chore: RLN relay tests

src/env_vars.py

@@ -14,8 +14,8 @@ def get_env_var(var_name, default=None):
 
 
 # Configuration constants. Need to be upercase to appear in reports
-DEFAULT_NWAKU = "harbor.status.im/wakuorg/nwaku:latest"
-DEFAULT_GOWAKU = "harbor.status.im/wakuorg/go-waku:latest"
+DEFAULT_NWAKU = "wakuorg/nwaku:latest"
+DEFAULT_GOWAKU = "wakuorg/go-waku:latest"
 NODE_1 = get_env_var("NODE_1", DEFAULT_GOWAKU)
 NODE_2 = get_env_var("NODE_2", DEFAULT_NWAKU)
 ADDITIONAL_NODES = get_env_var("ADDITIONAL_NODES", f"{DEFAULT_NWAKU},{DEFAULT_GOWAKU},{DEFAULT_NWAKU}")

src/node/waku_node.py

@@ -114,6 +114,8 @@ def start(self, **kwargs):
         else:
             logger.info(f"RLN credentials not set or credential store not available, starting without RLN")
 
+        logger.debug(f"Using volumes {self._volumes}")
+
         self._container = self._docker_manager.start_container(
             self._docker_manager.image, self._ports, default_args, self._log_path, self._ext_ip, self._volumes
         )

src/steps/relay.py

@@ -1,20 +1,17 @@
 import inspect
-import os
 from src.libs.custom_logger import get_custom_logger
 from time import time
 import pytest
 import allure
-from src.libs.common import to_base64, delay, gen_step_id
+from src.libs.common import to_base64, delay
 from src.node.waku_message import WakuMessage
 from src.env_vars import (
     NODE_1,
     NODE_2,
     ADDITIONAL_NODES,
     NODEKEY,
-    DEFAULT_NWAKU,
-    RLN_CREDENTIALS,
 )
-from src.node.waku_node import WakuNode, rln_credential_store_ready
+from src.node.waku_node import WakuNode
 from tenacity import retry, stop_after_delay, wait_fixed
 from src.test_data import VALID_PUBSUB_TOPICS
 
@@ -45,29 +42,6 @@ def setup_main_relay_nodes(self, request):
             self.node2.add_peers([self.multiaddr_with_id])
         self.main_nodes.extend([self.node1, self.node2])
 
-    @pytest.fixture(scope="function")
-    def register_main_rln_relay_nodes(self, request):
-        logger.debug(f"Registering RLN credentials: {inspect.currentframe().f_code.co_name}")
-        self.node1 = WakuNode(DEFAULT_NWAKU, f"node1_{request.cls.test_id}")
-        self.node1.register_rln(rln_creds_source=RLN_CREDENTIALS, rln_creds_id="1")
-        self.node2 = WakuNode(DEFAULT_NWAKU, f"node2_{request.cls.test_id}")
-        self.node2.register_rln(rln_creds_source=RLN_CREDENTIALS, rln_creds_id="2")
-        self.main_nodes.extend([self.node1, self.node2])
-
-    @pytest.fixture(scope="function")
-    def setup_main_rln_relay_nodes(self, request):
-        logger.debug(f"Running fixture setup: {inspect.currentframe().f_code.co_name}")
-        self.node1 = WakuNode(DEFAULT_NWAKU, f"node1_{request.cls.test_id}")
-        self.node1.start(relay="true", nodekey=NODEKEY, rln_creds_source=RLN_CREDENTIALS, rln_creds_id="1", rln_relay_membership_index="1")
-        self.enr_uri = self.node1.get_enr_uri()
-        self.node2 = WakuNode(DEFAULT_NWAKU, f"node2_{request.cls.test_id}")
-        self.node2.start(
-            relay="true", discv5_bootstrap_node=self.enr_uri, rln_creds_source=RLN_CREDENTIALS, rln_creds_id="2", rln_relay_membership_index="1"
-        )
-        if self.node2.is_nwaku():
-            self.node2.add_peers([self.multiaddr_with_id])
-        self.main_nodes.extend([self.node1, self.node2])
-
     @pytest.fixture(scope="function")
     def setup_optional_relay_nodes(self, request):
         logger.debug(f"Running fixture setup: {inspect.currentframe().f_code.co_name}")
@@ -164,19 +138,3 @@ def create_message(self, **kwargs):
     def subscribe_and_publish_with_retry(self, node_list, pubsub_topic_list):
         self.ensure_relay_subscriptions_on_nodes(node_list, pubsub_topic_list)
         self.check_published_message_reaches_relay_peer()
