test_: bring back messaging tests for functional check, added light client messaging

tests-functional/clients/services/wakuext.py

@@ -69,3 +69,8 @@ def send_community_chat_message(self, chat_id, message, content_type=MessageCont
         params = [{"chatId": chat_id, "text": message, "contentType": content_type}]
         response = self.rpc_request("sendChatMessage", params)
         return response.json()
+
+    def set_light_client(self, enabled=True):
+        params = [{"enabled": enabled}]
+        response = self.rpc_request("setLightClient", params)
+        return response.json()

tests-functional/clients/signals.py

@@ -16,6 +16,7 @@ class SignalType(Enum):
     NODE_READY = "node.ready"
     NODE_STARTED = "node.started"
     NODE_LOGIN = "node.login"
+    NODE_LOGOUT = "node.stopped"
     MEDIASERVER_STARTED = "mediaserver.started"
     WALLET_SUGGESTED_ROUTES = "wallet.suggested.routes"
     WALLET_ROUTER_SIGN_TRANSACTIONS = "wallet.router.sign-transactions"
@@ -98,6 +99,10 @@ def wait_for_login(self):
             assert not signal["event"]["error"]
         return signal
 
+    def wait_for_logout(self):
+        signal = self.wait_for_signal(SignalType.NODE_LOGOUT.value)
+        return signal
+
     def find_signal_containing_pattern(self, signal_type, event_pattern, timeout=20):
         start_time = time.time()
         while True:

tests-functional/tests/reliability/test_contact_request.py

@@ -10,40 +10,7 @@
 class TestContactRequests(MessengerTestCase):
 
     def test_contact_request_baseline(self, execution_number=1, network_condition=None):
-        message_text = f"test_contact_request_{execution_number}_{uuid4()}"
-        sender = self.initialize_backend(await_signals=self.await_signals)
-        receiver = self.initialize_backend(await_signals=self.await_signals)
-
-        existing_contacts = receiver.wakuext_service.get_contacts()
-
-        if sender.public_key in str(existing_contacts):
-            pytest.skip("Contact request was already sent for this sender<->receiver. Skipping test!!")
-
-        if network_condition:
-            network_condition(receiver)
-
-        response = sender.wakuext_service.send_contact_request(receiver.public_key, message_text)
-        expected_message = self.get_message_by_content_type(response, content_type=MessageContentType.CONTACT_REQUEST.value)[0]
-
-        messages_new_event = receiver.find_signal_containing_pattern(
-            SignalType.MESSAGES_NEW.value,
-            event_pattern=expected_message.get("id"),
-            timeout=60,
-        )
-
-        signal_messages_texts = []
-        if "messages" in messages_new_event.get("event", {}):
-            signal_messages_texts.extend(message["text"] for message in messages_new_event["event"]["messages"] if "text" in message)
-
-        assert (
-            f"@{sender.public_key} sent you a contact request" in signal_messages_texts
-        ), "Couldn't find the signal corresponding to the contact request"
-
-        self.validate_signal_event_against_response(
-            signal_event=messages_new_event,
-            fields_to_validate={"text": "text"},
-            expected_message=expected_message,
-        )
+        self.add_contact(execution_number, network_condition)
 
     @pytest.mark.parametrize("execution_number", range(10))
     def test_multiple_contact_requests(self, execution_number):

tests-functional/tests/reliability/test_create_private_groups.py

@@ -3,7 +3,6 @@
 import pytest
 from tests.test_cases import MessengerTestCase
 from clients.signals import SignalType
-from resources.enums import MessageContentType
 
 
 @pytest.mark.usefixtures("setup_two_nodes")
@@ -12,29 +11,7 @@ class TestCreatePrivateGroups(MessengerTestCase):
 
     def test_create_private_group_baseline(self, private_groups_count=1):
         self.make_contacts()
-
-        private_groups = []
-        for i in range(private_groups_count):
-            private_group_name = f"private_group_{i+1}_{uuid4()}"
-            response = self.sender.wakuext_service.create_group_chat_with_members([self.receiver.public_key], private_group_name)
-
-            expected_group_creation_msg = f"@{self.sender.public_key} created the group {private_group_name}"
-            expected_message = self.get_message_by_content_type(
-                response, content_type=MessageContentType.SYSTEM_MESSAGE_CONTENT_PRIVATE_GROUP.value, message_pattern=expected_group_creation_msg
-            )[0]
-
-            private_groups.append(expected_message)
-            sleep(0.01)
-
-        for i, expected_message in enumerate(private_groups):
-            messages_new_event = self.receiver.find_signal_containing_pattern(
-                SignalType.MESSAGES_NEW.value, event_pattern=expected_message.get("id"), timeout=60
-            )
-            self.validate_signal_event_against_response(
-                signal_event=messages_new_event,
-                expected_message=expected_message,
-                fields_to_validate={"text": "text"},
-            )
+        self.create_private_group(private_groups_count)
 
     def test_multiple_one_create_private_groups(self):
         self.test_create_private_group_baseline(private_groups_count=50)

tests-functional/tests/reliability/test_one_to_one_messages.py

@@ -3,33 +3,14 @@
 import pytest
 from tests.test_cases import MessengerTestCase
 from clients.signals import SignalType
-from resources.enums import MessageContentType
 
 
 @pytest.mark.usefixtures("setup_two_nodes")
 @pytest.mark.reliability
 class TestOneToOneMessages(MessengerTestCase):
 
     def test_one_to_one_message_baseline(self, message_count=1):
-        sent_messages = []
-        for i in range(message_count):
-            message_text = f"test_message_{i+1}_{uuid4()}"
-            response = self.sender.wakuext_service.send_message(self.receiver.public_key, message_text)
-            expected_message = self.get_message_by_content_type(response, content_type=MessageContentType.TEXT_PLAIN.value)[0]
-            sent_messages.append(expected_message)
-            sleep(0.01)
-
-        for i, expected_message in enumerate(sent_messages):
-            messages_new_event = self.receiver.find_signal_containing_pattern(
-                SignalType.MESSAGES_NEW.value,
-                event_pattern=expected_message.get("id"),
-                timeout=60,
-            )
-            self.validate_signal_event_against_response(
-                signal_event=messages_new_event,
-                fields_to_validate={"text": "text"},
-                expected_message=expected_message,
-            )
+        self.one_to_one_message(message_count)
 
     def test_multiple_one_to_one_messages(self):
         self.test_one_to_one_message_baseline(message_count=50)

tests-functional/tests/reliability/test_private_groups_messages.py

@@ -3,7 +3,6 @@
 import pytest
 from tests.test_cases import MessengerTestCase
 from clients.signals import SignalType
-from resources.enums import MessageContentType
 
 
 @pytest.mark.usefixtures("setup_two_nodes")
@@ -13,26 +12,7 @@ class TestPrivateGroupMessages(MessengerTestCase):
     def test_private_group_messages_baseline(self, message_count=1):
         self.make_contacts()
         self.private_group_id = self.join_private_group()
-
-        sent_messages = []
-        for i in range(message_count):
-            message_text = f"test_message_{i+1}_{uuid4()}"
-            response = self.sender.wakuext_service.send_group_chat_message(self.private_group_id, message_text)
-            expected_message = self.get_message_by_content_type(response, content_type=MessageContentType.TEXT_PLAIN.value)[0]
-            sent_messages.append(expected_message)
-            sleep(0.01)
-
-        for _, expected_message in enumerate(sent_messages):
-            messages_new_event = self.receiver.find_signal_containing_pattern(
-                SignalType.MESSAGES_NEW.value,
-                event_pattern=expected_message.get("id"),
-                timeout=60,
-            )
-            self.validate_signal_event_against_response(
-                signal_event=messages_new_event,
-                fields_to_validate={"text": "text"},
-                expected_message=expected_message,
-            )
+        self.private_group_message(message_count, self.private_group_id)
 
     def test_multiple_group_chat_messages(self):
         self.test_private_group_messages_baseline(message_count=50)

tests-functional/tests/test_cases.py

@@ -206,15 +206,16 @@ class MessengerTestCase(NetworkConditionTestCase):
         SignalType.MESSAGES_NEW.value,
         SignalType.MESSAGE_DELIVERED.value,
         SignalType.NODE_LOGIN.value,
+        SignalType.NODE_LOGOUT.value,
     ]
 
     @pytest.fixture(scope="function", autouse=False)
     def setup_two_nodes(self, request):
