mirror of
https://github.com/logos-messaging/logos-messaging-interop-tests.git
synced 2026-05-24 03:09:58 +00:00
df69919a7b
* - Add S06 relay-only test case for testing message propagation without a store. - Update `wrapper_helpers` for clearer event type handling and type annotations (`Optional[...]` usage). - Simplify `get_node_multiaddr` to retrieve addresses via `get_node_info_raw`. - Refactor `wrappers_manager` to adjust bindings path to `vendor` directory and add `get_node_info_raw` method. - Update `.gitignore` to exclude `store.sqlite3*`. * Refactor S06 relay-only test: replace try-finally blocks with context managers for clarity and conciseness. * Migrate S06 relay-only test to `test_send_e2e.py` and refactor with `StepsCommon` for reusability. --------- Co-authored-by: Egor Rachkovskii <egorrachkovskii@status.im>
319 lines
13 KiB
Python
319 lines
13 KiB
Python
from time import time_ns
|
|
|
|
import pytest
|
|
from src.env_vars import NODE_2
|
|
from src.steps.common import StepsCommon
|
|
from src.libs.common import delay, to_base64
|
|
from src.libs.custom_logger import get_custom_logger
|
|
from src.node.waku_node import WakuNode
|
|
from src.node.wrappers_manager import WrapperManager
|
|
from src.node.wrapper_helpers import (
|
|
EventCollector,
|
|
get_node_multiaddr,
|
|
wait_for_propagated,
|
|
wait_for_sent,
|
|
wait_for_error,
|
|
)
|
|
from src.steps.store import StepsStore
|
|
|
|
logger = get_custom_logger(__name__)
|
|
|
|
|
|
PROPAGATED_TIMEOUT_S = 30.0
|
|
SENT_TIMEOUT_S = 10.0
|
|
NO_SENT_OBSERVATION_S = 5.0
|
|
DEFAULT_CONTENT_TOPIC = "/test/1/default/proto"
|
|
DEFAULT_PAYLOAD = "Default Payload"
|
|
SENT_AFTER_STORE_TIMEOUT_S = 60.0
|
|
|
|
|
|
@pytest.mark.smoke
|
|
class TestSendBeforeRelay(StepsStore):
|
|
def test_s17_send_before_relay_peers_joins(self, node_config):
|
|
"""
|
|
S17: sender starts isolated, calls send()
|
|
- send() returns Ok(RequestId) immediately
|
|
- Propagated event eventually arrives
|
|
"""
|
|
sender_collector = EventCollector()
|
|
|
|
node_config.update(
|
|
{
|
|
"relay": True,
|
|
"store": False,
|
|
"discv5Discovery": False,
|
|
"numShardsInNetwork": 1,
|
|
}
|
|
)
|
|
|
|
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()}"
|
|
|
|
with sender_result.ok_value as sender_node:
|
|
message = self.create_message()
|
|
send_result = sender_node.send_message(message=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: start a relay peer with store enabled.
|
|
relay_config = {
|
|
**node_config,
|
|
"staticnodes": [get_node_multiaddr(sender_node)],
|
|
"portsshift": 1,
|
|
"store": True,
|
|
}
|
|
|
|
relay_result = WrapperManager.create_and_start(config=relay_config)
|
|
assert relay_result.is_ok(), f"Failed to start relay peer: {relay_result.err()}"
|
|
|
|
with relay_result.ok_value:
|
|
propagated_event = wait_for_propagated(
|
|
collector=sender_collector,
|
|
request_id=request_id,
|
|
timeout_s=PROPAGATED_TIMEOUT_S,
|
|
)
|
|
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}"
|
|
)
|
|
sent_event = wait_for_sent(
|
|
collector=sender_collector,
|
|
request_id=request_id,
|
|
timeout_s=SENT_TIMEOUT_S,
|
|
)
|
|
assert sent_event is not None, (
|
|
f"No MessageSentEvent received within {SENT_TIMEOUT_S}s "
|
|
f"from a store-enabled relay peer. Collected events: {sender_collector.events}"
|
|
)
|
|
|
|
def test_s17_no_sent_event_when_relay_has_no_store(self, node_config):
|
|
"""
|
|
S17 negative: relay peerstore=false, there shouldn't be a Sent event,.
|
|
"""
|
|
sender_collector = EventCollector()
|
|
|
|
node_config.update(
|
|
{
|
|
"relay": True,
|
|
"store": False,
|
|
"discv5Discovery": False,
|
|
"numShardsInNetwork": 1,
|
|
}
|
|
)
|
|
|
|
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()}"
|
|
|
|
with sender_result.ok_value as sender_node:
|
|
send_result = sender_node.send_message(message=self.create_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"
|
|
|
|
relay_config = {
|
|
**node_config,
|
|
"staticnodes": [get_node_multiaddr(sender_node)],
|
|
"portsshift": 1,
|
|
"store": False,
|
|
}
|
|
|
|
relay_result = WrapperManager.create_and_start(config=relay_config)
|
|
assert relay_result.is_ok(), f"Failed to start relay peer: {relay_result.err()}"
|
|
|
|
with relay_result.ok_value:
|
|
propagated_event = wait_for_propagated(
|
|
collector=sender_collector,
|
|
request_id=request_id,
|
|
timeout_s=PROPAGATED_TIMEOUT_S,
|
|
)
|
|
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}"
|
|
)
|
|
|
|
sent_event = wait_for_sent(
|
|
collector=sender_collector,
|
|
request_id=request_id,
|
|
timeout_s=SENT_TIMEOUT_S,
|
|
)
|
|
assert sent_event is None, (
|
|
f"Unexpected MessageSentEvent received when relay peer has store=false.\n"
|
|
f"Sent event: {sent_event}\n"
|
|
f"Collected events: {sender_collector.events}"
|
|
)
|
|
|
|
def test_s19_store_peer_appears_after_propagation(self, node_config):
|
|
"""
|
|
S19: a store peer comes online later.
|
|
question for Zoltan , is reliability = true mandatory for the store peer ?
|
|
what is the effect of the reliability here ?
|
|
- send() returns Ok(RequestId) immediately
|
|
- Propagated --- relay peer
|
|
- Sent when store peer is reachable
|
|
"""
|
|
sender_collector = EventCollector()
|
|
|
|
sender_collector = EventCollector()
|
|
|
|
node_config.update(
|
|
{
|
|
"relay": True,
|
|
"store": False,
|
|
"discv5Discovery": False,
|
|
"numShardsInNetwork": 1,
|
|
"reliability": True,
|
|
}
|
|
)
|
|
|
|
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()}"
|
|
|
|
with sender_result.ok_value as sender_node:
|
|
# Relay-only wrapper peer so propagation can complete without any
|
|
# store peer being reachable yet.
|
|
relay_config = {
|
|
**node_config,
|
|
"staticnodes": [get_node_multiaddr(sender_node)],
|
|
"portsshift": 1,
|
|
"store": False,
|
|
"reliability": False,
|
|
}
|
|
|
|
relay_result = WrapperManager.create_and_start(config=relay_config)
|
|
assert relay_result.is_ok(), f"Failed to start relay peer: {relay_result.err()}"
|
|
|
|
with relay_result.ok_value as relay_peer:
|
|
# Step 1: send(). Must return Ok(RequestId) immediately.
|
|
message = self.create_message()
|
|
send_result = sender_node.send_message(message=message)
|
|
assert send_result.is_ok(), f"send() must return Ok(RequestId), got: {send_result.err()}"
|
|
|
|
request_id = send_result.ok_value
|
|
assert request_id, "send() returned an empty RequestId"
|
|
|
|
# Step 2: Propagated should arrive via the relay peer.
|
|
propagated_event = wait_for_propagated(
|
|
collector=sender_collector,
|
|
request_id=request_id,
|
|
timeout_s=PROPAGATED_TIMEOUT_S,
|
|
)
|
|
assert propagated_event is not None, (
|
|
f"No MessagePropagatedEvent received within {PROPAGATED_TIMEOUT_S}s. " f"Collected events: {sender_collector.events}"
|
|
)
|
|
|
|
# Step 3: with no store peer reachable, Sent must not arrive yet.
|
|
early_sent_event = wait_for_sent(
|
|
collector=sender_collector,
|
|
request_id=request_id,
|
|
timeout_s=NO_SENT_OBSERVATION_S,
|
|
)
|
|
assert early_sent_event is None, f"MessageSentEvent arrived before any store peer was reachable. " f"Event: {early_sent_event}"
|
|
|
|
# Step 4: bring a docker store node online, wired into the
|
|
# existing mesh via REST. Teardown is handled by the autouse
|
|
# close_open_nodes fixture in tests/conftest.py.
|
|
store_node = WakuNode(NODE_2, f"store_node")
|
|
store_node.start(relay="true", store="true", discv5_discovery="false")
|
|
store_node.set_relay_subscriptions([self.test_pubsub_topic])
|
|
relay_multiaddr = get_node_multiaddr(relay_peer)
|
|
sender_multiaddr = get_node_multiaddr(sender_node)
|
|
store_node.add_peers([relay_multiaddr, sender_multiaddr])
|
|
delay(3)
|
|
|
|
sent_event = wait_for_sent(
|
|
collector=sender_collector,
|
|
request_id=request_id,
|
|
timeout_s=SENT_AFTER_STORE_TIMEOUT_S,
|
|
)
|
|
assert sent_event is not None, (
|
|
f"No MessageSentEvent received within {SENT_AFTER_STORE_TIMEOUT_S}s "
|
|
f"after store peer joined. Collected events: {sender_collector.events}"
|
|
)
|
|
|
|
self.check_published_message_is_stored(
|
|
store_node=store_node,
|
|
pubsub_topic=self.test_pubsub_topic,
|
|
messages_to_check=[message],
|
|
page_size=5,
|
|
ascending="true",
|
|
)
|
|
|
|
|
|
class TestS06CoreSenderRelayOnly(StepsCommon):
|
|
"""
|
|
S06 — Core sender with relay peers only, no store.
|
|
Sender has local relay enabled and is connected to one relay peer.
|
|
Expected: send() returns Ok(RequestId), message_propagated event arrives,
|
|
no message_sent (store disabled), no message_error.
|
|
"""
|
|
|
|
def test_s06_relay_propagation_without_store(self, node_config):
|
|
sender_collector = EventCollector()
|
|
|
|
node_config.update(
|
|
{
|
|
"relay": True,
|
|
"store": False,
|
|
"lightpush": False,
|
|
"filter": False,
|
|
"discv5Discovery": False,
|
|
"numShardsInNetwork": 1,
|
|
}
|
|
)
|
|
|
|
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()}"
|
|
|
|
with sender_result.ok_value as sender:
|
|
peer_config = {
|
|
**node_config,
|
|
"staticnodes": [get_node_multiaddr(sender)],
|
|
"portsshift": 1,
|
|
}
|
|
|
|
peer_result = WrapperManager.create_and_start(config=peer_config)
|
|
assert peer_result.is_ok(), f"Failed to start relay peer: {peer_result.err()}"
|
|
|
|
with peer_result.ok_value:
|
|
message = self.create_message(
|
|
payload=to_base64("S06 relay-only test payload"),
|
|
contentTopic="/test/1/s06-relay-only/proto",
|
|
)
|
|
|
|
send_result = sender.send_message(message=message)
|
|
assert send_result.is_ok(), f"send() failed: {send_result.err()}"
|
|
|
|
request_id = send_result.ok_value
|
|
assert request_id, "send() returned an empty RequestId"
|
|
|
|
propagated = wait_for_propagated(
|
|
collector=sender_collector,
|
|
request_id=request_id,
|
|
timeout_s=PROPAGATED_TIMEOUT_S,
|
|
)
|
|
assert propagated is not None, (
|
|
f"No message_propagated event within {PROPAGATED_TIMEOUT_S}s. " f"Collected events: {sender_collector.events}"
|
|
)
|
|
assert propagated["requestId"] == request_id
|
|
|
|
error = wait_for_error(sender_collector, request_id, timeout_s=0)
|
|
assert error is None, f"Unexpected message_error event: {error}"
|
|
|
|
sent = wait_for_sent(sender_collector, request_id, timeout_s=0)
|
|
assert sent is None, f"Unexpected message_sent event (store is disabled): {sent}"
|