-
-    @allure.step
-    def register_rln_single_node(self, **kwargs):
-        logger.debug("Registering RLN credentials for single node")
-        self.node1 = WakuNode(DEFAULT_NWAKU, f"node1_{gen_step_id()}")
-        self.node1.register_rln(rln_creds_source=kwargs["rln_creds_source"], rln_creds_id=kwargs["rln_creds_id"])
-
-    @allure.step
-    def check_rln_registration(self, key_id):
-        current_working_directory = os.getcwd()
-        creds_file_path = f"{current_working_directory}/keystore_{key_id}/keystore.json"
-        try:
-            rln_credential_store_ready(creds_file_path)
-        except Exception as ex:
-            logger.error(f"Credentials at {creds_file_path} not available: {ex}")
-            raise

src/steps/rln.py

@@ -0,0 +1,110 @@
+from src.env_vars import DEFAULT_NWAKU, RLN_CREDENTIALS, NODEKEY, NODE_1, NODE_2
+from src.libs.common import gen_step_id, to_base64
+from src.libs.custom_logger import get_custom_logger
+import os
+import inspect
+import pytest
+import allure
+from time import time
+from src.node.waku_node import WakuNode, rln_credential_store_ready
+from src.test_data import PUBSUB_TOPICS_RLN
+
+logger = get_custom_logger(__name__)
+
+
+class StepsRLN:
+    test_pubsub_topic = PUBSUB_TOPICS_RLN[0]
+    test_content_topic = "/test/1/waku-rln-relay/proto"
+    test_payload = "RLN relay works!!"
+
+    main_nodes = []
+    optional_nodes = []
+
+    @pytest.fixture(scope="function")
+    def register_main_rln_relay_nodes(self, request):
+        logger.debug(f"Running fixture setup: {inspect.currentframe().f_code.co_name}")
+        self.node1 = WakuNode(DEFAULT_NWAKU, f"node1_{request.cls.test_id}")
+        self.node1.register_rln(rln_creds_source=RLN_CREDENTIALS, rln_creds_id="1")
+        self.node2 = WakuNode(DEFAULT_NWAKU, f"node2_{request.cls.test_id}")
+        self.node2.register_rln(rln_creds_source=RLN_CREDENTIALS, rln_creds_id="2")
+
+    @pytest.fixture(scope="function")
+    def setup_main_rln_relay_nodes(self, request):
+        logger.debug(f"Running fixture setup: {inspect.currentframe().f_code.co_name}")
+        self.node1 = WakuNode(DEFAULT_NWAKU, f"node1_{request.cls.test_id}")
+        self.node1.start(relay="true", nodekey=NODEKEY, rln_creds_source=RLN_CREDENTIALS, rln_creds_id="1", rln_relay_membership_index="1")
+        self.enr_uri = self.node1.get_enr_uri()
+        self.multiaddr_with_id = self.node1.get_multiaddr_with_id()
+        self.node2 = WakuNode(DEFAULT_NWAKU, f"node2_{request.cls.test_id}")
+        self.node2.start(
+            relay="true", discv5_bootstrap_node=self.enr_uri, rln_creds_source=RLN_CREDENTIALS, rln_creds_id="2", rln_relay_membership_index="1"
+        )
+        if self.node2.is_nwaku():
+            self.node2.add_peers([self.multiaddr_with_id])
+        self.main_nodes.extend([self.node1, self.node2])
+
+    @allure.step
+    def setup_first_rln_relay_node(self, **kwargs):
+        self.node1 = WakuNode(DEFAULT_NWAKU, f"node1_{self.test_id}")
+        self.node1.start(relay="true", nodekey=NODEKEY, rln_creds_source=RLN_CREDENTIALS, rln_creds_id="1", rln_relay_membership_index="1", **kwargs)
+        self.enr_uri = self.node1.get_enr_uri()
+        self.multiaddr_with_id = self.node1.get_multiaddr_with_id()
+        self.main_nodes.extend([self.node1])
+
+    @allure.step
+    def setup_second_rln_relay_node(self, **kwargs):
+        self.node2 = WakuNode(DEFAULT_NWAKU, f"node2_{self.test_id}")
+        self.node2.start(
+            relay="true",
+            discv5_bootstrap_node=self.enr_uri,
+            rln_creds_source=RLN_CREDENTIALS,
+            rln_creds_id="2",
+            rln_relay_membership_index="1",
+            **kwargs,
+        )
+        if self.node2.is_nwaku():
+            self.node2.add_peers([self.multiaddr_with_id])
+        self.main_nodes.extend([self.node2])
+
+    @allure.step
+    def register_rln_single_node(self, **kwargs):
+        logger.debug("Registering RLN credentials for single node")
+        self.node1 = WakuNode(DEFAULT_NWAKU, f"node1_{gen_step_id()}")
+        self.node1.register_rln(rln_creds_source=kwargs["rln_creds_source"], rln_creds_id=kwargs["rln_creds_id"])
+
+    @allure.step
+    def check_rln_registration(self, key_id):
+        current_working_directory = os.getcwd()
+        creds_file_path = f"{current_working_directory}/keystore_{key_id}/keystore.json"
+        try:
+            rln_credential_store_ready(creds_file_path)
+        except Exception as ex:
+            logger.error(f"Credentials at {creds_file_path} not available: {ex}")
+            raise
+
+    @allure.step
+    def create_message(self, **kwargs):
+        message = {"payload": to_base64(self.test_payload), "contentTopic": self.test_content_topic, "timestamp": int(time() * 1e9)}
+        message.update(kwargs)
+        return message
+
+    @allure.step
+    def publish_message(self, message=None, pubsub_topic=None, sender=None):
+        if message is None:
+            message = self.create_message()
+        if pubsub_topic is None:
+            pubsub_topic = self.test_pubsub_topic
+        if not sender:
+            sender = self.node1
+
+        sender.send_relay_message(message, pubsub_topic)
+
+    @allure.step
+    def ensure_relay_subscriptions_on_nodes(self, node_list, pubsub_topic_list):
+        for node in node_list:
+            node.set_relay_subscriptions(pubsub_topic_list)
+
+    @allure.step
+    def subscribe_main_relay_nodes(self):
+        logger.debug(f"Running fixture setup: {inspect.currentframe().f_code.co_name}")
+        self.ensure_relay_subscriptions_on_nodes(self.main_nodes, [self.test_pubsub_topic])