-        request.cls.sender = self.sender = self.initialize_backend(await_signals=self.await_signals)
-        request.cls.receiver = self.receiver = self.initialize_backend(await_signals=self.await_signals)
+        request.cls.sender = self.sender = self.initialize_backend(self.await_signals, True)
+        request.cls.receiver = self.receiver = self.initialize_backend(self.await_signals, True)
 
-    def initialize_backend(self, await_signals):
-        backend = StatusBackend(await_signals=await_signals, privileged=True)
+    def initialize_backend(self, await_signals, privileged=True):
+        backend = StatusBackend(await_signals, privileged)
         backend.init_status_backend()
         backend.create_account_and_login()
         backend.find_public_key()
@@ -278,9 +279,15 @@ def join_private_group(self):
         response = self.sender.wakuext_service.create_group_chat_with_members([self.receiver.public_key], private_group_name)
         expected_group_creation_msg = f"@{self.sender.public_key} created the group {private_group_name}"
         expected_message = self.get_message_by_content_type(
-            response, content_type=MessageContentType.SYSTEM_MESSAGE_CONTENT_PRIVATE_GROUP.value, message_pattern=expected_group_creation_msg
+            response,
+            content_type=MessageContentType.SYSTEM_MESSAGE_CONTENT_PRIVATE_GROUP.value,
+            message_pattern=expected_group_creation_msg,
         )[0]
