test(docker): resolve hardcoded pathing for docker UI tests

- Resolved hardcoded `/workspaces/NetAlertX` path in Docker UI tests to use dynamic pathlib resolution, making tests portable across runners.
- Improved container hostname resolution safety in Docker UI tests.

Author: adamoutler

test/docker_tests/test_ldap_ui.py

@@ -50,16 +50,12 @@ def test_ldap_ui_login(tmp_path: pathlib.Path):
     """
     project_name = f"netalertx-ldap-{int(time.time())}"
 
-    workspace_dir = pathlib.Path("/workspaces/NetAlertX")
-    if workspace_dir.exists():
-        base_dir = workspace_dir / "test" / "tmp_ldap_ui"
-        base_dir.mkdir(parents=True, exist_ok=True)
-    else:
-        base_dir = tmp_path
+    repo_root = pathlib.Path(__file__).resolve().parents[2]
+    base_dir = tmp_path
 
     # Create test data directories for NetAlertX
     _create_test_data_dirs(base_dir)
-    subprocess.run(["chmod", "-R", "777", str(base_dir / "test_data")])
+    subprocess.run(["chmod", "-R", "777", str(base_dir / "test_data")], check=True)
 
     # Create LDAP bootstrap directory
     ldap_bootstrap_dir = base_dir / "ldap_bootstrap"
@@ -157,14 +153,25 @@ def get_container_name(service):
         ldap_container = get_container_name("ldap")
 
         # Connect the test container to the compose network to access the internal IPs directly
-        # The test container name is usually 'netalertx-test-container' or we can find it via hostname
+        # We parse the container ID out of /proc/self/cgroup or fallback to hostname
         test_container_id = socket.gethostname()
+        try:
+            with open("/proc/self/cgroup", "r") as f:
+                for line in f:
+                    if "docker" in line:
+                        test_container_id = line.split("/")[-1].strip()
+                        break
+        except Exception:
+            pass
+
         network_name = f"{project_name}_default"
         print(f"Connecting test container {test_container_id} to network {network_name}...")
         try:
-            subprocess.run(["docker", "network", "connect", network_name, test_container_id], check=False)
+            res = subprocess.run(["docker", "network", "connect", network_name, test_container_id], check=False, capture_output=True, text=True)
+            if res.returncode != 0 and "already exists" not in res.stderr:
+                print(f"Warning: failed to connect to network: {res.stderr}")
         except Exception as e:
-            print(f"Failed to connect network: {e}")
+            print(f"Failed to connect to network {network_name}: {e}")
 
         # Wait for LDAP to become ready
         print("Waiting for LDAP server to accept connections...")
@@ -223,8 +230,9 @@ def get_container_name(service):
 
         # Run the selenium test directly from the test container targeting the compose stack's IP
         print(f"Running UI test against {container_name} on port 20211...")
+        ldap_ui_test = repo_root / "test" / "ui" / "test_ui_ldap_login.py"
         cmd = [
-            "pytest", "/workspaces/NetAlertX/test/ui/test_ui_ldap_login.py", "-v", "-s"
+            "pytest", str(ldap_ui_test), "-v", "-s"
         ]
 
         env = os.environ.copy()

test/plugins/test_fritzbox.py

@@ -222,7 +222,7 @@ def _fc_with_mac(self, mac):
         return fc
 
     def test_returns_device_dict(self):
-        device = fritzbox.create_guest_wifi_device(self._fc_with_mac("AA:BB:CC:DD:EE:FF"), "fritz.box")
+        device = fritzbox.create_guest_wifi_device(self._fc_with_mac("AA:BB:CC:DD:EE:FF"))
         assert device is not None
         assert "mac_address" in device
         assert device["hostname"] == "Guest WiFi Network"
@@ -232,13 +232,13 @@ def test_returns_device_dict(self):
 
     def test_guest_mac_has_locally_administered_bit(self):
         """First byte must be 0x02 — locally-administered, unicast."""
-        device = fritzbox.create_guest_wifi_device(self._fc_with_mac("AA:BB:CC:DD:EE:FF"), "fritz.box")
+        device = fritzbox.create_guest_wifi_device(self._fc_with_mac("AA:BB:CC:DD:EE:FF"))
         first_byte = int(device["mac_address"].split(":")[0], 16)
         assert first_byte == 0x02
 
     def test_guest_mac_format_is_valid(self):
         """MAC must be 6 colon-separated lowercase hex pairs."""
-        device = fritzbox.create_guest_wifi_device(self._fc_with_mac("AA:BB:CC:DD:EE:FF"), "fritz.box")
+        device = fritzbox.create_guest_wifi_device(self._fc_with_mac("AA:BB:CC:DD:EE:FF"))
         parts = device["mac_address"].split(":")
         assert len(parts) == 6
         for part in parts:
@@ -248,27 +248,27 @@ def test_guest_mac_format_is_valid(self):
     def test_guest_mac_is_deterministic(self):
         """Same Fritz!Box MAC must always produce the same guest MAC."""
         fc = self._fc_with_mac("AA:BB:CC:DD:EE:FF")
-        mac1 = fritzbox.create_guest_wifi_device(fc, "fritz.box")["mac_address"]
-        mac2 = fritzbox.create_guest_wifi_device(fc, "fritz.box")["mac_address"]
+        mac1 = fritzbox.create_guest_wifi_device(fc)["mac_address"]
+        mac2 = fritzbox.create_guest_wifi_device(fc)["mac_address"]
         assert mac1 == mac2
 
     def test_different_fritzbox_macs_produce_different_guest_macs(self):
-        mac_a = fritzbox.create_guest_wifi_device(self._fc_with_mac("AA:BB:CC:DD:EE:01"), "fritz.box")["mac_address"]
-        mac_b = fritzbox.create_guest_wifi_device(self._fc_with_mac("AA:BB:CC:DD:EE:02"), "fritz.box")["mac_address"]
+        mac_a = fritzbox.create_guest_wifi_device(self._fc_with_mac("AA:BB:CC:DD:EE:01"))["mac_address"]
+        mac_b = fritzbox.create_guest_wifi_device(self._fc_with_mac("AA:BB:CC:DD:EE:02"))["mac_address"]
         assert mac_a != mac_b
 
     def test_no_fritzbox_mac_uses_fallback(self):
         """When DeviceInfo returns no MAC, fall back to 02:00:00:00:00:01."""
         fc = MagicMock()
         fc.call_action.return_value = {"NewMACAddress": ""}
-        device = fritzbox.create_guest_wifi_device(fc, "fritz.box")
+        device = fritzbox.create_guest_wifi_device(fc)
         assert device["mac_address"] == "02:00:00:00:00:01"
 
     def test_device_info_exception_returns_none(self):
         """If DeviceInfo call raises, create_guest_wifi_device must return None."""
         fc = MagicMock()
         fc.call_action.side_effect = Exception("Connection refused")
-        device = fritzbox.create_guest_wifi_device(fc, "fritz.box")
+        device = fritzbox.create_guest_wifi_device(fc)
         assert device is None
 
     def test_known_mac_produces_known_guest_mac(self):
@@ -281,7 +281,7 @@ def test_known_mac_produces_known_guest_mac(self):
         digest = hashlib.md5(f"GUEST:{fritzbox_mac}".encode()).digest()
         expected = "02:" + ":".join(f"{b:02x}" for b in digest[:5])
 
-        device = fritzbox.create_guest_wifi_device(self._fc_with_mac("AA:BB:CC:DD:EE:FF"), "fritz.box")
+        device = fritzbox.create_guest_wifi_device(self._fc_with_mac("AA:BB:CC:DD:EE:FF"))
         assert device["mac_address"] == expected