src/test_data.py

@@ -148,3 +148,5 @@
     {"description": "ISO 8601 timestamp", "value": "2023-12-26T10:58:51", "valid_for": []},
     {"description": "Missing", "value": None, "valid_for": ["gowaku"]},
 ]
+
+PUBSUB_TOPICS_RLN = ["/waku/2/rs/1/0"]

tests/relay/test_rln.py

@@ -1,24 +1,123 @@
-import os
+import math
+import random
+from time import time
+
 import pytest
 
-from src.env_vars import RLN_CREDENTIALS
+from src.libs.common import delay, to_base64
 from src.libs.custom_logger import get_custom_logger
 from src.steps.relay import StepsRelay
+from src.steps.rln import StepsRLN
+from src.test_data import SAMPLE_INPUTS
 
 logger = get_custom_logger(__name__)
 
 
-@pytest.mark.usefixtures()
-class TestRelayRLN(StepsRelay):
-    def test_register_rln(self):
-        logger.debug("Running register RLN test for main relay nodes")
-        key_stores_found = 0
+@pytest.mark.usefixtures("register_main_rln_relay_nodes")
+class TestRelayRLN(StepsRLN, StepsRelay):
+    def test_publish_with_valid_payloads_at_slow_rate(self):
+        self.setup_first_rln_relay_node()
+        self.setup_second_rln_relay_node()
+        self.subscribe_main_relay_nodes()
+        failed_payloads = []
+        for payload in SAMPLE_INPUTS[:5]:
+            logger.debug(f'Running test with payload {payload["description"]}')
+            message = self.create_message(payload=to_base64(payload["value"]))
+            try:
+                self.publish_message(message)
+            except Exception as e:
+                logger.error(f'Payload {payload["description"]} failed: {str(e)}')
+                failed_payloads.append(payload["description"])
+            delay(1)
+            assert not failed_payloads, f"Payloads failed: {failed_payloads}"
+
+    def test_publish_with_valid_payloads_at_spam_rate(self):
+        self.setup_first_rln_relay_node()
+        self.setup_second_rln_relay_node()
+        self.subscribe_main_relay_nodes()
+        previous = math.trunc(time())
+        for i, payload in enumerate(SAMPLE_INPUTS[:4]):
+            logger.debug(f'Running test with payload {payload["description"]}')
+            message = self.create_message(payload=to_base64(payload["value"]))
+            try:
+                now = math.trunc(time())
+                self.publish_message(message)
+                if i > 0 and (now - previous) == 0:
+                    raise AssertionError("Publish with RLN enabled at spam rate worked!!!")
+                else:
+                    previous = now
+            except Exception as e:
+                assert "RLN validation failed" in str(e)
+
+    @pytest.mark.skip(reason="flaky because of problems with time measurement")
+    def test_publish_with_valid_payloads_at_variable_rate(self):
+        self.setup_first_rln_relay_node()
+        self.setup_second_rln_relay_node()
+        self.subscribe_main_relay_nodes()
+        previous = math.trunc(time())
+        for i, payload in enumerate(SAMPLE_INPUTS):
+            logger.debug(f'Running test with payload {payload["description"]}')
+            message = self.create_message(payload=to_base64(payload["value"]))
+            try:
+                if i % 2 == 1:  # every sample with odd index is sent slowly
+                    delay(1 + 1)
+                now = math.trunc(time())
+                logger.debug(f"Message sent at timestamp {now}")
+                self.publish_message(message)
+                if i > 0 and (now - previous) == 0:
+                    raise AssertionError("Publish with RLN enabled at spam rate worked!!!")
+                else:
+                    previous = now
+            except Exception as e:
+                assert "RLN validation failed" in str(e)
+
+    def test_publish_with_valid_payloads_random_epoch_at_slow_rate(self):
+        epoch_sec = random.randint(2, 5)
+        self.setup_first_rln_relay_node(rln_relay_epoch_sec=epoch_sec)
+        self.setup_second_rln_relay_node(rln_relay_epoch_sec=epoch_sec)
+        self.subscribe_main_relay_nodes()
+        failed_payloads = []
+        for payload in SAMPLE_INPUTS[:5]:
+            logger.debug(f'Running test with payload {payload["description"]}')
+            message = self.create_message(payload=to_base64(payload["value"]))
+            try:
+                self.publish_message(message)
+            except Exception as e:
+                logger.error(f'Payload {payload["description"]} failed: {str(e)}')
+                failed_payloads.append(payload["description"])
+            delay(epoch_sec)
+            assert not failed_payloads, f"Payloads failed: {failed_payloads}"
 