-        self.receiver.find_signal_containing_pattern(SignalType.MESSAGES_NEW.value, event_pattern=expected_message.get("id"), timeout=60)
+        self.receiver.find_signal_containing_pattern(
+            SignalType.MESSAGES_NEW.value,
+            event_pattern=expected_message.get("id"),
+            timeout=60,
+        )
         return response.get("result", {}).get("chats", [])[0].get("id")
 
     def create_and_join_community(self):
@@ -332,3 +339,109 @@ def community_messages(self, message_chat_id, message_count):
                 fields_to_validate={"text": "text"},
                 expected_message=expected_message,
             )
+
+    def one_to_one_message(self, message_count):
+        sent_messages = []
+        for i in range(message_count):
+            message_text = f"test_message_{i+1}_{uuid4()}"
+            response = self.sender.wakuext_service.send_message(self.receiver.public_key, message_text)
+            expected_message = self.get_message_by_content_type(response, content_type=MessageContentType.TEXT_PLAIN.value)[0]
+            sent_messages.append(expected_message)
+            time.sleep(0.01)
+
+        for i, expected_message in enumerate(sent_messages):
+            messages_new_event = self.receiver.find_signal_containing_pattern(
+                SignalType.MESSAGES_NEW.value,
+                event_pattern=expected_message.get("id"),
+                timeout=60,
+            )
+            self.validate_signal_event_against_response(
+                signal_event=messages_new_event,
+                fields_to_validate={"text": "text"},
+                expected_message=expected_message,
+            )
+
+    def add_contact(self, execution_number, network_condition=None, privileged=True):
+        message_text = f"test_contact_request_{execution_number}_{uuid4()}"
+        sender = self.initialize_backend(await_signals=self.await_signals, privileged=privileged)
+        receiver = self.initialize_backend(await_signals=self.await_signals, privileged=privileged)
+
+        existing_contacts = receiver.wakuext_service.get_contacts()
+
+        if sender.public_key in str(existing_contacts):
+            pytest.skip("Contact request was already sent for this sender<->receiver. Skipping test!!")
+
+        if network_condition:
+            network_condition(receiver)
+
+        response = sender.wakuext_service.send_contact_request(receiver.public_key, message_text)
+        expected_message = self.get_message_by_content_type(response, content_type=MessageContentType.CONTACT_REQUEST.value)[0]
+
+        messages_new_event = receiver.find_signal_containing_pattern(
+            SignalType.MESSAGES_NEW.value,
+            event_pattern=expected_message.get("id"),
+            timeout=60,
+        )
+
+        signal_messages_texts = []
+        if "messages" in messages_new_event.get("event", {}):
+            signal_messages_texts.extend(message["text"] for message in messages_new_event["event"]["messages"] if "text" in message)
+
+        assert (
+            f"@{sender.public_key} sent you a contact request" in signal_messages_texts
+        ), "Couldn't find the signal corresponding to the contact request"
+
+        self.validate_signal_event_against_response(
+            signal_event=messages_new_event,
+            fields_to_validate={"text": "text"},
+            expected_message=expected_message,
+        )
+
+    def create_private_group(self, private_groups_count):
+        private_groups = []
+        for i in range(private_groups_count):
+            private_group_name = f"private_group_{i+1}_{uuid4()}"
+            response = self.sender.wakuext_service.create_group_chat_with_members([self.receiver.public_key], private_group_name)
+
+            expected_group_creation_msg = f"@{self.sender.public_key} created the group {private_group_name}"
+            expected_message = self.get_message_by_content_type(
+                response,
+                content_type=MessageContentType.SYSTEM_MESSAGE_CONTENT_PRIVATE_GROUP.value,
+                message_pattern=expected_group_creation_msg,
+            )[0]
+
+            private_groups.append(expected_message)
+            time.sleep(0.01)
+
+        for i, expected_message in enumerate(private_groups):
+            messages_new_event = self.receiver.find_signal_containing_pattern(
+                SignalType.MESSAGES_NEW.value,
+                event_pattern=expected_message.get("id"),
+                timeout=60,
+            )
+            self.validate_signal_event_against_response(
+                signal_event=messages_new_event,
+                expected_message=expected_message,
+                fields_to_validate={"text": "text"},
+            )
+
+    def private_group_message(self, message_count, private_group_id):
+        sent_messages = []
+        for i in range(message_count):
+            message_text = f"test_message_{i+1}_{uuid4()}"
+            response = self.sender.wakuext_service.send_group_chat_message(private_group_id, message_text)
+            expected_message = self.get_message_by_content_type(response, content_type=MessageContentType.TEXT_PLAIN.value)[0]
+            sent_messages.append(expected_message)
+            time.sleep(0.01)
+
+        for _, expected_message in enumerate(sent_messages):
+            messages_new_event = self.receiver.find_signal_containing_pattern(
+                SignalType.MESSAGES_NEW.value,
+                event_pattern=expected_message.get("id"),
+                timeout=60,
+            )
+            self.validate_signal_event_against_response(
+                signal_event=messages_new_event,
+                fields_to_validate={"text": "text"},
+                expected_message=expected_message,
+            )