From 2580749e17f1b39f69e282e1c05a6413710cf590 Mon Sep 17 00:00:00 2001 From: Aya Hassan Date: Thu, 16 Apr 2026 13:51:15 +0200 Subject: [PATCH] Add temp changes --- ...wrappers_helpers.py => wrapper_helpers.py} | 0 tests/wrappers_tests/test_basic_life_cycle.py | 26 ++++ tests/wrappers_tests/test_send_e2e.py | 135 ++++++++---------- 3 files changed, 82 insertions(+), 79 deletions(-) rename src/node/{wrappers_helpers.py => wrapper_helpers.py} (100%) create mode 100644 tests/wrappers_tests/test_basic_life_cycle.py diff --git a/src/node/wrappers_helpers.py b/src/node/wrapper_helpers.py similarity index 100% rename from src/node/wrappers_helpers.py rename to src/node/wrapper_helpers.py diff --git a/tests/wrappers_tests/test_basic_life_cycle.py b/tests/wrappers_tests/test_basic_life_cycle.py new file mode 100644 index 000000000..eb2026438 --- /dev/null +++ b/tests/wrappers_tests/test_basic_life_cycle.py @@ -0,0 +1,26 @@ +import pytest +from src.node.wrappers_manager import WrapperManager + + +@pytest.mark.smoke +class TestLogosDeliveryLifecycle: + def _create_start_node(self, node_config): + result = WrapperManager.create_and_start(config=node_config) + assert result.is_ok(), f"Failed to create and start node: {result.err()}" + return result.ok_value + + def test_create_start_and_stop_node(self, node_config): + node = self._create_start_node(node_config) + + stop_result = node.stop_and_destroy() + assert stop_result.is_ok(), f"Failed to stop and destroy node: {stop_result.err()}" + + def test_stop_node_without_destroy(self, node_config): + node = self._create_start_node(node_config) + + try: + stop_result = node.stop_node() + assert stop_result.is_ok(), f"Failed to stop node: {stop_result.err()}" + finally: + destroy_result = node.destroy() + assert destroy_result.is_ok(), f"Failed to destroy node: {destroy_result.err()}" diff --git a/tests/wrappers_tests/test_send_e2e.py b/tests/wrappers_tests/test_send_e2e.py index ede0e04a6..c65c77c20 100644 --- a/tests/wrappers_tests/test_send_e2e.py +++ b/tests/wrappers_tests/test_send_e2e.py @@ -1,23 +1,8 @@ -""" -S17 – No delivery peers at T0, relay peers appear later. - -Setup: Sender starts isolated (no peers). -Action: send() is called immediately. -Then: A relay peer is started with the sender's multiaddr as a static peer, - causing both nodes to connect and the sender's retry loop to deliver. -Expected: - - send() returns Ok(RequestId) synchronously even with no peers. - - A MessagePropagatedEvent with the same RequestId arrives once the - relay peer joins. - - No MessageErrorEvent arrives before the Propagated event. - -Reference: issue #163, scenario S17. -""" - import pytest - +from src.steps.common import StepsCommon +from src.libs.common import to_base64 from src.node.wrappers_manager import WrapperManager -from src.node.wrappers_helpers import ( +from src.node.wrapper_helpers import ( EventCollector, get_node_multiaddr, wait_for_propagated, @@ -28,86 +13,78 @@ CONTENT_TOPIC = "/test/1/s17-relay-late-join/proto" PROPAGATED_TIMEOUT_S = 30.0 -class TestS17RelayPeersAppearLater: - @pytest.fixture - def sender_collector(self): - return EventCollector() +class TestS17RelayPeersAppearLater(StepsCommon): + """ + S17 – No delivery peers at T0, relay peers appear later. + """ - @pytest.fixture - def sender_node(self, node_config, sender_collector): - # node_config is provided by the conftest.py fixture; - # override only what differs from the default for an isolated sender. - node_config.update({"relay": True, "store": False, "discv5Discovery": False}) - - result = WrapperManager.create_and_start(config=node_config, event_cb=sender_collector.event_callback) - assert result.is_ok(), f"Failed to start sender: {result.err()}" - - node = result.ok_value - yield node - node.stop_and_destroy() - - def test_send_before_relay_peers_exist_then_peer_joins(self, sender_node, sender_collector, node_config): + def test_send_before_relay_peers_exist_then_peer_joins(self, node_config): """ S17: send() is called while the sender has no peers. A relay peer is then brought online with the sender's address as a static peer, causing the sender's retry loop to deliver the message. """ + sender_collector = EventCollector() + node_config.update({"relay": True, "store": False, "discv5Discovery": False}) + + sender_result = WrapperManager.create_and_start(config=node_config, event_cb=sender_collector.event_callback) + assert sender_result.is_ok(), f"Failed to start sender: {sender_result.err()}" + sender_node = sender_result.ok_value + + # try: # Step 1: send while isolated — must return Ok(RequestId) immediately - message = { - "contentTopic": CONTENT_TOPIC, - "payload": "UzE3IHJlbGF5IGxhdGUgam9pbg==", # base64("S17 relay late join") - } - - send_result = sender_node.send_message(message) - + send_result = sender_node.send_message(message=self.create_message(payload=to_base64(f"Message"))) assert send_result.is_ok(), f"send() must return Ok(RequestId) even with no peers, got: {send_result.err()}" request_id = send_result.ok_value assert request_id, "send() returned an empty RequestId" + """ + # Step 2: get sender's multiaddr so the relay peer can dial back to it + sender_multiaddr = get_node_multiaddr(sender_node) - # Step 2: get sender's multiaddr so the relay peer can dial back to it - sender_multiaddr = get_node_multiaddr(sender_node) + # Step 3: start the relay peer with the sender listed as a static peer + relay_config = node_config.copy() + relay_config["staticPeers"] = [sender_multiaddr] - # Step 3: start the relay peer with the sender listed as a static peer. - # node_config produces a fresh config with its own free ports each call. - node_config.update({"relay": True, "store": False, "discv5Discovery": False}) - node_config["staticPeers"] = [sender_multiaddr] + relay_result = WrapperManager.create_and_start(config=relay_config) + assert relay_result.is_ok(), f"Failed to start relay peer: {relay_result.err()}" + relay_peer = relay_result.ok_value - relay_peer_result = WrapperManager.create_and_start(config=node_config) - assert relay_peer_result.is_ok(), f"Failed to start relay peer: {relay_peer_result.err()}" - relay_peer = relay_peer_result.ok_value + try: + # Step 4: wait for a Propagated event — the sender's retry loop should + # deliver the message now that a relay peer is reachable + propagated_event = wait_for_propagated( + collector=sender_collector, + request_id=request_id, + timeout_s=PROPAGATED_TIMEOUT_S, + ) - try: - # Step 4: wait for a Propagated event — the sender's retry loop should - # deliver the message now that a relay peer is reachable - propagated_event = wait_for_propagated( - collector=sender_collector, - request_id=request_id, - timeout_s=PROPAGATED_TIMEOUT_S, - ) + # Step 5: check no Error event arrived + error_event = wait_for_error( + collector=sender_collector, + request_id=request_id, + timeout_s=0, + ) - # Step 5: check no Error arrived before Propagated - error_event = wait_for_error( - collector=sender_collector, - request_id=request_id, - timeout_s=0, - ) + for event in sender_collector.get_events_for_request(request_id): + assert event.get("requestId") == request_id, f"Event carries wrong requestId: {event}" - # All events for this request must carry the same requestId - for event in sender_collector.get_events_for_request(request_id): - assert event.get("requestId") == request_id, f"Event carries wrong requestId: {event}" + assert propagated_event is not None, ( + f"No MessagePropagatedEvent received within {PROPAGATED_TIMEOUT_S}s " + f"after relay peer joined. Collected events: {sender_collector.events}" + ) - assert propagated_event is not None, ( - f"No MessagePropagatedEvent received within {PROPAGATED_TIMEOUT_S}s " - f"after relay peer joined. Collected events: {sender_collector.events}" - ) + assert error_event is None, ( + f"MessageErrorEvent arrived before Propagated — violates S17 expectations.\n" + f"Error : {error_event}\n" + f"Propagated: {propagated_event}" + ) - assert error_event is None, ( - f"MessageErrorEvent arrived before Propagated — violates S17 expectations.\n" - f"Error : {error_event}\n" - f"Propagated: {propagated_event}" - ) + finally: + relay_peer.stop_and_destroy() finally: - relay_peer.stop_and_destroy() + sender_node.stop_and_destroy() + + """