-        if RLN_CREDENTIALS is None:
-            pytest.skip("RLN_CREDENTIALS not set, skipping test")
+    @pytest.mark.skip(reason="waiting for RLN v2 implementation")
+    def test_publish_with_valid_payloads_random_user_message_limit(self):
+        user_message_limit = random.randint(2, 4)
+        self.setup_first_rln_relay_node(rln_relay_user_message_limit=user_message_limit)
+        self.setup_second_rln_relay_node(rln_relay_user_message_limit=user_message_limit)
+        self.subscribe_main_relay_nodes()
+        failed_payloads = []
+        for payload in SAMPLE_INPUTS[:user_message_limit]:
+            logger.debug(f'Running test with payload {payload["description"]}')
+            message = self.create_message(payload=to_base64(payload["value"]))
+            try:
+                self.publish_message(message)
+            except Exception as e:
+                logger.error(f'Payload {payload["description"]} failed: {str(e)}')
+                failed_payloads.append(payload["description"])
+            assert not failed_payloads, f"Payloads failed: {failed_payloads}"
 
-        for k in range(1, 6):
-            self.register_rln_single_node(rln_creds_source=RLN_CREDENTIALS, rln_creds_id=f"{k}")
-            self.check_rln_registration(k)
-            key_stores_found += 1
-        assert key_stores_found == 5, f"Invalid number of RLN keystores found, expected 5 found {key_stores_found}"
+    @pytest.mark.skip(reason="pending on https://github.com/waku-org/nwaku/issues/2606")
+    def test_publish_with_valid_payloads_dynamic_at_slow_rate(self):
+        self.setup_first_rln_relay_node(rln_relay_dynamic="true")
+        self.setup_second_rln_relay_node(rln_relay_dynamic="true")
+        self.subscribe_main_relay_nodes()
+        failed_payloads = []
+        for payload in SAMPLE_INPUTS[:5]:
+            logger.debug(f'Running test with payload {payload["description"]}')
+            message = self.create_message(payload=to_base64(payload["value"]))
+            try:
+                self.publish_message(message)
+            except Exception as e:
+                logger.error(f'Payload {payload["description"]} failed: {str(e)}')
+                failed_payloads.append(payload["description"])
+            delay(1)
+            assert not failed_payloads, f"Payloads failed: {failed_payloads}"