test_: Tests for wakuext messages 4 (#6428)

* test_: update message outgoing status

* test_: rename send one to one message method

* test_: refactor community_messages

* test_: add test send community message

* test_: restructure tests wakuext messages

* test_: fix dynamic properties in schema

* test_: refactor send_community_messages

Author: rlve

Diff for: tests-functional/clients/services/wakuext.py

@@ -68,7 +68,7 @@ def add_contact(self, contact_id: str, displayName: str):
         response = self.rpc_request("addContact", params)
         return response.json()
 
-    def send_message(self, contact_id: str, message: str):
+    def send_one_to_one_message(self, contact_id: str, message: str):
         params = [{"id": contact_id, "message": message}]
         response = self.rpc_request("sendOneToOneMessage", params)
         return response.json()
@@ -187,8 +187,8 @@ def delete_message_and_send(self, message_id: str):
         response = self.rpc_request("deleteMessageAndSend", params)
         return response.json()
 
-    def delete_message_for_me_and_sync(self, localChatID: str, message_id: str):
-        params = [localChatID, message_id]
+    def delete_message_for_me_and_sync(self, local_chat_id: str, message_id: str):
+        params = [local_chat_id, message_id]
         response = self.rpc_request("deleteMessageForMeAndSync", params)
         return response.json()
 
@@ -201,3 +201,8 @@ def first_unseen_message_id(self, chat_id: str):
         params = [chat_id]
         response = self.rpc_request("firstUnseenMessageID", params)
         return response.json()
+
+    def update_message_outgoing_status(self, message_id: str, new_status: str):
+        params = [message_id, new_status]
+        response = self.rpc_request("updateMessageOutgoingStatus", params)
+        return response.json()

Diff for: tests-functional/schemas/wakuext_schatPinnedMessages renamed to tests-functional/schemas/wakuext_chatPinnedMessages

@@ -0,0 +1,20 @@
+{
+    "$schema": "http://json-schema.org/schema#",
+    "properties": {
+        "id": {
+            "type": "integer"
+        },
+        "jsonrpc": {
+            "type": "string"
+        },
+        "result": {
+            "type": "null"
+        }
+    },
+    "required": [
+        "id",
+        "jsonrpc",
+        "result"
+    ],
+    "type": "object"
+}

Diff for: tests-functional/schemas/wakuext_sendChatMessage

@@ -214,7 +214,7 @@ def send_multiple_one_to_one_messages(self, message_count=1) -> tuple[list[str],
         for i in range(message_count):
             message_text = f"test_message_{i}_{uuid4()}"
             sent_texts.append(message_text)
-            response = self.sender.wakuext_service.send_message(self.receiver.public_key, message_text)
+            response = self.sender.wakuext_service.send_one_to_one_message(self.receiver.public_key, message_text)
             responses.append(response)
 
         return sent_texts, responses

Diff for: tests-functional/schemas/wakuext_updateMessageOutgoingStatus

@@ -17,7 +17,7 @@ def test_light_client_rate_limiting(self):
 
         for i in range(200):
             message_text = f"test_message_{i+1}_{uuid4()}"
-            response = self.sender.wakuext_service.send_message(self.receiver.public_key, message_text)
+            response = self.sender.wakuext_service.send_one_to_one_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.1)

Diff for: tests-functional/steps/messenger.py

@@ -31,7 +31,7 @@ def test_one_to_one_message_with_low_bandwidth(self):
     def test_one_to_one_message_with_node_pause_30_seconds(self):
         with self.node_pause(self.receiver):
             message_text = f"test_message_{uuid4()}"
-            self.sender.wakuext_service.send_message(self.receiver.public_key, message_text)
+            self.sender.wakuext_service.send_one_to_one_message(self.receiver.public_key, message_text)
             sleep(30)
         self.receiver.find_signal_containing_pattern(SignalType.MESSAGES_NEW.value, event_pattern=message_text)
         self.sender.wait_for_signal(SignalType.MESSAGE_DELIVERED.value)

Diff for: tests-functional/tests/reliability/test_light_client_rate_limiting.py

@@ -6,16 +6,6 @@
 @pytest.mark.usefixtures("setup_two_unprivileged_nodes")
 class TestDefaultMessaging(MessengerSteps):
 
-    def test_one_to_one_messages(self):
-        responses = self.one_to_one_message(5)
-
-        for response in responses:
-            self.receiver.verify_json_schema(response, method="wakuext_sendOneToOneMessage")
-
-            chat = response["result"]["chats"][0]
-            assert chat["id"] == self.receiver.public_key
-            assert chat["lastMessage"]["displayName"] == self.sender.display_name
-
     def test_add_contact(self):
         self.add_contact(execution_number=1, network_condition=None, privileged=False)
 

Diff for: tests-functional/tests/reliability/test_one_to_one_messages.py

@@ -12,7 +12,7 @@
 class TestMessageReactions(MessengerSteps):
     def test_one_to_one_message_reactions(self):
         self.make_contacts()
-        response = self.sender.wakuext_service.send_message(self.receiver.public_key, "test_message")
+        response = self.sender.wakuext_service.send_one_to_one_message(self.receiver.public_key, "test_message")
         message = self.get_message_by_content_type(response, content_type=MessageContentType.TEXT_PLAIN.value)[0]
         message_id, sender_chat_id = message["id"], message["chatId"]
         receiver_chat_id = self.receiver.wakuext_service.rpc_request(method="chats").json()["result"][0]["id"]
@@ -60,7 +60,7 @@ def test_one_to_one_message_reactions(self):
         )
         assert not response.json()["result"]
 
