test_: fix

tests-functional/clients/status_backend.py

@@ -11,6 +11,7 @@
 import docker
 import docker.errors
 import os
+
 from tenacity import retry, stop_after_delay, wait_fixed
 from clients.services.wallet import WalletService
 from clients.services.wakuext import WakuextService
@@ -21,7 +22,6 @@
 from conftest import option
 from resources.constants import user_1, DEFAULT_DISPLAY_NAME, USER_DIR
 from docker.errors import APIError
-from docker.types import IPAMConfig, IPAMPool
 
 NANOSECONDS_PER_SECOND = 1_000_000_000
 
@@ -30,9 +30,7 @@ class StatusBackend(RpcClient, SignalClient):
 
     container = None
 
-    def __init__(self, await_signals=[], privileged=False, custom_network=False):
-        self.docker_project_name = option.docker_project_name
-        self.network_name = f"{self.docker_project_name}_default"
+    def __init__(self, await_signals=[], privileged=False):
         if option.status_backend_url:
             url = option.status_backend_url
         else:
@@ -43,7 +41,7 @@ def __init__(self, await_signals=[], privileged=False, custom_network=False):
                 try:
                     host_port = random.choice(option.status_backend_port_range)
                     ports_tried.append(host_port)
-                    self.container = self._start_container(host_port, privileged, custom_network)
+                    self.container = self._start_container(host_port, privileged)
                     url = f"http://127.0.0.1:{host_port}"
                     option.status_backend_port_range.remove(host_port)
                     break
@@ -72,11 +70,12 @@ def __init__(self, await_signals=[], privileged=False, custom_network=False):
         self.accounts_service = AccountService(self)
         self.settings_service = SettingsService(self)
 
-    def _start_container(self, host_port, privileged, custom_network):
+    def _start_container(self, host_port, privileged):
+        docker_project_name = option.docker_project_name
 
         identifier = os.environ.get("BUILD_ID") if os.environ.get("CI") else os.popen("git rev-parse --short HEAD").read().strip()
-        image_name = f"{self.docker_project_name}-status-backend:latest"
-        container_name = f"{self.docker_project_name}-{identifier}-status-backend-{host_port}"
+        image_name = f"{docker_project_name}-status-backend:latest"
+        container_name = f"{docker_project_name}-{identifier}-status-backend-{host_port}"
 
         coverage_path = option.codecov_dir if option.codecov_dir else os.path.abspath("./coverage/binary")
 
@@ -85,7 +84,7 @@ def _start_container(self, host_port, privileged, custom_network):
             "detach": True,
             "privileged": privileged,
             "name": container_name,
