From aa01a9f88f96ae30f6de6f0026b5a4ee8ea1a348 Mon Sep 17 00:00:00 2001 From: Aya Hassan Date: Sun, 12 Jul 2026 19:21:06 +0200 Subject: [PATCH 1/4] adding first test and wrapper --- src/node/wrappers_manager.py | 16 ++++++++++ .../wrappers_tests/test_channel_lifecycle.py | 30 +++++++++++++++++++ vendor/logos-delivery-python-bindings | 2 +- 3 files changed, 47 insertions(+), 1 deletion(-) create mode 100644 tests/wrappers_tests/test_channel_lifecycle.py diff --git a/src/node/wrappers_manager.py b/src/node/wrappers_manager.py index 2a0e84982..8b59bcb4f 100644 --- a/src/node/wrappers_manager.py +++ b/src/node/wrappers_manager.py @@ -75,6 +75,22 @@ class WrapperManager: def send_message(self, message: dict, *, timeout_s: float = 20.0) -> Result[str, str]: return self._node.send_message(message, timeout_s=timeout_s) + def channel_create( + self, + channel_id: str, + content_topic: str, + sender_id: str, + *, + timeout_s: float = 20.0, + ) -> Result[str, str]: + return self._node.channel_create(channel_id, content_topic, sender_id, timeout_s=timeout_s) + + def channel_send(self, channel_id: str, message: dict, *, timeout_s: float = 20.0) -> Result[str, str]: + return self._node.channel_send(channel_id, message, timeout_s=timeout_s) + + def channel_close(self, channel_id: str, *, timeout_s: float = 20.0) -> Result[int, str]: + return self._node.channel_close(channel_id, timeout_s=timeout_s) + def get_available_node_info_ids(self, *, timeout_s: float = 20.0) -> Result[list[str], str]: return self._node.get_available_node_info_ids(timeout_s=timeout_s) diff --git a/tests/wrappers_tests/test_channel_lifecycle.py b/tests/wrappers_tests/test_channel_lifecycle.py new file mode 100644 index 000000000..d39841361 --- /dev/null +++ b/tests/wrappers_tests/test_channel_lifecycle.py @@ -0,0 +1,30 @@ +import pytest +from src.node.wrappers_manager import WrapperManager + +CHANNEL_ID = "rc01-channel" +CONTENT_TOPIC = "/test/1/channel/proto" +SENDER_ID = "rc01-sender" + + +@pytest.mark.smoke +class TestChannelLifecycle: + def test_rc01_create_channel_duplicate_rejected(self, node_config): + """RC01: create a channel; a duplicate create with the same id is rejected. + + The reliable channel manager is mounted automatically for a Core-mode + node, so no store / --reliability is needed. No events are expected. + """ + create_node_result = WrapperManager.create_and_start(config=node_config) + assert create_node_result.is_ok(), f"Failed to create and start node: {create_node_result.err()}" + node = create_node_result.ok_value + + try: + create_result = node.channel_create(CHANNEL_ID, CONTENT_TOPIC, SENDER_ID) + assert create_result.is_ok(), f"channel_create failed: {create_result.err()}" + assert create_result.ok_value == CHANNEL_ID, f"channel_create returned unexpected id: {create_result.ok_value!r}" + + duplicate_result = node.channel_create(CHANNEL_ID, CONTENT_TOPIC, SENDER_ID) + assert duplicate_result.is_err(), f"duplicate channel_create must fail, got Ok({duplicate_result.ok_value!r})" + assert f"channel already exists: {CHANNEL_ID}" in duplicate_result.err(), f"unexpected error message: {duplicate_result.err()!r}" + finally: + node.stop_and_destroy() diff --git a/vendor/logos-delivery-python-bindings b/vendor/logos-delivery-python-bindings index 36041dae7..694833acf 160000 --- a/vendor/logos-delivery-python-bindings +++ b/vendor/logos-delivery-python-bindings @@ -1 +1 @@ -Subproject commit 36041dae76a53fff91fe53253933d8eb2ab385f9 +Subproject commit 694833acfb632105a4d5ab010edfdbe1dd46bbce From 040eca1394f607422f9e27c4aa4d39401314584b Mon Sep 17 00:00:00 2001 From: Aya Hassan Date: Tue, 14 Jul 2026 10:09:23 +0200 Subject: [PATCH 2/4] add mode core , ignore generated files --- .gitignore | 3 +++ tests/wrappers_tests/test_channel_lifecycle.py | 2 ++ vendor/logos-delivery-python-bindings | 2 +- 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 7d7cfc8b6..dff4b9035 100644 --- a/.gitignore +++ b/.gitignore @@ -107,3 +107,6 @@ dmypy.json # Waku node runtime artifacts store.sqlite3* + +# SDS / reliable channel manager generated files +data/ diff --git a/tests/wrappers_tests/test_channel_lifecycle.py b/tests/wrappers_tests/test_channel_lifecycle.py index d39841361..7448934cd 100644 --- a/tests/wrappers_tests/test_channel_lifecycle.py +++ b/tests/wrappers_tests/test_channel_lifecycle.py @@ -14,6 +14,8 @@ class TestChannelLifecycle: The reliable channel manager is mounted automatically for a Core-mode node, so no store / --reliability is needed. No events are expected. """ + node_config.update({"mode": "Core"}) + create_node_result = WrapperManager.create_and_start(config=node_config) assert create_node_result.is_ok(), f"Failed to create and start node: {create_node_result.err()}" node = create_node_result.ok_value diff --git a/vendor/logos-delivery-python-bindings b/vendor/logos-delivery-python-bindings index 694833acf..5fb251bd8 160000 --- a/vendor/logos-delivery-python-bindings +++ b/vendor/logos-delivery-python-bindings @@ -1 +1 @@ -Subproject commit 694833acfb632105a4d5ab010edfdbe1dd46bbce +Subproject commit 5fb251bd8c6cae40e36a59874d5bc747f52230bd From f0ae29a9f28ceb7c7d1459b7c6b487ee909abab0 Mon Sep 17 00:00:00 2001 From: Aya Hassan Date: Tue, 14 Jul 2026 10:23:17 +0200 Subject: [PATCH 3/4] added test RC02 --- .../wrappers_tests/test_channel_lifecycle.py | 29 ++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/tests/wrappers_tests/test_channel_lifecycle.py b/tests/wrappers_tests/test_channel_lifecycle.py index 7448934cd..5f9beee40 100644 --- a/tests/wrappers_tests/test_channel_lifecycle.py +++ b/tests/wrappers_tests/test_channel_lifecycle.py @@ -1,10 +1,13 @@ import pytest from src.node.wrappers_manager import WrapperManager +from src.node.wrapper_helpers import EventCollector, create_message_bindings CHANNEL_ID = "rc01-channel" CONTENT_TOPIC = "/test/1/channel/proto" SENDER_ID = "rc01-sender" +UNKNOWN_CHANNEL_ID = "rc02-unknown-channel" + @pytest.mark.smoke class TestChannelLifecycle: @@ -16,7 +19,8 @@ class TestChannelLifecycle: """ node_config.update({"mode": "Core"}) - create_node_result = WrapperManager.create_and_start(config=node_config) + collector = EventCollector() + create_node_result = WrapperManager.create_and_start(config=node_config, event_cb=collector.event_callback) assert create_node_result.is_ok(), f"Failed to create and start node: {create_node_result.err()}" node = create_node_result.ok_value @@ -28,5 +32,28 @@ class TestChannelLifecycle: duplicate_result = node.channel_create(CHANNEL_ID, CONTENT_TOPIC, SENDER_ID) assert duplicate_result.is_err(), f"duplicate channel_create must fail, got Ok({duplicate_result.ok_value!r})" assert f"channel already exists: {CHANNEL_ID}" in duplicate_result.err(), f"unexpected error message: {duplicate_result.err()!r}" + + assert collector.events == [], f"expected no events, got: {collector.events}" + finally: + node.stop_and_destroy() + + def test_rc02_send_on_unknown_channel_rejected(self, node_config): + """RC02: channel_send() to an id that was never created is rejected. + + The send must Err with "unknown channel: " and emit no events. + """ + node_config.update({"mode": "Core"}) + + collector = EventCollector() + create_node_result = WrapperManager.create_and_start(config=node_config, event_cb=collector.event_callback) + assert create_node_result.is_ok(), f"Failed to create and start node: {create_node_result.err()}" + node = create_node_result.ok_value + + try: + send_result = node.channel_send(UNKNOWN_CHANNEL_ID, create_message_bindings()) + assert send_result.is_err(), f"channel_send on unknown channel must fail, got Ok({send_result.ok_value!r})" + assert f"unknown channel: {UNKNOWN_CHANNEL_ID}" in send_result.err(), f"unexpected error message: {send_result.err()!r}" + + assert collector.events == [], f"expected no events, got: {collector.events}" finally: node.stop_and_destroy() From cd25689555b276f4b3cc7026188a6e78061ca52c Mon Sep 17 00:00:00 2001 From: Aya Hassan Date: Tue, 14 Jul 2026 18:49:53 +0200 Subject: [PATCH 4/4] Add RC03/RC04 and other variants --- .../wrappers_tests/test_channel_lifecycle.py | 168 ++++++++++++++++++ 1 file changed, 168 insertions(+) diff --git a/tests/wrappers_tests/test_channel_lifecycle.py b/tests/wrappers_tests/test_channel_lifecycle.py index 5f9beee40..fe1e3663a 100644 --- a/tests/wrappers_tests/test_channel_lifecycle.py +++ b/tests/wrappers_tests/test_channel_lifecycle.py @@ -1,6 +1,9 @@ +import uuid + import pytest from src.node.wrappers_manager import WrapperManager from src.node.wrapper_helpers import EventCollector, create_message_bindings +from src.libs.common import delay CHANNEL_ID = "rc01-channel" CONTENT_TOPIC = "/test/1/channel/proto" @@ -8,6 +11,16 @@ SENDER_ID = "rc01-sender" UNKNOWN_CHANNEL_ID = "rc02-unknown-channel" +RC03_CHANNEL_ID = "rc03-channel" + +RC04_CHANNEL_ID = "rc04-channel" +RC04_EPHEMERAL_CHANNEL_ID = "rc04-ephemeral-channel" +RC04_DISTINCT_CHANNEL_ID = "rc04-distinct-channel" + +# Give the reliable channel manager a moment to settle a freshly-created +# channel before we act on it. +CHANNEL_SETTLE_S = 1 + @pytest.mark.smoke class TestChannelLifecycle: @@ -57,3 +70,158 @@ class TestChannelLifecycle: assert collector.events == [], f"expected no events, got: {collector.events}" finally: node.stop_and_destroy() + + def test_rc03_close_channel_close_unknown_rejected(self, node_config): + """RC03: close an existing channel; closing again / an unknown id is rejected. + + First close succeeds; a second close of the same (now-gone) id and a + close of a never-created id both Err with "unknown channel: ". + Lifecycle teardown + idempotency guard. No events are expected. + """ + node_config.update({"mode": "Core"}) + + collector = EventCollector() + create_node_result = WrapperManager.create_and_start(config=node_config, event_cb=collector.event_callback) + assert create_node_result.is_ok(), f"Failed to create and start node: {create_node_result.err()}" + node = create_node_result.ok_value + + try: + create_result = node.channel_create(RC03_CHANNEL_ID, CONTENT_TOPIC, SENDER_ID) + assert create_result.is_ok(), f"channel_create failed: {create_result.err()}" + + delay(CHANNEL_SETTLE_S) + + close_result = node.channel_close(RC03_CHANNEL_ID) + assert close_result.is_ok(), f"channel_close on an existing channel failed: {close_result.err()}" + + reclose_result = node.channel_close(RC03_CHANNEL_ID) + assert reclose_result.is_err(), f"second channel_close must fail, got Ok({reclose_result.ok_value!r})" + assert f"unknown channel: {RC03_CHANNEL_ID}" in reclose_result.err(), f"unexpected error message: {reclose_result.err()!r}" + + unknown_close_result = node.channel_close(UNKNOWN_CHANNEL_ID) + assert unknown_close_result.is_err(), f"channel_close on unknown channel must fail, got Ok({unknown_close_result.ok_value!r})" + assert f"unknown channel: {UNKNOWN_CHANNEL_ID}" in unknown_close_result.err(), f"unexpected error message: {unknown_close_result.err()!r}" + + assert collector.events == [], f"expected no events, got: {collector.events}" + finally: + node.stop_and_destroy() + + def test_rc03_close_random_id_leaves_open_channel_intact(self, node_config): + """RC03 variant: closing a random unknown id while a real channel is open. + + A genuine channel is created and left open; closing a random id Errs with + "unknown channel: " and must not disturb the open channel, which then + still closes cleanly. No events are expected. + """ + node_config.update({"mode": "Core"}) + + channel_id = f"rc03-open-{uuid.uuid4()}" + random_id = f"rc03-random-{uuid.uuid4()}" + + collector = EventCollector() + create_node_result = WrapperManager.create_and_start(config=node_config, event_cb=collector.event_callback) + assert create_node_result.is_ok(), f"Failed to create and start node: {create_node_result.err()}" + node = create_node_result.ok_value + + try: + create_result = node.channel_create(channel_id, CONTENT_TOPIC, SENDER_ID) + assert create_result.is_ok(), f"channel_create failed: {create_result.err()}" + + delay(CHANNEL_SETTLE_S) + + random_close_result = node.channel_close(random_id) + assert random_close_result.is_err(), f"channel_close on a random id must fail, got Ok({random_close_result.ok_value!r})" + assert f"unknown channel: {random_id}" in random_close_result.err(), f"unexpected error message: {random_close_result.err()!r}" + + # The real channel was left untouched and still closes cleanly. + close_result = node.channel_close(channel_id) + assert close_result.is_ok(), f"open channel_close failed after a bad-id close: {close_result.err()}" + + assert collector.events == [], f"expected no events, got: {collector.events}" + finally: + node.stop_and_destroy() + + def test_rc04_empty_payload_rejected_and_send_returns_handle(self, node_config): + """RC04: empty payload is rejected; a non-empty send returns a handle synchronously. + + channel_send with an empty payload Errs with "empty payload"; a normal + channel_send returns Ok(channelReqId) immediately (delivery is async). + Input validation + the immediate-handle contract of send. + """ + node_config.update({"mode": "Core"}) + + create_node_result = WrapperManager.create_and_start(config=node_config) + assert create_node_result.is_ok(), f"Failed to create and start node: {create_node_result.err()}" + node = create_node_result.ok_value + + try: + create_result = node.channel_create(RC04_CHANNEL_ID, CONTENT_TOPIC, SENDER_ID) + assert create_result.is_ok(), f"channel_create failed: {create_result.err()}" + + delay(CHANNEL_SETTLE_S) + + empty_result = node.channel_send(RC04_CHANNEL_ID, create_message_bindings(payload="")) + assert empty_result.is_err(), f"channel_send with an empty payload must fail, got Ok({empty_result.ok_value!r})" + assert "empty payload" in empty_result.err(), f"unexpected error message: {empty_result.err()!r}" + + send_result = node.channel_send(RC04_CHANNEL_ID, create_message_bindings()) + assert send_result.is_ok(), f"channel_send with a non-empty payload failed: {send_result.err()}" + assert send_result.ok_value, f"channel_send must return a non-empty channelReqId handle, got: {send_result.ok_value!r}" + finally: + node.stop_and_destroy() + + def test_rc04_ephemeral_send_returns_handle(self, node_config): + """RC04 variant: an ephemeral channel_send still returns a handle synchronously. + + The ephemeral flag only affects downstream persistence / terminal events, + not the send contract, so channel_send returns Ok(channelReqId) immediately. + """ + node_config.update({"mode": "Core"}) + + create_node_result = WrapperManager.create_and_start(config=node_config) + assert create_node_result.is_ok(), f"Failed to create and start node: {create_node_result.err()}" + node = create_node_result.ok_value + + try: + create_result = node.channel_create(RC04_EPHEMERAL_CHANNEL_ID, CONTENT_TOPIC, SENDER_ID) + assert create_result.is_ok(), f"channel_create failed: {create_result.err()}" + + delay(CHANNEL_SETTLE_S) + + send_result = node.channel_send(RC04_EPHEMERAL_CHANNEL_ID, create_message_bindings(ephemeral=True)) + assert send_result.is_ok(), f"ephemeral channel_send failed: {send_result.err()}" + assert send_result.ok_value, f"channel_send must return a non-empty channelReqId handle, got: {send_result.ok_value!r}" + finally: + node.stop_and_destroy() + + def test_rc04_sequential_sends_return_distinct_handles(self, node_config): + """RC04 variant: back-to-back sends each return a distinct handle. + + Every channel_send is its own request, so two sends on the same channel + return two different (non-empty) channelReqId handles. + """ + node_config.update({"mode": "Core"}) + + create_node_result = WrapperManager.create_and_start(config=node_config) + assert create_node_result.is_ok(), f"Failed to create and start node: {create_node_result.err()}" + node = create_node_result.ok_value + + try: + create_result = node.channel_create(RC04_DISTINCT_CHANNEL_ID, CONTENT_TOPIC, SENDER_ID) + assert create_result.is_ok(), f"channel_create failed: {create_result.err()}" + + delay(CHANNEL_SETTLE_S) + + first_result = node.channel_send(RC04_DISTINCT_CHANNEL_ID, create_message_bindings()) + assert first_result.is_ok(), f"first channel_send failed: {first_result.err()}" + assert first_result.ok_value, f"first channel_send returned an empty handle: {first_result.ok_value!r}" + + second_result = node.channel_send(RC04_DISTINCT_CHANNEL_ID, create_message_bindings()) + assert second_result.is_ok(), f"second channel_send failed: {second_result.err()}" + assert second_result.ok_value, f"second channel_send returned an empty handle: {second_result.ok_value!r}" + + assert ( + first_result.ok_value != second_result.ok_value + ), f"channel_send handles must be distinct, got the same id twice: {first_result.ok_value!r}" + finally: + node.stop_and_destroy()