From b7d5f37334854d1c87adfea9fa49dc9c0e39eb25 Mon Sep 17 00:00:00 2001 From: Anton Date: Mon, 3 Feb 2025 15:00:42 +0100 Subject: [PATCH 1/9] test_: bring back messaging tests for functional check --- .../tests/reliability/test_contact_request.py | 35 +-------- .../reliability/test_one_to_one_messages.py | 20 +---- tests-functional/tests/test_cases.py | 57 ++++++++++++++ tests-functional/tests/test_waku_rpc.py | 77 ++----------------- 4 files changed, 67 insertions(+), 122 deletions(-) diff --git a/tests-functional/tests/reliability/test_contact_request.py b/tests-functional/tests/reliability/test_contact_request.py index 7a6e3dcf24..c6c1eb1528 100644 --- a/tests-functional/tests/reliability/test_contact_request.py +++ b/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): diff --git a/tests-functional/tests/reliability/test_one_to_one_messages.py b/tests-functional/tests/reliability/test_one_to_one_messages.py index faf6536f56..daa41386e2 100644 --- a/tests-functional/tests/reliability/test_one_to_one_messages.py +++ b/tests-functional/tests/reliability/test_one_to_one_messages.py @@ -11,25 +11,7 @@ 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) diff --git a/tests-functional/tests/test_cases.py b/tests-functional/tests/test_cases.py index 599b1d51be..551d817710 100644 --- a/tests-functional/tests/test_cases.py +++ b/tests-functional/tests/test_cases.py @@ -332,3 +332,60 @@ 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): + 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, + ) diff --git a/tests-functional/tests/test_waku_rpc.py b/tests-functional/tests/test_waku_rpc.py index 927cb2234f..7c3ce0dccb 100644 --- a/tests-functional/tests/test_waku_rpc.py +++ b/tests-functional/tests/test_waku_rpc.py @@ -6,7 +6,7 @@ import pytest from conftest import option -from test_cases import StatusBackendTestCase +from test_cases import StatusBackendTestCase, MessengerTestCase class TestRpc(StatusBackendTestCase): @@ -28,73 +28,12 @@ def test_(self, method, params): self.rpc_client.verify_json_schema(response.json(), method) -@pytest.mark.skip("to be reworked via status-backend") -class TestRpcMessaging(StatusBackendTestCase): - @dataclass - class User: - rpc_url: str - chat_public_key: Optional[str] = None - chat_id: Optional[str] = None +@pytest.mark.rpc +class TestRpcMessaging(MessengerTestCase): - def test_add_contact(self): - _id = str(random.randint(1, 8888)) - - self.user_1 = self.User(rpc_url=option.rpc_url) - self.user_2 = self.User(rpc_url=option.rpc_url_2) - - # get chat public key - for user in self.user_1, self.user_2: - response = self.rpc_client.rpc_request("accounts_getAccounts", [], _id, url=user.rpc_url) - self.rpc_client.verify_is_valid_json_rpc_response(response) - - user.chat_public_key = next( - (item["public-key"] for item in response.json()["result"] if item["chat"]), - None, - ) + @pytest.mark.usefixtures("setup_two_nodes") + def test_one_to_one_message(self): + self.one_to_one_message(5) - # send contact requests - for sender in self.user_1, self.user_2: - for receiver in self.user_1, self.user_2: - if sender != receiver: - response = self.rpc_client.rpc_request( - method="wakuext_sendContactRequest", - params=[ - { - "id": receiver.chat_public_key, - "message": f"contact request from {sender.chat_public_key}: sent at {time.time()}", - } - ], - request_id=99, - url=sender.rpc_url, - ) - - self.rpc_client.verify_is_valid_json_rpc_response(response) - sender.chat_id = response.json()["result"]["chats"][0]["lastMessage"]["id"] - - # accept contact requests - for user in self.user_1, self.user_2: - response = self.rpc_client.rpc_request( - method="wakuext_acceptContactRequest", - params=[ - { - "id": user.chat_id, - } - ], - request_id=99, - url=user.rpc_url, - ) - self.rpc_client.verify_is_valid_json_rpc_response(response) - - # verify contacts - for user in (self.user_1, self.user_2), (self.user_2, self.user_1): - response = self.rpc_client.rpc_request( - method="wakuext_contacts", - params=[], - request_id=99, - url=user[0].rpc_url, - ) - self.rpc_client.verify_is_valid_json_rpc_response(response) - - response = response.json() - assert response["result"][0]["added"] is True - assert response["result"][0]["id"] == user[1].chat_public_key + def test_add_contact(self): + self.add_contact(execution_number=1, network_condition=None) From 579f07fe7414cdbd683eba9c351916ff53a4b26b Mon Sep 17 00:00:00 2001 From: Anton Date: Mon, 3 Feb 2025 16:22:48 +0100 Subject: [PATCH 2/9] test_: added light client messaging --- tests-functional/clients/services/wakuext.py | 5 ++ .../reliability/test_create_private_groups.py | 24 +-------- .../test_private_groups_messages.py | 21 +------- tests-functional/tests/test_cases.py | 53 +++++++++++++++++-- tests-functional/tests/test_waku_rpc.py | 38 +++++++++---- 5 files changed, 85 insertions(+), 56 deletions(-) diff --git a/tests-functional/clients/services/wakuext.py b/tests-functional/clients/services/wakuext.py index 765af594c7..11f614d03b 100644 --- a/tests-functional/clients/services/wakuext.py +++ b/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() diff --git a/tests-functional/tests/reliability/test_create_private_groups.py b/tests-functional/tests/reliability/test_create_private_groups.py index 16d66dd9c8..3f0c8cf45a 100644 --- a/tests-functional/tests/reliability/test_create_private_groups.py +++ b/tests-functional/tests/reliability/test_create_private_groups.py @@ -12,29 +12,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) diff --git a/tests-functional/tests/reliability/test_private_groups_messages.py b/tests-functional/tests/reliability/test_private_groups_messages.py index 3bf37b9a8b..de507df2ef 100644 --- a/tests-functional/tests/reliability/test_private_groups_messages.py +++ b/tests-functional/tests/reliability/test_private_groups_messages.py @@ -13,26 +13,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) def test_multiple_group_chat_messages(self): self.test_private_group_messages_baseline(message_count=50) diff --git a/tests-functional/tests/test_cases.py b/tests-functional/tests/test_cases.py index 551d817710..0de245714a 100644 --- a/tests-functional/tests/test_cases.py +++ b/tests-functional/tests/test_cases.py @@ -210,11 +210,11 @@ class MessengerTestCase(NetworkConditionTestCase): @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() @@ -389,3 +389,48 @@ def add_contact(self, execution_number, network_condition): 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): + 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) + 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, + ) diff --git a/tests-functional/tests/test_waku_rpc.py b/tests-functional/tests/test_waku_rpc.py index 7c3ce0dccb..0d57ec1dc0 100644 --- a/tests-functional/tests/test_waku_rpc.py +++ b/tests-functional/tests/test_waku_rpc.py @@ -1,11 +1,5 @@ import random -import time -from dataclasses import dataclass -from typing import Optional - import pytest - -from conftest import option from test_cases import StatusBackendTestCase, MessengerTestCase @@ -29,11 +23,37 @@ def test_(self, method, params): @pytest.mark.rpc -class TestRpcMessaging(MessengerTestCase): +@pytest.mark.usefixtures("setup_two_nodes") +class TestDefaultMessaging(MessengerTestCase): - @pytest.mark.usefixtures("setup_two_nodes") - def test_one_to_one_message(self): + @pytest.fixture(scope="function", autouse=False) + def setup_two_nodes(self, request): + request.cls.sender = self.sender = self.initialize_backend(self.await_signals, False) + request.cls.receiver = self.receiver = self.initialize_backend(self.await_signals, False) + + def test_one_to_one_messages(self): self.one_to_one_message(5) def test_add_contact(self): self.add_contact(execution_number=1, network_condition=None) + + def test_crate_private_group(self): + self.make_contacts() + self.create_private_group(1) + + def test_private_group_messages(self): + self.make_contacts() + self.private_group_id = self.join_private_group() + self.private_group_message(5) + + +@pytest.mark.rpc +@pytest.mark.usefixtures("setup_two_nodes") +class TestLightClientMessaging(TestDefaultMessaging): + + @pytest.fixture(scope="function", autouse=False) + def setup_two_nodes(self, request): + request.cls.sender = self.sender = self.initialize_backend(self.await_signals, False) + request.cls.receiver = self.receiver = self.initialize_backend(self.await_signals, False) + for user in self.sender, self.receiver: + user.wakuext_service.set_light_client(True) From 70e3799b95fdfded37c2d3de36a36faf8aca4703 Mon Sep 17 00:00:00 2001 From: Anton Date: Mon, 3 Feb 2025 16:28:56 +0100 Subject: [PATCH 3/9] test_: fix lint errors --- .../tests/reliability/test_create_private_groups.py | 1 - .../tests/reliability/test_one_to_one_messages.py | 1 - .../tests/reliability/test_private_groups_messages.py | 3 +-- tests-functional/tests/test_cases.py | 4 ++-- tests-functional/tests/test_waku_rpc.py | 2 +- 5 files changed, 4 insertions(+), 7 deletions(-) diff --git a/tests-functional/tests/reliability/test_create_private_groups.py b/tests-functional/tests/reliability/test_create_private_groups.py index 3f0c8cf45a..9db0946441 100644 --- a/tests-functional/tests/reliability/test_create_private_groups.py +++ b/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") diff --git a/tests-functional/tests/reliability/test_one_to_one_messages.py b/tests-functional/tests/reliability/test_one_to_one_messages.py index daa41386e2..f897ec5f2d 100644 --- a/tests-functional/tests/reliability/test_one_to_one_messages.py +++ b/tests-functional/tests/reliability/test_one_to_one_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") diff --git a/tests-functional/tests/reliability/test_private_groups_messages.py b/tests-functional/tests/reliability/test_private_groups_messages.py index de507df2ef..bd141c77ef 100644 --- a/tests-functional/tests/reliability/test_private_groups_messages.py +++ b/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,7 +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() - self.private_group_message(message_count) + 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) diff --git a/tests-functional/tests/test_cases.py b/tests-functional/tests/test_cases.py index 0de245714a..050e33d0ca 100644 --- a/tests-functional/tests/test_cases.py +++ b/tests-functional/tests/test_cases.py @@ -414,11 +414,11 @@ def create_private_group(self, private_groups_count): fields_to_validate={"text": "text"}, ) - def private_group_message(self, message_count): + 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(self.private_group_id, message_text) + 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) diff --git a/tests-functional/tests/test_waku_rpc.py b/tests-functional/tests/test_waku_rpc.py index 0d57ec1dc0..8003054145 100644 --- a/tests-functional/tests/test_waku_rpc.py +++ b/tests-functional/tests/test_waku_rpc.py @@ -44,7 +44,7 @@ def test_crate_private_group(self): def test_private_group_messages(self): self.make_contacts() self.private_group_id = self.join_private_group() - self.private_group_message(5) + self.private_group_message(5, self.private_group_id) @pytest.mark.rpc From 3803e7e310f83577dd16839b2b856fe9e41e7f91 Mon Sep 17 00:00:00 2001 From: Anton Date: Mon, 3 Feb 2025 16:47:43 +0100 Subject: [PATCH 4/9] test_: fix test_add_contact --- tests-functional/tests/test_cases.py | 6 +++--- tests-functional/tests/test_waku_rpc.py | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tests-functional/tests/test_cases.py b/tests-functional/tests/test_cases.py index 050e33d0ca..cfdc932daf 100644 --- a/tests-functional/tests/test_cases.py +++ b/tests-functional/tests/test_cases.py @@ -354,10 +354,10 @@ def one_to_one_message(self, message_count): expected_message=expected_message, ) - def add_contact(self, execution_number, network_condition): + def add_contact(self, execution_number, network_condition, privileged=True): 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) + 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() diff --git a/tests-functional/tests/test_waku_rpc.py b/tests-functional/tests/test_waku_rpc.py index 8003054145..199401d790 100644 --- a/tests-functional/tests/test_waku_rpc.py +++ b/tests-functional/tests/test_waku_rpc.py @@ -35,7 +35,7 @@ def test_one_to_one_messages(self): self.one_to_one_message(5) def test_add_contact(self): - self.add_contact(execution_number=1, network_condition=None) + self.add_contact(execution_number=1, network_condition=None, privileged=False) def test_crate_private_group(self): self.make_contacts() From 955a94849fa83f3d8c164c2008f653ae9e3893aa Mon Sep 17 00:00:00 2001 From: Anton Date: Thu, 6 Feb 2025 15:20:39 +0100 Subject: [PATCH 5/9] test_: restart to set light client --- tests-functional/tests/test_waku_rpc.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests-functional/tests/test_waku_rpc.py b/tests-functional/tests/test_waku_rpc.py index 199401d790..0be06f61f3 100644 --- a/tests-functional/tests/test_waku_rpc.py +++ b/tests-functional/tests/test_waku_rpc.py @@ -56,4 +56,7 @@ def setup_two_nodes(self, request): request.cls.sender = self.sender = self.initialize_backend(self.await_signals, False) request.cls.receiver = self.receiver = self.initialize_backend(self.await_signals, False) for user in self.sender, self.receiver: + key_uid = user.node_login_event["event"]["account"]["key-uid"] user.wakuext_service.set_light_client(True) + user.logout() + user.login(key_uid) From 5774be68586cc3ebab25f71d6191aa79306bc441 Mon Sep 17 00:00:00 2001 From: Anton Date: Mon, 10 Feb 2025 12:49:51 +0100 Subject: [PATCH 6/9] test_: wait for logout/login --- tests-functional/clients/signals.py | 5 +++++ tests-functional/tests/test_cases.py | 1 + tests-functional/tests/test_waku_rpc.py | 3 +++ 3 files changed, 9 insertions(+) diff --git a/tests-functional/clients/signals.py b/tests-functional/clients/signals.py index 49e098a084..d6ddfb7dbc 100644 --- a/tests-functional/clients/signals.py +++ b/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: diff --git a/tests-functional/tests/test_cases.py b/tests-functional/tests/test_cases.py index cfdc932daf..6787dd8dba 100644 --- a/tests-functional/tests/test_cases.py +++ b/tests-functional/tests/test_cases.py @@ -206,6 +206,7 @@ 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) diff --git a/tests-functional/tests/test_waku_rpc.py b/tests-functional/tests/test_waku_rpc.py index 0be06f61f3..ec6ee73fad 100644 --- a/tests-functional/tests/test_waku_rpc.py +++ b/tests-functional/tests/test_waku_rpc.py @@ -59,4 +59,7 @@ def setup_two_nodes(self, request): key_uid = user.node_login_event["event"]["account"]["key-uid"] user.wakuext_service.set_light_client(True) user.logout() + user.wait_for_logout() user.login(key_uid) + user.prepare_wait_for_signal("node.login", 1) + user.wait_for_login() From 388444c48c192c0233f7b21ccf8043d3e1208518 Mon Sep 17 00:00:00 2001 From: Anton Date: Tue, 11 Feb 2025 13:33:20 +0100 Subject: [PATCH 7/9] test_: skip lightclient tests --- tests-functional/tests/test_cases.py | 174 ++++++++++++++++++------ tests-functional/tests/test_waku_rpc.py | 1 + 2 files changed, 133 insertions(+), 42 deletions(-) diff --git a/tests-functional/tests/test_cases.py b/tests-functional/tests/test_cases.py index 6787dd8dba..b71f406309 100644 --- a/tests-functional/tests/test_cases.py +++ b/tests-functional/tests/test_cases.py @@ -64,7 +64,9 @@ def wallet_create_multi_transaction(self, **kwargs): if key in transfer_tx_data: transfer_tx_data[key] = new_value else: - logging.info(f"Warning: The key '{key}' does not exist in the transferTx parameters and will be ignored.") + logging.info( + f"Warning: The key '{key}' does not exist in the transferTx parameters and will be ignored." + ) params = [ { "fromAddress": user_1.address, @@ -139,7 +141,9 @@ def wait_until_tx_not_pending(self, tx_hash, timeout=10): while response.json()["result"]["isPending"] is True: time_passed = time.time() - start_time if time_passed >= timeout: - raise TimeoutError(f"Tx {tx_hash} is still pending after {timeout} seconds") + raise TimeoutError( + f"Tx {tx_hash} is still pending after {timeout} seconds" + ) time.sleep(0.5) response = self.rpc_client.rpc_valid_request(method, params) return response.json()["result"]["tx"] @@ -162,7 +166,9 @@ class NetworkConditionTestCase: @contextmanager def add_latency(self, node, latency=300, jitter=50): logging.info("Entering context manager: add_latency") - node.container_exec(f"apk add iproute2 && tc qdisc add dev eth0 root netem delay {latency}ms {jitter}ms distribution normal") + node.container_exec( + f"apk add iproute2 && tc qdisc add dev eth0 root netem delay {latency}ms {jitter}ms distribution normal" + ) try: yield finally: @@ -172,7 +178,9 @@ def add_latency(self, node, latency=300, jitter=50): @contextmanager def add_packet_loss(self, node, packet_loss=2): logging.info("Entering context manager: add_packet_loss") - node.container_exec(f"apk add iproute2 && tc qdisc add dev eth0 root netem loss {packet_loss}%") + node.container_exec( + f"apk add iproute2 && tc qdisc add dev eth0 root netem loss {packet_loss}%" + ) try: yield finally: @@ -182,7 +190,9 @@ def add_packet_loss(self, node, packet_loss=2): @contextmanager def add_low_bandwith(self, node, rate="1mbit", burst="32kbit", limit="12500"): logging.info("Entering context manager: add_low_bandwith") - node.container_exec(f"apk add iproute2 && tc qdisc add dev eth0 root tbf rate {rate} burst {burst} limit {limit}") + node.container_exec( + f"apk add iproute2 && tc qdisc add dev eth0 root tbf rate {rate} burst {burst} limit {limit}" + ) try: yield finally: @@ -206,13 +216,17 @@ class MessengerTestCase(NetworkConditionTestCase): SignalType.MESSAGES_NEW.value, SignalType.MESSAGE_DELIVERED.value, SignalType.NODE_LOGIN.value, - SignalType.NODE_LOGOUT.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(self.await_signals, True) - request.cls.receiver = self.receiver = self.initialize_backend(self.await_signals, True) + 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, privileged=True): backend = StatusBackend(await_signals, privileged) @@ -228,30 +242,48 @@ def make_contacts(self): if self.sender.public_key in str(existing_contacts): return - response = self.sender.wakuext_service.send_contact_request(self.receiver.public_key, "contact_request") - expected_message = self.get_message_by_content_type(response, content_type=MessageContentType.CONTACT_REQUEST.value)[0] - self.receiver.find_signal_containing_pattern(SignalType.MESSAGES_NEW.value, event_pattern=expected_message.get("id")) + response = self.sender.wakuext_service.send_contact_request( + self.receiver.public_key, "contact_request" + ) + expected_message = self.get_message_by_content_type( + response, content_type=MessageContentType.CONTACT_REQUEST.value + )[0] + self.receiver.find_signal_containing_pattern( + SignalType.MESSAGES_NEW.value, event_pattern=expected_message.get("id") + ) self.receiver.wakuext_service.accept_contact_request(expected_message.get("id")) accepted_signal = f"@{self.receiver.public_key} accepted your contact request" - self.sender.find_signal_containing_pattern(SignalType.MESSAGES_NEW.value, event_pattern=accepted_signal) + self.sender.find_signal_containing_pattern( + SignalType.MESSAGES_NEW.value, event_pattern=accepted_signal + ) - def validate_signal_event_against_response(self, signal_event, fields_to_validate, expected_message): + def validate_signal_event_against_response( + self, signal_event, fields_to_validate, expected_message + ): expected_message_id = expected_message.get("id") signal_event_messages = signal_event.get("event", {}).get("messages") assert len(signal_event_messages) > 0, "No messages found in the signal event" message = next( - (message for message in signal_event_messages if message.get("id") == expected_message_id), + ( + message + for message in signal_event_messages + if message.get("id") == expected_message_id + ), None, ) - assert message, f"Message with ID {expected_message_id} not found in the signal event" + assert ( + message + ), f"Message with ID {expected_message_id} not found in the signal event" message_mismatch = [] for response_field, event_field in fields_to_validate.items(): response_value = expected_message[response_field] event_value = message[event_field] if response_value != event_value: - message_mismatch.append(f"Field '{response_field}': Expected '{response_value}', Found '{event_value}'") + message_mismatch.append( + f"Field '{response_field}': Expected '{response_value}', Found '{event_value}'" + ) if not message_mismatch: return @@ -272,16 +304,28 @@ def get_message_by_content_type(self, response, content_type, message_pattern="" if matched_messages: return matched_messages else: - raise ValueError(f"Failed to find a message with contentType '{content_type}' in response") + raise ValueError( + f"Failed to find a message with contentType '{content_type}' in response" + ) def join_private_group(self): private_group_name = f"private_group_{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}" + 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): @@ -291,8 +335,14 @@ def create_and_join_community(self): community_id = response.get("result", {}).get("communities", [{}])[0].get("id") self.receiver.wakuext_service.fetch_community(community_id) - response_to_join = self.receiver.wakuext_service.request_to_join_community(community_id) - join_id = response_to_join.get("result", {}).get("requestsToJoinCommunity", [{}])[0].get("id") + response_to_join = self.receiver.wakuext_service.request_to_join_community( + community_id + ) + join_id = ( + response_to_join.get("result", {}) + .get("requestsToJoinCommunity", [{}])[0] + .get("id") + ) # I couldn't find any signal related to the requestToJoinCommunity request in the peer node. # That's why I need this retry logic for accepting the request to join the community. @@ -300,14 +350,20 @@ def create_and_join_community(self): retry_interval = 0.5 for attempt in range(max_retries): try: - response = self.sender.wakuext_service.accept_request_to_join_community(join_id) + response = self.sender.wakuext_service.accept_request_to_join_community( + join_id + ) if response.get("result"): break except Exception as e: - logging.error(f"Attempt {attempt + 1}/{max_retries}: Unexpected error: {e}") + logging.error( + f"Attempt {attempt + 1}/{max_retries}: Unexpected error: {e}" + ) time.sleep(retry_interval) else: - raise Exception(f"Failed to accept request to join community in {max_retries * retry_interval} seconds.") + raise Exception( + f"Failed to accept request to join community in {max_retries * retry_interval} seconds." + ) chats = response.get("result", {}).get("communities", [{}])[0].get("chats", {}) chat_id = list(chats.keys())[0] if chats else None @@ -317,8 +373,12 @@ def community_messages(self, message_chat_id, message_count): sent_messages = [] for i in range(message_count): message_text = f"test_message_{i+1}_{uuid4()}" - response = self.sender.wakuext_service.send_community_chat_message(message_chat_id, message_text) - expected_message = self.get_message_by_content_type(response, content_type=MessageContentType.TEXT_PLAIN.value)[0] + response = self.sender.wakuext_service.send_community_chat_message( + message_chat_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) @@ -338,8 +398,12 @@ 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] + 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) @@ -357,19 +421,29 @@ def one_to_one_message(self, message_count): def add_contact(self, execution_number, network_condition, 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) + 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!!") + 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] + 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, @@ -379,7 +453,11 @@ def add_contact(self, execution_number, network_condition, privileged=True): 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) + 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 @@ -395,11 +473,17 @@ 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) + 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_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] private_groups.append(expected_message) @@ -407,7 +491,9 @@ def create_private_group(self, private_groups_count): 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 + SignalType.MESSAGES_NEW.value, + event_pattern=expected_message.get("id"), + timeout=60, ) self.validate_signal_event_against_response( signal_event=messages_new_event, @@ -419,8 +505,12 @@ 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] + 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) diff --git a/tests-functional/tests/test_waku_rpc.py b/tests-functional/tests/test_waku_rpc.py index ec6ee73fad..f24be2af09 100644 --- a/tests-functional/tests/test_waku_rpc.py +++ b/tests-functional/tests/test_waku_rpc.py @@ -48,6 +48,7 @@ def test_private_group_messages(self): @pytest.mark.rpc +@pytest.mark.skip @pytest.mark.usefixtures("setup_two_nodes") class TestLightClientMessaging(TestDefaultMessaging): From 7830c157ded9d152ff0af82dd07940f74237b8c9 Mon Sep 17 00:00:00 2001 From: Anton Date: Tue, 11 Feb 2025 13:34:50 +0100 Subject: [PATCH 8/9] test_: fix typo --- tests-functional/tests/test_cases.py | 2 +- tests-functional/tests/test_waku_rpc.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests-functional/tests/test_cases.py b/tests-functional/tests/test_cases.py index b71f406309..2fdfdbf94c 100644 --- a/tests-functional/tests/test_cases.py +++ b/tests-functional/tests/test_cases.py @@ -419,7 +419,7 @@ def one_to_one_message(self, message_count): expected_message=expected_message, ) - def add_contact(self, execution_number, network_condition, privileged=True): + 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 diff --git a/tests-functional/tests/test_waku_rpc.py b/tests-functional/tests/test_waku_rpc.py index f24be2af09..6fae44a34d 100644 --- a/tests-functional/tests/test_waku_rpc.py +++ b/tests-functional/tests/test_waku_rpc.py @@ -37,7 +37,7 @@ def test_one_to_one_messages(self): def test_add_contact(self): self.add_contact(execution_number=1, network_condition=None, privileged=False) - def test_crate_private_group(self): + def test_create_private_group(self): self.make_contacts() self.create_private_group(1) From 073ad53e91cfa471caa51a69628353fd68a18551 Mon Sep 17 00:00:00 2001 From: Anton Date: Tue, 11 Feb 2025 13:42:30 +0100 Subject: [PATCH 9/9] test_: paint it black --- tests-functional/tests/test_cases.py | 154 +++++++-------------------- 1 file changed, 37 insertions(+), 117 deletions(-) diff --git a/tests-functional/tests/test_cases.py b/tests-functional/tests/test_cases.py index 2fdfdbf94c..3fac2b2ecc 100644 --- a/tests-functional/tests/test_cases.py +++ b/tests-functional/tests/test_cases.py @@ -64,9 +64,7 @@ def wallet_create_multi_transaction(self, **kwargs): if key in transfer_tx_data: transfer_tx_data[key] = new_value else: - logging.info( - f"Warning: The key '{key}' does not exist in the transferTx parameters and will be ignored." - ) + logging.info(f"Warning: The key '{key}' does not exist in the transferTx parameters and will be ignored.") params = [ { "fromAddress": user_1.address, @@ -141,9 +139,7 @@ def wait_until_tx_not_pending(self, tx_hash, timeout=10): while response.json()["result"]["isPending"] is True: time_passed = time.time() - start_time if time_passed >= timeout: - raise TimeoutError( - f"Tx {tx_hash} is still pending after {timeout} seconds" - ) + raise TimeoutError(f"Tx {tx_hash} is still pending after {timeout} seconds") time.sleep(0.5) response = self.rpc_client.rpc_valid_request(method, params) return response.json()["result"]["tx"] @@ -166,9 +162,7 @@ class NetworkConditionTestCase: @contextmanager def add_latency(self, node, latency=300, jitter=50): logging.info("Entering context manager: add_latency") - node.container_exec( - f"apk add iproute2 && tc qdisc add dev eth0 root netem delay {latency}ms {jitter}ms distribution normal" - ) + node.container_exec(f"apk add iproute2 && tc qdisc add dev eth0 root netem delay {latency}ms {jitter}ms distribution normal") try: yield finally: @@ -178,9 +172,7 @@ def add_latency(self, node, latency=300, jitter=50): @contextmanager def add_packet_loss(self, node, packet_loss=2): logging.info("Entering context manager: add_packet_loss") - node.container_exec( - f"apk add iproute2 && tc qdisc add dev eth0 root netem loss {packet_loss}%" - ) + node.container_exec(f"apk add iproute2 && tc qdisc add dev eth0 root netem loss {packet_loss}%") try: yield finally: @@ -190,9 +182,7 @@ def add_packet_loss(self, node, packet_loss=2): @contextmanager def add_low_bandwith(self, node, rate="1mbit", burst="32kbit", limit="12500"): logging.info("Entering context manager: add_low_bandwith") - node.container_exec( - f"apk add iproute2 && tc qdisc add dev eth0 root tbf rate {rate} burst {burst} limit {limit}" - ) + node.container_exec(f"apk add iproute2 && tc qdisc add dev eth0 root tbf rate {rate} burst {burst} limit {limit}") try: yield finally: @@ -221,12 +211,8 @@ class MessengerTestCase(NetworkConditionTestCase): @pytest.fixture(scope="function", autouse=False) def setup_two_nodes(self, request): - request.cls.sender = self.sender = self.initialize_backend( - self.await_signals, True - ) - request.cls.receiver = self.receiver = self.initialize_backend( - self.await_signals, True - ) + 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, privileged=True): backend = StatusBackend(await_signals, privileged) @@ -242,48 +228,30 @@ def make_contacts(self): if self.sender.public_key in str(existing_contacts): return - response = self.sender.wakuext_service.send_contact_request( - self.receiver.public_key, "contact_request" - ) - expected_message = self.get_message_by_content_type( - response, content_type=MessageContentType.CONTACT_REQUEST.value - )[0] - self.receiver.find_signal_containing_pattern( - SignalType.MESSAGES_NEW.value, event_pattern=expected_message.get("id") - ) + response = self.sender.wakuext_service.send_contact_request(self.receiver.public_key, "contact_request") + expected_message = self.get_message_by_content_type(response, content_type=MessageContentType.CONTACT_REQUEST.value)[0] + self.receiver.find_signal_containing_pattern(SignalType.MESSAGES_NEW.value, event_pattern=expected_message.get("id")) self.receiver.wakuext_service.accept_contact_request(expected_message.get("id")) accepted_signal = f"@{self.receiver.public_key} accepted your contact request" - self.sender.find_signal_containing_pattern( - SignalType.MESSAGES_NEW.value, event_pattern=accepted_signal - ) + self.sender.find_signal_containing_pattern(SignalType.MESSAGES_NEW.value, event_pattern=accepted_signal) - def validate_signal_event_against_response( - self, signal_event, fields_to_validate, expected_message - ): + def validate_signal_event_against_response(self, signal_event, fields_to_validate, expected_message): expected_message_id = expected_message.get("id") signal_event_messages = signal_event.get("event", {}).get("messages") assert len(signal_event_messages) > 0, "No messages found in the signal event" message = next( - ( - message - for message in signal_event_messages - if message.get("id") == expected_message_id - ), + (message for message in signal_event_messages if message.get("id") == expected_message_id), None, ) - assert ( - message - ), f"Message with ID {expected_message_id} not found in the signal event" + assert message, f"Message with ID {expected_message_id} not found in the signal event" message_mismatch = [] for response_field, event_field in fields_to_validate.items(): response_value = expected_message[response_field] event_value = message[event_field] if response_value != event_value: - message_mismatch.append( - f"Field '{response_field}': Expected '{response_value}', Found '{event_value}'" - ) + message_mismatch.append(f"Field '{response_field}': Expected '{response_value}', Found '{event_value}'") if not message_mismatch: return @@ -304,18 +272,12 @@ def get_message_by_content_type(self, response, content_type, message_pattern="" if matched_messages: return matched_messages else: - raise ValueError( - f"Failed to find a message with contentType '{content_type}' in response" - ) + raise ValueError(f"Failed to find a message with contentType '{content_type}' in response") def join_private_group(self): private_group_name = f"private_group_{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}" - ) + 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, @@ -335,14 +297,8 @@ def create_and_join_community(self): community_id = response.get("result", {}).get("communities", [{}])[0].get("id") self.receiver.wakuext_service.fetch_community(community_id) - response_to_join = self.receiver.wakuext_service.request_to_join_community( - community_id - ) - join_id = ( - response_to_join.get("result", {}) - .get("requestsToJoinCommunity", [{}])[0] - .get("id") - ) + response_to_join = self.receiver.wakuext_service.request_to_join_community(community_id) + join_id = response_to_join.get("result", {}).get("requestsToJoinCommunity", [{}])[0].get("id") # I couldn't find any signal related to the requestToJoinCommunity request in the peer node. # That's why I need this retry logic for accepting the request to join the community. @@ -350,20 +306,14 @@ def create_and_join_community(self): retry_interval = 0.5 for attempt in range(max_retries): try: - response = self.sender.wakuext_service.accept_request_to_join_community( - join_id - ) + response = self.sender.wakuext_service.accept_request_to_join_community(join_id) if response.get("result"): break except Exception as e: - logging.error( - f"Attempt {attempt + 1}/{max_retries}: Unexpected error: {e}" - ) + logging.error(f"Attempt {attempt + 1}/{max_retries}: Unexpected error: {e}") time.sleep(retry_interval) else: - raise Exception( - f"Failed to accept request to join community in {max_retries * retry_interval} seconds." - ) + raise Exception(f"Failed to accept request to join community in {max_retries * retry_interval} seconds.") chats = response.get("result", {}).get("communities", [{}])[0].get("chats", {}) chat_id = list(chats.keys())[0] if chats else None @@ -373,12 +323,8 @@ def community_messages(self, message_chat_id, message_count): sent_messages = [] for i in range(message_count): message_text = f"test_message_{i+1}_{uuid4()}" - response = self.sender.wakuext_service.send_community_chat_message( - message_chat_id, message_text - ) - expected_message = self.get_message_by_content_type( - response, content_type=MessageContentType.TEXT_PLAIN.value - )[0] + response = self.sender.wakuext_service.send_community_chat_message(message_chat_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) @@ -398,12 +344,8 @@ 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] + 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) @@ -421,29 +363,19 @@ def one_to_one_message(self, message_count): 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 - ) + 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!!" - ) + 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] + 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, @@ -453,11 +385,7 @@ def add_contact(self, execution_number, network_condition=None, privileged=True) 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 - ) + 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 @@ -473,13 +401,9 @@ 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 - ) + 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_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, @@ -505,12 +429,8 @@ 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] + 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)