-        response = self.sender.wakuext_service.send_message(self.receiver.public_key, "test_message 1")
+        response = self.sender.wakuext_service.send_one_to_one_message(self.receiver.public_key, "test_message 1")
         message_1 = self.get_message_by_content_type(response, content_type=MessageContentType.TEXT_PLAIN.value)[0]
         emoji_1_id = self.receiver.wakuext_service.rpc_request(method="sendEmojiReaction", params=[receiver_chat_id, message_1["id"], 2]).json()[
             "result"
@@ -71,7 +71,7 @@ def test_one_to_one_message_reactions(self):
             timeout=60,
         )
 
-        response = self.receiver.wakuext_service.send_message(self.sender.public_key, "test_message 2")
+        response = self.receiver.wakuext_service.send_one_to_one_message(self.sender.public_key, "test_message 2")
         message_2 = self.get_message_by_content_type(response, content_type=MessageContentType.TEXT_PLAIN.value)[0]
         emoji_2_id = self.sender.wakuext_service.rpc_request(method="sendEmojiReaction", params=[sender_chat_id, message_2["id"], 3]).json()[
             "result"

Diff for: tests-functional/tests/test_wakuext_default_messaging.py

@@ -0,0 +1,89 @@
+import pytest
+
+from steps.messenger import MessengerSteps
+
+
+@pytest.mark.usefixtures("setup_two_unprivileged_nodes")
+@pytest.mark.rpc
+class TestFetchingChatMessages(MessengerSteps):
+    def test_chat_messages(self):
+        sent_texts, _ = self.send_multiple_one_to_one_messages(1)
+
+        sender_chat_id = self.receiver.public_key
+        response = self.sender.wakuext_service.chat_messages(sender_chat_id)
+
+        self.sender.verify_json_schema(response, method="wakuext_chatMessages")
+
+        messages = response.get("result", {}).get("messages", [])
+        assert len(messages) == 1
+        actual_text = messages[0].get("text", "")
+        assert actual_text == sent_texts[0]
+
+    def test_chat_messages_with_pagination(self):
+        sent_texts, _ = self.send_multiple_one_to_one_messages(5)
+        sender_chat_id = self.receiver.public_key
+
+        # Page 1
+        chat_messages_res1 = self.sender.wakuext_service.chat_messages(sender_chat_id, cursor="", limit=3)
+
+        cursor1 = chat_messages_res1.get("result", {}).get("cursor", "")
+        messages_page1 = chat_messages_res1.get("result", {}).get("messages", [])
+        assert len(messages_page1) == 3
+        assert messages_page1[0].get("text", "") == sent_texts[4]
+        assert messages_page1[1].get("text", "") == sent_texts[3]
+        assert messages_page1[2].get("text", "") == sent_texts[2]
+        assert cursor1 != ""
+
+        # Page 2
+        chat_messages_res2 = self.sender.wakuext_service.chat_messages(sender_chat_id, cursor=cursor1, limit=3)
+
+        cursor2 = chat_messages_res2.get("result", {}).get("cursor", "")
+        messages_page2 = chat_messages_res2.get("result", {}).get("messages", [])
+        assert len(messages_page2) == 2
+        assert messages_page2[0].get("text", "") == sent_texts[1]
+        assert messages_page2[1].get("text", "") == sent_texts[0]
+        assert cursor2 == ""
+
+    def test_message_by_message_id(self):
+        sent_texts, responses = self.send_multiple_one_to_one_messages(1)
+
+        message_id = responses[0].get("result", {}).get("messages", [])[0].get("id", "")
+        response = self.sender.wakuext_service.message_by_message_id(message_id)
+
+        self.sender.verify_json_schema(response, method="wakuext_messageByMessageID")
+
+        actual_text = response.get("result", {}).get("text", "")
+        assert actual_text == sent_texts[0]
+
+    @pytest.mark.parametrize(
+        "searchTerm,caseSensitive,expectedCount",
+        [
+            ("test_message_1", False, 1),
+            ("TEST_MESSAGE_", False, 3),
+            # ("TEST_MESSAGE_", True, 0),  # Skipped due to https://github.com/status-im/status-go/issues/6359
+        ],
+    )
+    def test_all_messages_from_chat_which_match_term(self, searchTerm, caseSensitive, expectedCount):
+        self.send_multiple_one_to_one_messages(3)
+        sender_chat_id = self.receiver.public_key
+
+        response = self.sender.wakuext_service.all_messages_from_chat_which_match_term(sender_chat_id, searchTerm, caseSensitive)
+
+        self.sender.verify_json_schema(response, method="wakuext_allMessagesFromChatWhichMatchTerm")
+
+        messages = response.get("result", {}).get("messages", [])
+        assert len(messages) == expectedCount
+
+    def test_first_unseen_message(self):
+        _, responses = self.send_multiple_one_to_one_messages(1)
+        sender_chat_id = self.receiver.public_key
+        message_id = responses[0].get("result", {}).get("messages", [])[0].get("id", "")
+
+        response = self.sender.wakuext_service.mark_message_as_unread(sender_chat_id, message_id)
+        self.sender.verify_json_schema(response, method="wakuext_markMessageAsUnread")
+
+        response = self.sender.wakuext_service.first_unseen_message_id(sender_chat_id)
+        self.sender.verify_json_schema(response, method="wakuext_firstUnseenMessageID")
+
+        result = response.get("result", "")
+        assert result == message_id

Diff for: tests-functional/tests/test_wakuext_message_reactions.py

@@ -3,80 +3,11 @@
 from steps.messenger import MessengerSteps
 
 from clients.services.wakuext import SendPinMessagePayload
-from clients.signals import SignalType
 
 
 @pytest.mark.usefixtures("setup_two_unprivileged_nodes")
 @pytest.mark.rpc
-class TestChatMessages(MessengerSteps):
-
-    def test_chat_messages(self):
-        sent_texts, _ = self.send_multiple_one_to_one_messages(1)
-
-        sender_chat_id = self.receiver.public_key
-        response = self.sender.wakuext_service.chat_messages(sender_chat_id)
-
-        self.sender.verify_json_schema(response, method="wakuext_chatMessages")
-
-        messages = response.get("result", {}).get("messages", [])
-        assert len(messages) == 1
-        actual_text = messages[0].get("text", "")
-        assert actual_text == sent_texts[0]
-
-    def test_chat_messages_with_pagination(self):
-        sent_texts, _ = self.send_multiple_one_to_one_messages(5)
-        sender_chat_id = self.receiver.public_key
-
-        # Page 1
-        chat_messages_res1 = self.sender.wakuext_service.chat_messages(sender_chat_id, cursor="", limit=3)
-
-        cursor1 = chat_messages_res1.get("result", {}).get("cursor", "")
-        messages_page1 = chat_messages_res1.get("result", {}).get("messages", [])
-        assert len(messages_page1) == 3
-        assert messages_page1[0].get("text", "") == sent_texts[4]
-        assert messages_page1[1].get("text", "") == sent_texts[3]
-        assert messages_page1[2].get("text", "") == sent_texts[2]
-        assert cursor1 != ""
-
-        # Page 2
-        chat_messages_res2 = self.sender.wakuext_service.chat_messages(sender_chat_id, cursor=cursor1, limit=3)
-
-        cursor2 = chat_messages_res2.get("result", {}).get("cursor", "")
-        messages_page2 = chat_messages_res2.get("result", {}).get("messages", [])
-        assert len(messages_page2) == 2
-        assert messages_page2[0].get("text", "") == sent_texts[1]
-        assert messages_page2[1].get("text", "") == sent_texts[0]
-        assert cursor2 == ""
-
-    def test_message_by_message_id(self):
-        sent_texts, responses = self.send_multiple_one_to_one_messages(1)
-
-        message_id = responses[0].get("result", {}).get("messages", [])[0].get("id", "")
-        response = self.sender.wakuext_service.message_by_message_id(message_id)
-
-        self.sender.verify_json_schema(response, method="wakuext_messageByMessageID")
-
-        actual_text = response.get("result", {}).get("text", "")
-        assert actual_text == sent_texts[0]
-
-    @pytest.mark.parametrize(
-        "searchTerm,caseSensitive,expectedCount",
-        [
-            ("test_message_1", False, 1),
-            ("TEST_MESSAGE_", False, 3),
-            # ("TEST_MESSAGE_", True, 0),  # Skipped due to https://github.com/status-im/status-go/issues/6359
-        ],
-    )
-    def test_all_messages_from_chat_which_match_term(self, searchTerm, caseSensitive, expectedCount):
-        self.send_multiple_one_to_one_messages(3)
-        sender_chat_id = self.receiver.public_key
-
-        response = self.sender.wakuext_service.all_messages_from_chat_which_match_term(sender_chat_id, searchTerm, caseSensitive)
-
-        self.sender.verify_json_schema(response, method="wakuext_allMessagesFromChatWhichMatchTerm")
-
-        messages = response.get("result", {}).get("messages", [])
-        assert len(messages) == expectedCount
+class TestInteractingWithChatMessages(MessengerSteps):
 
     def test_pinned_messages(self):
         sent_texts, responses = self.send_multiple_one_to_one_messages(1)
@@ -94,7 +25,7 @@ def test_pinned_messages(self):
 
         sender_chat_id = self.receiver.public_key
         response = self.sender.wakuext_service.chat_pinned_messages(sender_chat_id)
-        self.sender.verify_json_schema(response, method="wakuext_schatPinnedMessages")
+        self.sender.verify_json_schema(response, method="wakuext_chatPinnedMessages")
 
         pinned_messages = response.get("result", {}).get("pinnedMessages", [])
         assert len(pinned_messages) == 1
@@ -226,43 +157,14 @@ def test_delete_message_for_me_and_sync(self):
 
         # TODO: assert sync action
 
-    def test_first_unseen_message(self):
+    def test_update_message_outgoing_status(self):
         _, responses = self.send_multiple_one_to_one_messages(1)
-        sender_chat_id = self.receiver.public_key
         message_id = responses[0].get("result", {}).get("messages", [])[0].get("id", "")
+        new_status = "delivered"
 
-        response = self.sender.wakuext_service.mark_message_as_unread(sender_chat_id, message_id)
-        self.sender.verify_json_schema(response, method="wakuext_markMessageAsUnread")
-
-        response = self.sender.wakuext_service.first_unseen_message_id(sender_chat_id)
-        self.sender.verify_json_schema(response, method="wakuext_firstUnseenMessageID")
+        response = self.sender.wakuext_service.update_message_outgoing_status(message_id, new_status)
+        self.sender.verify_json_schema(response, method="wakuext_updateMessageOutgoingStatus")
 
-        result = response.get("result", "")
-        assert result == message_id
-
-
-@pytest.mark.usefixtures("setup_two_unprivileged_nodes")
-@pytest.mark.rpc
-class TestUserStatus(MessengerSteps):
-
-    def test_status_updates(self):
-        self.make_contacts()
-
-        statuses = [[1, "text_1"], [2, "text_2"], [3, "text_3"], [4, "text_4"]]
-
-        for new_status, custom_text in statuses:
-            response = self.sender.wakuext_service.set_user_status(new_status, custom_text)
-            self.sender.verify_json_schema(response, method="wakuext_setUserStatus")
-
-            self.receiver.find_signal_containing_pattern(
-                SignalType.MESSAGES_NEW.value,
-                event_pattern=custom_text,
-                timeout=10,
-            )
-
-            response = self.receiver.wakuext_service.status_updates()
-            self.sender.verify_json_schema(response, method="wakuext_statusUpdates")
-
-            statusUpdate = response.get("result", {}).get("statusUpdates", [])[0]
-            assert statusUpdate.get("statusType", -1) == new_status
-            assert statusUpdate.get("text", "") == custom_text
+        response = self.sender.wakuext_service.message_by_message_id(message_id)
+        outgoing_status = response.get("result", {}).get("outgoingStatus", "")
+        assert outgoing_status == new_status

Diff for: tests-functional/tests/test_wakuext_messages_fetching.py

@@ -0,0 +1,29 @@
+import pytest
+
+from steps.messenger import MessengerSteps
+
+
+@pytest.mark.usefixtures("setup_two_unprivileged_nodes")
+@pytest.mark.rpc
+class TestSendingChatMessages(MessengerSteps):
+    def test_one_to_one_messages(self):
+        responses = self.one_to_one_message(1)
+        self.receiver.verify_json_schema(responses[0], method="wakuext_sendOneToOneMessage")
+
+        chat = responses[0]["result"]["chats"][0]
+        assert chat["id"] == self.receiver.public_key
+        assert chat["lastMessage"]["displayName"] == self.sender.display_name
+
+    def test_send_community_message(self):
+        self.create_community(self.sender)
+        community_chat_id = self.join_community(self.receiver)
+
+        text = "test_message"
+        response = self.sender.wakuext_service.send_community_chat_message(community_chat_id, text)
+        self.sender.verify_json_schema(response, method="wakuext_sendChatMessage")
+
+        response = self.sender.wakuext_service.chat_messages(community_chat_id)
+        messages = response.get("result", {}).get("messages", [])
+        assert len(messages) == 1
+        actual_text = messages[0].get("text", "")
+        assert actual_text == text