mirror of
https://github.com/logos-messaging/logos-messaging-nim.git
synced 2026-08-11 09:53:19 +00:00
342a965370
* test(e2e): port remaining wrapper tests from the interop repo The wrapper suite that moved into tests-e2e (#4027) was a reworked subset of the one still living in logos-delivery-interop-tests. Comparing both sides showed 21 tests here against 46 there, with no overlap in the delta: the 25 missing tests cover scenarios the reworked set never included. Ports those 25 tests, bringing the in-repo suite to the full 46: - 12 send scenarios: s01 (nil/destroyed handle), s03, s04, s05, s11, s13, s16, s18 (both orderings), s25, s29 - 7 channel lifecycle tests (rc01-rc04) - 6 wrapper corner cases: auto port allocation, MyBoundPorts, ENR Supporting changes the ported tests need: - wrapper_helpers: get_node_tcp_port, get_node_bound_ports, enr_udp_port - WrapperManager: channel_create/send/close, destroy_keep_ctx - vendored binding refreshed to the revision exposing the channel API (additive only; cffi resolves symbols lazily, so nothing existing moves) Two Edge senders were fixed while porting. build_node_config defaults relay and store to True, and the flat-JSON config path applies mode=Edge before explicit fields, so those defaults win: the Edge nodes in s11/s16/s25 came up as relay and store servers and exercised the relay path instead of lightpush. They now set relay=False and store=False, matching test_send_e2e_part2. s16 also dropped lightpush=True, which mounts the lightpush server and fails node start once relay is off; the lightpush client mounts unconditionally. Suite goes from 21 to 46 functions (53 collected). The docker subset grows from 3 to 5 as s11 and s25 need a store peer. Local run against a freshly built library: 45 passed, 2 skipped, 1 xfailed. * test(e2e): enable autosharding in the channel lifecycle tests channel_create subscribes to the channel's content topic since #4081, and resolving that topic to a shard needs autosharding. build_node_config leaves numShardsInNetwork at 0 and cluster 198 has no preset, so these nodes came up with static sharding and every channel_create failed with "autosharding is not configured; pass an explicit shard". Adds numShardsInNetwork=1 to the six tests that create a channel, matching what every other wrapper test that touches the send or channel API already does. rc02 is left alone: channel_send rejects on the id lookup before any shard is resolved. Verified locally against a fresh build: the five tests that complete now pass and the error string is gone from the run.
102 lines
3.9 KiB
Python
102 lines
3.9 KiB
Python
import sys
|
|
from pathlib import Path
|
|
from result import Result, Ok, Err
|
|
|
|
_BINDINGS_PATH = Path(__file__).resolve().parents[2] / "vendor" / "logos-delivery-python-bindings" / "waku"
|
|
if str(_BINDINGS_PATH) not in sys.path:
|
|
sys.path.insert(0, str(_BINDINGS_PATH))
|
|
|
|
from wrapper import NodeWrapper as _NodeWrapper # type: ignore[import]
|
|
|
|
""""
|
|
thin manager/wrapper layer around NodeWrapper from the bindings.
|
|
It simplifies create, start, and interaction with a Waku node while returning consistent Result objects (Ok / Err).
|
|
"""
|
|
|
|
|
|
class WrapperManager:
|
|
def __init__(self, node: _NodeWrapper):
|
|
self._node = node
|
|
|
|
@classmethod
|
|
def create(
|
|
cls,
|
|
config: dict,
|
|
event_cb=None,
|
|
*,
|
|
timeout_s: float = 20.0,
|
|
) -> Result["WrapperManager", str]:
|
|
result = _NodeWrapper.create_node(config, event_cb, timeout_s=timeout_s)
|
|
if result.is_err():
|
|
return Err(result.err())
|
|
return Ok(cls(result.ok_value))
|
|
|
|
@classmethod
|
|
def create_and_start(
|
|
cls,
|
|
config: dict,
|
|
event_cb=None,
|
|
*,
|
|
timeout_s: float = 20.0,
|
|
) -> Result["WrapperManager", str]:
|
|
result = _NodeWrapper.create_and_start(config, event_cb, timeout_s=timeout_s)
|
|
if result.is_err():
|
|
return Err(result.err())
|
|
return Ok(cls(result.ok_value))
|
|
|
|
def __enter__(self) -> "WrapperManager":
|
|
return self
|
|
|
|
def __exit__(self, *_) -> None:
|
|
self.stop_and_destroy()
|
|
|
|
def start_node(self, *, timeout_s: float = 20.0) -> Result[int, str]:
|
|
return self._node.start_node(timeout_s=timeout_s)
|
|
|
|
def stop_node(self, *, timeout_s: float = 20.0) -> Result[int, str]:
|
|
return self._node.stop_node(timeout_s=timeout_s)
|
|
|
|
def destroy(self, *, timeout_s: float = 20.0) -> Result[int, str]:
|
|
return self._node.destroy(timeout_s=timeout_s)
|
|
|
|
def stop_and_destroy(self, *, timeout_s: float = 20.0) -> Result[int, str]:
|
|
return self._node.stop_and_destroy(timeout_s=timeout_s)
|
|
|
|
def destroy_keep_ctx(self, *, timeout_s: float = 20.0) -> Result[int, str]:
|
|
"""Pass-through for NodeWrapper.destroy_keep_ctx — see that method."""
|
|
return self._node.destroy_keep_ctx(timeout_s=timeout_s)
|
|
|
|
def subscribe_content_topic(self, content_topic: str, *, timeout_s: float = 20.0) -> Result[int, str]:
|
|
return self._node.subscribe_content_topic(content_topic, timeout_s=timeout_s)
|
|
|
|
def unsubscribe_content_topic(self, content_topic: str, *, timeout_s: float = 20.0) -> Result[int, str]:
|
|
return self._node.unsubscribe_content_topic(content_topic, timeout_s=timeout_s)
|
|
|
|
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[str, 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)
|
|
|
|
def get_node_info(self, node_info_id: str, *, timeout_s: float = 20.0) -> Result[str, str]:
|
|
return self._node.get_node_info(node_info_id, timeout_s=timeout_s)
|
|
|
|
def get_available_configs(self, *, timeout_s: float = 20.0) -> Result[dict, str]:
|
|
return self._node.get_available_configs(timeout_s=timeout_s)
|