-            "labels": {"com.docker.compose.project": self.docker_project_name},
+            "labels": {"com.docker.compose.project": docker_project_name},
             "entrypoint": [
                 "status-backend",
                 "--address",
@@ -107,11 +106,8 @@ def _start_container(self, host_port, privileged, custom_network):
 
         container = self.docker_client.containers.run(**container_args)
 
-        if custom_network:
-            self._create_and_connect_to_custom_network(f"{self.docker_project_name}_custom", container)
-        else:
-            self.docker_network = self.docker_client.networks.get(self.network_name)
-            self.docker_network.connect(container)
+        network = self.docker_client.networks.get(f"{docker_project_name}_default")
+        network.connect(container)
 
         option.status_backend_containers.append(self)
         return container
@@ -204,25 +200,23 @@ def extract_data(self, path: str):
 
         return temp_dir
 
-    def create_account_and_login(
-        self,
-        data_dir=USER_DIR,
-        display_name=None,
-        password=user_1.password,
-    ):
-        self.display_name = (
-            display_name if display_name else f"DISP_NAME_{''.join(random.choices(string.ascii_letters + string.digits + '_-', k=10))}"
+    def create_account_and_login(self, data_dir=USER_DIR, **kwargs):
+        self.display_name = kwargs.get(
+            "display_name",
+            f"DISP_NAME_{''.join(random.choices(string.ascii_letters + string.digits + '_-', k=10))}",
         )
         method = "CreateAccountAndLogin"
         data = {
             "rootDataDir": data_dir,
             "kdfIterations": 256000,
             "displayName": self.display_name,
-            "password": password,
+            "password": kwargs.get("password", user_1.password),
             "customizationColor": "primary",
             "logEnabled": True,
             "logLevel": "DEBUG",
+            "wakuV2LightClient": kwargs.get("wakuV2LightClient", False),
         }
+
         data = self._set_proxy_credentials(data)
         resp = self.api_valid_request(method, data)
         self.node_login_event = self.find_signal_containing_pattern(SignalType.NODE_LOGIN.value, event_pattern=self.display_name)
@@ -341,70 +335,15 @@ def kill(self):
             self.container = None
             logging.info("Container stopped.")
 
-    def change_container_ip(self):
+    def change_container_ip(self, new_ip="172.11.0.10"):
         if not self.container:
             raise RuntimeError("Container is not initialized.")
+        docker_project_name = option.docker_project_name
+        network_name = f"{docker_project_name}_default"
         try:
-            self.container.reload()
-            container_network_info = self.container.attrs["NetworkSettings"]["Networks"].get(self.network_name)
-            if not container_network_info or "IPAddress" not in container_network_info:
-                raise RuntimeError(f"Container {self.container.name} is not connected to network {self.network_name}")
-
-            current_ip = container_network_info["IPAddress"]
-            logging.info(f"Current IP of container {self.container.name} is {current_ip}")
-
-            logging.info(f'Attrs {self.container.attrs["NetworkSettings"]}')
-
-            # Get network details
-            network = self.docker_client.networks.get(self.network_name)
-            network_subnets = [cfg["Subnet"] for cfg in network.attrs.get("IPAM", {}).get("Config", [])]
-
-            if not network_subnets:
-                raise RuntimeError(f"Network {self.network_name} does not have a user-defined subnet. " f"Cannot manually assign an IP.")
-
-            logging.info(f"Network {self.network_name} subnets: {network_subnets}")
-
-            new_ip = self._get_random_available_ip(self.docker_network, subnet="173.18.0")
-            logging.info(f"Changing container {self.container.name} IP from {current_ip} to {new_ip}")
-
-            self.docker_network.disconnect(self.container)
-            self.docker_network.connect(self.container, ipv4_address=new_ip)
-
+            network = self.docker_client.networks.get(network_name)
+            network.disconnect(self.container)
+            network.connect(self.container, ipv4_address=new_ip)
+            logging.info(f"Changed container {self.container.name} IP to {new_ip}")
         except Exception as e:
             raise RuntimeError(f"Failed to change container IP: {e}")
-
-    def _get_random_available_ip(self, network, subnet):
-        used_ips = []
-        for cid in network.attrs.get("Containers", {}):
-            try:
-                container = network.client.containers.get(cid)
-                ip = container.attrs["NetworkSettings"]["Networks"][network.name].get("IPAddress")
-                if ip:
-                    used_ips.append(ip)
-            except docker.errors.NotFound:
-                continue
-        while True:
-            random_ip = f"{subnet}.{random.randint(2, 254)}"
-            if random_ip not in used_ips:
-                return random_ip
-
-    def _create_and_connect_to_custom_network(self, name: str, container):
-        self.network_name = name
-        subnet = "173.18.0.0/24"
-        existing_networks = [net.name for net in self.docker_client.networks.list()]
-        if self.network_name not in existing_networks:
-            ipam_config = IPAMConfig(driver="default", pool_configs=[IPAMPool(subnet=subnet)])
-            self.docker_client.networks.create(name=self.network_name, driver="bridge", ipam=ipam_config)
-            logging.info(f"Created network {self.network_name} with subnet {subnet}")
-        else:
-            logging.info(f"Already found network {self.network_name} with subnet {subnet}")
-
-        self.docker_network = self.docker_client.networks.get(self.network_name)
-        random_ip = self._get_random_available_ip(self.docker_network, subnet="173.18.0")
-
-        try:
-            self.docker_network.connect(container, ipv4_address=random_ip)
-            logging.info(f"Connected container {container.name} to {self.docker_network} with IP {random_ip}")
-        except Exception as e:
-            logging.error(f"Failed to connect container to network: {e}")
-            raise RuntimeError(f"Failed to connect container to network {self.docker_network}: {e}")

tests-functional/tests/reliability/test_contact_request.py

@@ -39,8 +39,8 @@ def test_contact_request_with_node_pause_30_seconds(self):
         sender.wait_for_signal(SignalType.MESSAGE_DELIVERED.value)
 
     def test_contact_request_with_ip_change(self):
-        sender = self.initialize_backend(await_signals=self.await_signals, privileged=True, custom_network=True)
-        receiver = self.initialize_backend(await_signals=self.await_signals, privileged=True, custom_network=True)
+        sender = self.initialize_backend(await_signals=self.await_signals, privileged=True)
+        receiver = self.initialize_backend(await_signals=self.await_signals, privileged=True)
         receiver.change_container_ip()
 
         message_text = f"test_contact_request_{uuid4()}"

tests-functional/tests/test_cases.py

@@ -211,18 +211,18 @@ class MessengerTestCase(NetworkConditionTestCase):
 
     @pytest.fixture(scope="function", autouse=False)
     def setup_two_privileged_nodes(self, request):
-        request.cls.sender = self.sender = self.initialize_backend(self.await_signals, privileged=True, custom_network=True)
-        request.cls.receiver = self.receiver = self.initialize_backend(self.await_signals, privileged=True, custom_network=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)
 
     @pytest.fixture(scope="function", autouse=False)
     def setup_two_unprivileged_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 initialize_backend(self, await_signals, privileged=True, custom_network=False):
-        backend = StatusBackend(await_signals, privileged, custom_network)
+    def initialize_backend(self, await_signals, privileged=True, **kwargs):
+        backend = StatusBackend(await_signals, privileged)
         backend.init_status_backend()
-        backend.create_account_and_login()
+        backend.create_account_and_login(**kwargs)
         backend.find_public_key()
         backend.wakuext_service.start_messenger()
         return backend