Add temp changes

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()}"

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()
+            
+            """