Merge branch 'master' into E2E_tests_part2

src/steps/common.py

@@ -4,6 +4,7 @@ import inspect
 from time import time
 import allure
 import pytest
+from datetime import timedelta, datetime
 from tenacity import retry, stop_after_delay, wait_fixed
 from src.libs.common import delay, to_base64
 from src.libs.custom_logger import get_custom_logger
@@ -57,3 +58,21 @@ class StepsCommon:
         ctx.update(int(msg["timestamp"]).to_bytes(8, byteorder="big"))
         hash_bytes = ctx.digest()
         return base64.b64encode(hash_bytes).decode("utf-8")
+
+    def get_time_list_pass(self):
+        ts_pass = [
+            {"description": "3 sec Past", "value": int((datetime.now() - timedelta(seconds=3)).timestamp() * 1e9)},
+            {"description": "1 sec Past", "value": int((datetime.now() - timedelta(seconds=1)).timestamp() * 1e9)},
+            {"description": "0.1 sec Past", "value": int((datetime.now() - timedelta(seconds=0.1)).timestamp() * 1e9)},
+            {"description": "0.1 sec Future", "value": int((datetime.now() + timedelta(seconds=0.1)).timestamp() * 1e9)},
+            {"description": "2 sec Future", "value": int((datetime.now() + timedelta(seconds=2)).timestamp() * 1e9)},
+            {"description": "10 sec Future", "value": int((datetime.now() + timedelta(seconds=10)).timestamp() * 1e9)},
+        ]
+        return ts_pass
+
+    def get_time_list_fail(self):
+        ts_fail = [
+            {"description": "20 sec Past", "value": int((datetime.now() - timedelta(seconds=20)).timestamp() * 1e9)},
+            {"description": "40 sec Future", "value": int((datetime.now() + timedelta(seconds=40)).timestamp() * 1e9)},
+        ]
+        return ts_fail

src/steps/light_push.py

@@ -13,6 +13,7 @@ from src.env_vars import (
 from src.node.waku_node import WakuNode
 from src.steps.common import StepsCommon
 from src.test_data import VALID_PUBSUB_TOPICS
+from tenacity import retry, stop_after_delay, wait_fixed
 
 logger = get_custom_logger(__name__)
 
@@ -137,3 +138,9 @@ class StepsLightPush(StepsCommon):
         payload = {"pubsubTopic": pubsub_topic, "message": message}
         payload.update(kwargs)
         return payload
+
+    @allure.step
+    @retry(stop=stop_after_delay(120), wait=wait_fixed(1), reraise=True)
+    def subscribe_and_light_push_with_retry(self):
+        self.subscribe_to_pubsub_topics_via_relay()
+        self.check_light_pushed_message_reaches_receiving_peer()

src/test_data.py

@@ -352,6 +352,8 @@ METRICS_WITH_INITIAL_VALUE_ZERO = [
     "waku_histogram_message_size_sum",
     "waku_histogram_message_size_count",
     'waku_histogram_message_size_bucket{le="0.0"}',
+    'waku_histogram_message_size_bucket{le="1.0"}',
+    'waku_histogram_message_size_bucket{le="3.0"}',
     'waku_histogram_message_size_bucket{le="5.0"}',
     'waku_histogram_message_size_bucket{le="15.0"}',
     'waku_histogram_message_size_bucket{le="50.0"}',
@@ -359,7 +361,7 @@ METRICS_WITH_INITIAL_VALUE_ZERO = [
     'waku_histogram_message_size_bucket{le="100.0"}',
     'waku_histogram_message_size_bucket{le="125.0"}',
     'waku_histogram_message_size_bucket{le="150.0"}',
-    'waku_histogram_message_size_bucket{le="300.0"}',
+    'waku_histogram_message_size_bucket{le="500.0"}',
     'waku_histogram_message_size_bucket{le="700.0"}',
     'waku_histogram_message_size_bucket{le="1000.0"}',
     'waku_histogram_message_size_bucket{le="+Inf"}',

tests/light_push/test_publish.py

@@ -1,5 +1,5 @@
 import pytest
-from src.env_vars import NODE_2
+
 from src.libs.custom_logger import get_custom_logger
 from time import time
 from src.libs.common import delay, to_base64
@@ -267,9 +267,7 @@ class TestLightPushPublish(StepsLightPush):
         self.check_light_pushed_message_reaches_receiving_peer()
         self.receiving_node1.restart()
         self.receiving_node1.ensure_ready()
-        delay(30)
+        self.subscribe_and_light_push_with_retry()
-        self.subscribe_to_pubsub_topics_via_relay()
-        self.check_light_pushed_message_reaches_receiving_peer()
 
     def test_light_push_and_retrieve_100_messages(self):
         num_messages = 100  # if increase this number make sure to also increase rest-relay-cache-capacity flag

tests/store/test_api_flags.py

@@ -1,5 +1,5 @@
 import pytest
-from time import time
+from src.env_vars import NODE_1, NODE_2
 from src.libs.custom_logger import get_custom_logger
 from src.libs.common import to_base64
 from src.node.waku_message import WakuMessage
@@ -17,6 +17,7 @@ class TestApiFlags(StepsStore):
         self.publish_message()
         self.check_published_message_is_stored(store_node=self.store_node1, peer_addr=self.multiaddr_list[0])
 
+    @pytest.mark.skipif("go-waku" in (NODE_1 + NODE_2), reason="Test works only with nwaku")
     def test_store_with_wrongPeerAddr(self):
         self.publish_message()
         wrong_peer_addr = self.multiaddr_list[0][1:]

tests/store/test_page_size.py

@@ -1,4 +1,5 @@
 import pytest
+from src.env_vars import NODE_1, NODE_2
 from src.libs.common import to_base64
 from src.steps.store import StepsStore
 from src.libs.custom_logger import get_custom_logger
@@ -44,6 +45,7 @@ class TestPageSize(StepsStore):
             store_response = self.get_messages_from_store(node, page_size=1000000)
             assert len(store_response.messages) == 100, "Message count mismatch"
 
+    @pytest.mark.skipif("go-waku" in (NODE_1 + NODE_2), reason="Test works only with nwaku")
     def test_negative_number_page_size(self):
         page_size = -1
         for i in range(10):

tests/store/test_time_filter.py

@@ -1,5 +1,5 @@
 import time
-
+from src.env_vars import NODE_1, NODE_2
 import pytest
 from datetime import timedelta, datetime
 from src.libs.custom_logger import get_custom_logger
@@ -10,24 +10,10 @@ logger = get_custom_logger(__name__)
 
 @pytest.mark.usefixtures("node_setup")
 class TestTimeFilter(StepsStore):
-    @pytest.fixture(scope="function", autouse=True)
-    def setup_test_data(self):
-        self.ts_pass = [
-            {"description": "3 sec Past", "value": int((datetime.now() - timedelta(seconds=3)).timestamp() * 1e9)},
-            {"description": "1 sec Past", "value": int((datetime.now() - timedelta(seconds=1)).timestamp() * 1e9)},
-            {"description": "0.1 sec Past", "value": int((datetime.now() - timedelta(seconds=0.1)).timestamp() * 1e9)},
-            {"description": "0.1 sec Future", "value": int((datetime.now() + timedelta(seconds=0.1)).timestamp() * 1e9)},
-            {"description": "2 sec Future", "value": int((datetime.now() + timedelta(seconds=2)).timestamp() * 1e9)},
-            {"description": "10 sec Future", "value": int((datetime.now() + timedelta(seconds=10)).timestamp() * 1e9)},
-        ]
-        self.ts_fail = [
-            {"description": "20 sec Past", "value": int((datetime.now() - timedelta(seconds=20)).timestamp() * 1e9)},
-            {"description": "40 sec Future", "value": int((datetime.now() + timedelta(seconds=40)).timestamp() * 1e9)},
-        ]
-
     def test_messages_with_timestamps_close_to_now(self):
         failed_timestamps = []
-        for timestamp in self.ts_pass:
+        ts_pass = self.get_time_list_pass()
+        for timestamp in ts_pass:
             logger.debug(f'Running test with payload {timestamp["description"]}')
             message = self.create_message(timestamp=timestamp["value"])
             try:
@@ -40,7 +26,8 @@ class TestTimeFilter(StepsStore):
 
     def test_messages_with_timestamps_far_from_now(self):
         success_timestamps = []
-        for timestamp in self.ts_fail:
+        ts_fail = self.get_time_list_fail()
+        for timestamp in ts_fail:
             logger.debug(f'Running test with payload {timestamp["description"]}')
             message = self.create_message(timestamp=timestamp["value"])
             try:
@@ -53,7 +40,8 @@ class TestTimeFilter(StepsStore):
 
     def test_time_filter_matches_one_message(self):
         message_hash_list = []
-        for timestamp in self.ts_pass:
+        ts_pass = self.get_time_list_pass()
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
             message_hash_list.append(self.compute_message_hash(self.test_pubsub_topic, message))
@@ -61,15 +49,16 @@ class TestTimeFilter(StepsStore):
             store_response = self.get_messages_from_store(
                 node,
                 page_size=20,
-                start_time=self.ts_pass[0]["value"] - 100000,
+                start_time=ts_pass[0]["value"] - 100000,
-                end_time=self.ts_pass[0]["value"] + 100000,
+                end_time=ts_pass[0]["value"] + 100000,
             )
             assert len(store_response.messages) == 1, "Message count mismatch"
             assert store_response.message_hash(0) == message_hash_list[0], "Incorrect messaged filtered based on time"
 
     def test_time_filter_matches_multiple_messages(self):
         message_hash_list = []
-        for timestamp in self.ts_pass:
+        ts_pass = self.get_time_list_pass()
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
             message_hash_list.append(self.compute_message_hash(self.test_pubsub_topic, message))
@@ -77,8 +66,8 @@ class TestTimeFilter(StepsStore):
             store_response = self.get_messages_from_store(
                 node,
                 page_size=20,
-                start_time=self.ts_pass[0]["value"] - 100000,
+                start_time=ts_pass[0]["value"] - 100000,
-                end_time=self.ts_pass[4]["value"] + 100000,
+                end_time=ts_pass[4]["value"] + 100000,
             )
             assert len(store_response.messages) == 5, "Message count mismatch"
             for i in range(5):
@@ -86,7 +75,8 @@ class TestTimeFilter(StepsStore):
 
     def test_time_filter_matches_no_message(self):
         message_hash_list = []
-        for timestamp in self.ts_pass:
+        ts_pass = self.get_time_list_pass()
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
             message_hash_list.append(self.compute_message_hash(self.test_pubsub_topic, message))
@@ -94,14 +84,15 @@ class TestTimeFilter(StepsStore):
             store_response = self.get_messages_from_store(
                 node,
                 page_size=20,
-                start_time=self.ts_pass[0]["value"] - 100000,
+                start_time=ts_pass[0]["value"] - 100000,
-                end_time=self.ts_pass[0]["value"] - 100,
+                end_time=ts_pass[0]["value"] - 100,
             )
             assert not store_response.messages, "Message count mismatch"
 
     def test_time_filter_start_time_equals_end_time(self):
         message_hash_list = []
-        for timestamp in self.ts_pass:
+        ts_pass = self.get_time_list_pass()
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
             message_hash_list.append(self.compute_message_hash(self.test_pubsub_topic, message))
@@ -109,16 +100,18 @@ class TestTimeFilter(StepsStore):
             store_response = self.get_messages_from_store(
                 node,
                 page_size=20,
-                start_time=self.ts_pass[0]["value"],
+                start_time=ts_pass[0]["value"],
-                end_time=self.ts_pass[0]["value"],
+                end_time=ts_pass[0]["value"],
             )
             assert len(store_response.messages) == 1, "Message count mismatch"
             assert store_response.message_hash(0) == message_hash_list[0], "Incorrect messaged filtered based on time"
 
+    @pytest.mark.skipif("go-waku" in (NODE_1 + NODE_2), reason="Test works only with nwaku")
     def test_time_filter_start_time_after_end_time(self):
-        start_time = self.ts_pass[4]["value"]  # 2 sec Future
+        ts_pass = self.get_time_list_pass()
-        end_time = self.ts_pass[0]["value"]  # 3 sec past
+        start_time = ts_pass[4]["value"]  # 2 sec Future
-        for timestamp in self.ts_pass:
+        end_time = ts_pass[0]["value"]  # 3 sec past
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
         logger.debug(f"inquering stored messages with start time {start_time} after end time {end_time}")
@@ -133,7 +126,8 @@ class TestTimeFilter(StepsStore):
             assert len(store_response.messages) == 0, "got messages with start time after end time !"
 
         def test_time_filter_negative_start_time(self):
-            for timestamp in self.ts_pass:
+            ts_pass = self.get_time_list_pass()
+            for timestamp in ts_pass:
                 message = self.create_message(timestamp=timestamp["value"])
                 self.publish_message(message=message)
 
@@ -146,7 +140,8 @@ class TestTimeFilter(StepsStore):
             assert len(store_response.messages) == 6, "number of messages retrieved doesn't match time filter "
 
     def test_time_filter_zero_start_time(self):
-        for timestamp in self.ts_pass:
+        ts_pass = self.get_time_list_pass()
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
         start_time = 0
@@ -157,8 +152,10 @@ class TestTimeFilter(StepsStore):
 
             assert len(store_response.messages) == 6, "number of messages retrieved doesn't match time filter "
 
+    @pytest.mark.skipif("go-waku" in (NODE_1 + NODE_2), reason="Test works only with nwaku")
     def test_time_filter_zero_start_end_time(self):
-        for timestamp in self.ts_pass:
+        ts_pass = self.get_time_list_pass()
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
         start_time = 0
@@ -171,7 +168,8 @@ class TestTimeFilter(StepsStore):
             assert len(store_response.messages) == 6, "number of messages retrieved doesn't match time filter "
 
     def test_time_filter_invalid_start_time(self):
-        for timestamp in self.ts_pass:
+        ts_pass = self.get_time_list_pass()
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
         start_time = "abc"
@@ -185,23 +183,23 @@ class TestTimeFilter(StepsStore):
             assert e.args[0].find("Bad Request for url"), "url with wrong start_time is accepted"
 
     def test_time_filter_end_time_now(self):
-        self.ts_pass[3]["value"] = int((datetime.now() + timedelta(seconds=4)).timestamp() * 1e9)
+        ts_pass = self.get_time_list_pass()
-        start_time = self.ts_pass[0]["value"]
+        ts_pass[3]["value"] = int((datetime.now() + timedelta(seconds=4)).timestamp() * 1e9)
-        i = 0
+        start_time = ts_pass[0]["value"]
-        for timestamp in self.ts_pass:
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
-            i += 1
         end_time = int(datetime.now().timestamp() * 1e9)
         logger.debug(f"inquering stored messages with start time {start_time} after end time {end_time}")
         for node in self.store_nodes:
             store_response = self.get_messages_from_store(node, page_size=20, start_time=start_time, end_time=end_time, include_data=True)
             logger.debug(f"number of messages stored for start time {start_time} and " f"end time = {end_time} is  {len(store_response.messages)}")
-            assert len(store_response.messages) == 4, "number of messages retrieved doesn't match time filter "
+            assert len(store_response.messages) == 3, "number of messages retrieved doesn't match time filter "
 
     def test_time_filter_big_timestamp(self):
-        start_time = self.ts_pass[0]["value"]
+        ts_pass = self.get_time_list_pass()
-        for timestamp in self.ts_pass:
+        start_time = ts_pass[0]["value"]
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
         end_time = int((datetime.now() + timedelta(days=8000)).timestamp() * 1e9)
@@ -211,12 +209,14 @@ class TestTimeFilter(StepsStore):
             logger.debug(f"number of messages stored for start time {start_time} and " f"end time = {end_time} is  {len(store_response.messages)}")
             assert len(store_response.messages) == 6, "number of messages retrieved doesn't match time filter "
 
+    @pytest.mark.skipif("go-waku" in (NODE_1 + NODE_2), reason="Test works only with nwaku")
     def test_time_filter_small_timestamp(self):
-        start_time = self.ts_pass[0]["value"]
+        ts_pass = self.get_time_list_pass()
-        for timestamp in self.ts_pass:
+        start_time = ts_pass[0]["value"]
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
-        end_time = self.ts_pass[5]["value"] + 1
+        end_time = ts_pass[5]["value"] + 1
         logger.debug(f"inquering stored messages with start time {start_time} after end time {end_time}")
         for node in self.store_nodes:
             store_response = self.get_messages_from_store(node, page_size=20, start_time=start_time, end_time=end_time, include_data=True)
@@ -224,8 +224,10 @@ class TestTimeFilter(StepsStore):
 
             assert len(store_response.messages) == 6, "number of messages retrieved doesn't match time filter "
 
+    @pytest.mark.skipif("go-waku" in (NODE_1 + NODE_2), reason="Test works only with nwaku")
     def test_time_filter_negative_end_time(self):
-        for timestamp in self.ts_pass:
+        ts_pass = self.get_time_list_pass()
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
         end_time = -10000
@@ -236,8 +238,10 @@ class TestTimeFilter(StepsStore):
 
             assert len(store_response.messages) == 6, "number of messages retrieved doesn't match time filter "
 
+    @pytest.mark.skipif("go-waku" in (NODE_1 + NODE_2), reason="Test works only with nwaku")
     def test_time_filter_zero_end_time(self):
-        for timestamp in self.ts_pass:
+        ts_pass = self.get_time_list_pass()
+        for timestamp in ts_pass:
             message = self.create_message(timestamp=timestamp["value"])
             self.publish_message(message=message)
         end_time = 0