arthexis 0.1.24__py3-none-any.whl → 0.1.25__py3-none-any.whl

nodes/tests.py

@@ -36,6 +36,7 @@ from django.test import Client, SimpleTestCase, TestCase, TransactionTestCase, o
 from django.urls import reverse
 from django.contrib.auth import get_user_model
 from django.contrib import admin
+from django.contrib.admin import helpers
 from django.contrib.auth.models import Permission
 from django_celery_beat.models import IntervalSchedule, PeriodicTask
 from django.conf import settings
@@ -133,6 +134,12 @@ class NodeGetLocalDatabaseUnavailableTests(SimpleTestCase):
 
 
 class NodeGetLocalTests(TestCase):
+    def setUp(self):
+        super().setUp()
+        User = get_user_model()
+        self.user = User.objects.create_user(username="localtester", password="pwd")
+        self.client.force_login(self.user)
+
     def test_normalize_relation_handles_various_inputs(self):
         self.assertEqual(
             Node.normalize_relation(Node.Relation.UPSTREAM),
@@ -174,6 +181,7 @@ class NodeGetLocalTests(TestCase):
                     patch(
                         "nodes.models.socket.gethostbyname", return_value="127.0.0.1"
                     ),
+                    patch.object(Node, "_resolve_ip_addresses", return_value=([], [])),
                     patch("nodes.models.revision.get_revision", return_value="rev"),
                     patch.object(Node, "ensure_keys"),
                 ):
@@ -202,6 +210,7 @@ class NodeGetLocalTests(TestCase):
                     patch(
                         "nodes.models.socket.gethostbyname", return_value="127.0.0.1"
                     ),
+                    patch.object(Node, "_resolve_ip_addresses", return_value=([], [])),
                     patch("nodes.models.revision.get_revision", return_value="rev"),
                     patch.object(Node, "ensure_keys"),
                     patch.object(Node, "notify_peers_of_update"),
@@ -221,6 +230,7 @@ class NodeGetLocalTests(TestCase):
                     patch(
                         "nodes.models.socket.gethostbyname", return_value="127.0.0.1"
                     ),
+                    patch.object(Node, "_resolve_ip_addresses", return_value=([], [])),
                     patch("nodes.models.revision.get_revision", return_value="rev"),
                     patch.object(Node, "ensure_keys"),
                     patch.object(Node, "notify_peers_of_update"),
@@ -242,6 +252,7 @@ class NodeGetLocalTests(TestCase):
                     patch(
                         "nodes.models.socket.gethostbyname", return_value="127.0.0.1"
                     ),
+                    patch.object(Node, "_resolve_ip_addresses", return_value=([], [])),
                     patch("nodes.models.revision.get_revision", return_value="rev"),
                     patch.object(Node, "ensure_keys"),
                     patch.object(Node, "notify_peers_of_update"),
@@ -260,6 +271,7 @@ class NodeGetLocalTests(TestCase):
                     patch("nodes.models.Node.get_current_mac", return_value="00:11:22:33:44:55"),
                     patch("nodes.models.socket.gethostname", return_value="localhost"),
                     patch("nodes.models.socket.gethostbyname", return_value="127.0.0.1"),
+                    patch.object(Node, "_resolve_ip_addresses", return_value=([], [])),
                     patch("nodes.models.revision.get_revision", return_value="rev"),
                     patch.object(Node, "ensure_keys"),
                     patch.object(Node, "notify_peers_of_update"),
@@ -282,6 +294,7 @@ class NodeGetLocalTests(TestCase):
                     patch("nodes.models.Node.get_current_mac", return_value="00:11:22:33:44:56"),
                     patch("nodes.models.socket.gethostname", return_value="localhost"),
                     patch("nodes.models.socket.gethostbyname", return_value="127.0.0.1"),
+                    patch.object(Node, "_resolve_ip_addresses", return_value=([], [])),
                     patch("nodes.models.revision.get_revision", return_value="rev"),
                     patch.object(Node, "ensure_keys"),
                     patch.object(Node, "notify_peers_of_update"),
@@ -377,6 +390,37 @@ class NodeGetLocalTests(TestCase):
         self.assertNotEqual(node_one.public_endpoint, node_two.public_endpoint)
         self.assertTrue(node_two.public_endpoint.startswith("duplicate-host-"))
 
+    def test_register_node_accepts_network_hostname_without_address(self):
+        response = self.client.post(
+            reverse("register-node"),
+            data={
+                "hostname": "domain-node",
+                "network_hostname": "domain-node.example.com",
+                "port": 8050,
+                "mac_address": "aa:bb:cc:dd:ee:ff",
+            },
+            content_type="application/json",
+        )
+        self.assertEqual(response.status_code, 200)
+        node = Node.objects.get(mac_address="aa:bb:cc:dd:ee:ff")
+        self.assertEqual(node.network_hostname, "domain-node.example.com")
+        self.assertIsNone(node.address)
+        self.assertIsNone(node.ipv4_address)
+        self.assertIsNone(node.ipv6_address)
+
+    def test_register_node_requires_contact_information(self):
+        response = self.client.post(
+            reverse("register-node"),
+            data={
+                "hostname": "missing-host",
+                "port": 8051,
+                "mac_address": "aa:bb:cc:dd:ee:00",
+            },
+            content_type="application/json",
+        )
+        self.assertEqual(response.status_code, 400)
+        self.assertIn("at least one", response.json()["detail"])
+
     def test_register_node_assigns_interface_role_and_returns_uuid(self):
         NodeRole.objects.get_or_create(name="Interface")
         private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
@@ -806,7 +850,10 @@ class NodeInfoViewTests(TestCase):
         self.addCleanup(self.patcher.stop)
         self.node = Node.objects.create(
             hostname="local",
+            network_hostname="local.example.com",
             address="10.0.0.10",
+            ipv4_address="10.0.0.10",
+            ipv6_address="2001:db8::10",
             port=8000,
             mac_address=self.mac,
             public_endpoint="local",
@@ -834,6 +881,8 @@ class NodeInfoViewTests(TestCase):
         self.assertEqual(response.status_code, 200)
         payload = response.json()
         self.assertEqual(payload["port"], 80)
+        self.assertEqual(payload.get("network_hostname"), "local.example.com")
+        self.assertIn("local.example.com", payload.get("contact_hosts", []))
 
     def test_preserves_explicit_port_in_host_header(self):
         with self.settings(ALLOWED_HOSTS=["arthexis.com"]):
@@ -855,6 +904,8 @@ class NodeInfoViewTests(TestCase):
         self.assertEqual(response.status_code, 200)
         payload = response.json()
         self.assertEqual(payload.get("role"), "Terminal")
+        self.assertEqual(payload.get("ipv4_address"), "10.0.0.10")
+        self.assertEqual(payload.get("ipv6_address"), "2001:db8::10")
 
 
 class RegisterVisitorNodeMessageTests(TestCase):
@@ -936,6 +987,7 @@ class NodeRegisterCurrentTests(TestCase):
                     patch(
                         "nodes.models.socket.gethostbyname", return_value="127.0.0.1"
                     ),
+                    patch.object(Node, "_resolve_ip_addresses", return_value=([], [])),
                     patch("nodes.models.revision.get_revision", return_value="rev"),
                     patch.object(Node, "ensure_keys"),
                     patch.object(Node, "notify_peers_of_update") as mock_notify,
@@ -963,6 +1015,7 @@ class NodeRegisterCurrentTests(TestCase):
                     patch(
                         "nodes.models.socket.gethostbyname", return_value="127.0.0.1"
                     ),
+                    patch.object(Node, "_resolve_ip_addresses", return_value=([], [])),
                     patch("nodes.models.revision.get_revision", return_value="rev"),
                     patch.object(Node, "ensure_keys"),
                 ):
@@ -981,6 +1034,7 @@ class NodeRegisterCurrentTests(TestCase):
                     patch(
                         "nodes.models.socket.gethostbyname", return_value="127.0.0.1"
                     ),
+                    patch.object(Node, "_resolve_ip_addresses", return_value=([], [])),
                     patch("nodes.models.revision.get_revision", return_value="rev"),
                     patch.object(Node, "ensure_keys"),
                 ):
@@ -1000,6 +1054,7 @@ class NodeRegisterCurrentTests(TestCase):
                     patch(
                         "nodes.models.socket.gethostbyname", return_value="127.0.0.1"
                     ),
+                    patch.object(Node, "_resolve_ip_addresses", return_value=([], [])),
                     patch("nodes.models.revision.get_revision", return_value="rev"),
                     patch.object(Node, "ensure_keys"),
                 ):
@@ -1025,10 +1080,20 @@ class NodeRegisterCurrentTests(TestCase):
                         return_value="00:ff:ee:dd:cc:bb",
                     ),
                     patch("nodes.models.socket.gethostname", return_value="localnode"),
+                    patch("nodes.models.socket.getfqdn", return_value="localnode.example.com"),
                     patch(
                         "nodes.models.socket.gethostbyname",
                         return_value="192.168.1.5",
                     ),
+                    patch.dict(os.environ, {"HOSTNAME": ""}, clear=False),
+                    patch.object(
+                        Node,
+                        "_resolve_ip_addresses",
+                        return_value=(
+                            ["192.168.1.5", "93.184.216.34"],
+                            ["fe80::1", "2001:4860:4860::8888"],
+                        ),
+                    ),
                     patch("nodes.models.revision.get_revision", return_value="newrev"),
                     patch("requests.post") as mock_post,
                 ):
@@ -1052,6 +1117,9 @@ class NodeRegisterCurrentTests(TestCase):
         self.assertEqual(payload["hostname"], "localnode")
         self.assertEqual(payload["installed_version"], "2.0.0")
         self.assertEqual(payload["installed_revision"], "newrev")
+        self.assertEqual(payload.get("network_hostname"), "localnode.example.com")
+        self.assertEqual(payload.get("ipv4_address"), "93.184.216.34")
+        self.assertEqual(payload.get("ipv6_address"), "2001:4860:4860::8888")
 
     def test_register_current_notifies_peers_without_version_change(self):
         Node.objects.create(
@@ -1070,10 +1138,20 @@ class NodeRegisterCurrentTests(TestCase):
                         return_value="00:ff:ee:dd:cc:cc",
                     ),
                     patch("nodes.models.socket.gethostname", return_value="samever"),
+                    patch("nodes.models.socket.getfqdn", return_value="samever.example.com"),
                     patch(
                         "nodes.models.socket.gethostbyname",
                         return_value="192.168.1.6",
                     ),
+                    patch.dict(os.environ, {"HOSTNAME": ""}, clear=False),
+                    patch.object(
+                        Node,
+                        "_resolve_ip_addresses",
+                        return_value=(
+                            ["192.168.1.6", "93.184.216.35"],
+                            ["fe80::2", "2001:4860:4860::8844"],
+                        ),
+                    ),
                     patch("nodes.models.revision.get_revision", return_value="rev1"),
                     patch("requests.post") as mock_post,
                 ):
@@ -1095,6 +1173,44 @@ class NodeRegisterCurrentTests(TestCase):
         payload = json.loads(kwargs["data"])
         self.assertEqual(payload["installed_version"], "1.0.0")
         self.assertEqual(payload.get("installed_revision"), "rev1")
+        self.assertEqual(payload.get("network_hostname"), "samever.example.com")
+        self.assertEqual(payload.get("ipv4_address"), "93.184.216.35")
+        self.assertEqual(payload.get("ipv6_address"), "2001:4860:4860::8844")
+
+    def test_register_current_populates_network_fields(self):
+        with TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            with override_settings(BASE_DIR=base):
+                with (
+                    patch(
+                        "nodes.models.Node.get_current_mac",
+                        return_value="00:12:34:56:78:90",
+                    ),
+                    patch("nodes.models.socket.gethostname", return_value="nodehost"),
+                    patch("nodes.models.socket.getfqdn", return_value="nodehost.example.com"),
+                    patch(
+                        "nodes.models.socket.gethostbyname",
+                        return_value="10.0.0.5",
+                    ),
+                    patch.dict(os.environ, {"HOSTNAME": ""}, clear=False),
+                    patch.object(
+                        Node,
+                        "_resolve_ip_addresses",
+                        return_value=(
+                            ["10.0.0.5", "93.184.216.36"],
+                            ["fe80::5", "2001:4860:4860::1"],
+                        ),
+                    ),
+                    patch("nodes.models.revision.get_revision", return_value="revX"),
+                    patch.object(Node, "ensure_keys"),
+                    patch.object(Node, "notify_peers_of_update"),
+                ):
+                    node, created = Node.register_current()
+        self.assertTrue(created)
+        self.assertEqual(node.network_hostname, "nodehost.example.com")
+        self.assertEqual(node.ipv4_address, "93.184.216.36")
+        self.assertEqual(node.ipv6_address, "2001:4860:4860::1")
+        self.assertEqual(node.address, "93.184.216.36")
 
     @patch("nodes.views.capture_screenshot")
     def test_capture_screenshot(self, mock_capture):
@@ -1731,7 +1847,10 @@ class NodeAdminTests(TestCase):
 
         payload = {
             "hostname": node.hostname,
+            "network_hostname": "remote-node.example.com",
             "address": node.address,
+            "ipv4_address": "198.51.100.10",
+            "ipv6_address": "2001:db8::10",
             "port": node.port,
             "role": "Control",
         }
@@ -1740,7 +1859,13 @@ class NodeAdminTests(TestCase):
         node.refresh_from_db()
 
         self.assertIn("role", changed)
+        self.assertIn("network_hostname", changed)
+        self.assertIn("ipv4_address", changed)
+        self.assertIn("ipv6_address", changed)
         self.assertEqual(node.role, control)
+        self.assertEqual(node.network_hostname, "remote-node.example.com")
+        self.assertEqual(node.ipv4_address, "198.51.100.10")
+        self.assertEqual(node.ipv6_address, "2001:db8::10")
         self.assertTrue(control.node_set.filter(pk=node.pk).exists())
         self.assertFalse(terminal.node_set.filter(pk=node.pk).exists())
 
@@ -1758,7 +1883,10 @@ class NodeAdminTests(TestCase):
 
         payload = {
             "hostname": node.hostname,
+            "network_hostname": "role-name-node.example.com",
             "address": node.address,
+            "ipv4_address": "198.51.100.11",
+            "ipv6_address": "2001:db8::11",
             "port": node.port,
             "role_name": "Control",
         }
@@ -1767,6 +1895,9 @@ class NodeAdminTests(TestCase):
         node.refresh_from_db()
 
         self.assertIn("role", changed)
+        self.assertEqual(node.network_hostname, "role-name-node.example.com")
+        self.assertEqual(node.ipv4_address, "198.51.100.11")
+        self.assertEqual(node.ipv6_address, "2001:db8::11")
         self.assertEqual(node.role, control)
         self.assertTrue(control.node_set.filter(pk=node.pk).exists())
         self.assertFalse(terminal.node_set.filter(pk=node.pk).exists())
@@ -2407,6 +2538,53 @@ class NodeAdminTests(TestCase):
         )
         self.assertContains(response, str(remote))
 
+    def test_send_net_message_action_displays_form(self):
+        target = Node.objects.create(
+            hostname="remote-one", address="10.0.0.10", port=8020
+        )
+        response = self.client.post(
+            reverse("admin:nodes_node_changelist"),
+            {
+                "action": "send_net_message",
+                helpers.ACTION_CHECKBOX_NAME: [str(target.pk)],
+            },
+            follow=False,
+        )
+        self.assertEqual(response.status_code, 200)
+        response.render()
+        self.assertContains(response, "Send Net Message")
+        self.assertContains(response, str(target))
+        self.assertContains(response, 'name="apply"')
+        self.assertContains(response, "Selected node (1)")
+
+    @patch("nodes.admin.NetMessage.propagate")
+    def test_send_net_message_action_creates_messages(self, mock_propagate):
+        first = Node.objects.create(
+            hostname="remote-two", address="10.0.0.11", port=8021
+        )
+        second = Node.objects.create(
+            hostname="remote-three", address="10.0.0.12", port=8022
+        )
+        url = reverse("admin:nodes_node_changelist")
+        payload = {
+            "action": "send_net_message",
+            "apply": "1",
+            helpers.ACTION_CHECKBOX_NAME: [str(first.pk), str(second.pk)],
+            "subject": "Maintenance",
+            "body": "We will reboot tonight.",
+        }
+        existing_ids = set(NetMessage.objects.values_list("pk", flat=True))
+        response = self.client.post(url, payload, follow=True)
+        self.assertEqual(response.status_code, 200)
+        new_messages = NetMessage.objects.exclude(pk__in=existing_ids)
+        self.assertEqual(new_messages.count(), 2)
+        self.assertEqual(mock_propagate.call_count, 2)
+        for node in (first, second):
+            message = new_messages.get(filter_node=node)
+            self.assertEqual(message.subject, "Maintenance")
+            self.assertEqual(message.body, "We will reboot tonight.")
+        self.assertContains(response, "Sent 2 net messages.")
+
     @patch("nodes.admin.requests.post")
     @patch("nodes.admin.requests.get")
     def test_update_selected_nodes_progress_updates_remote(
@@ -3064,7 +3242,7 @@ class NetMessagePropagationTests(TestCase):
         with patch.object(Node, "get_local", return_value=self.local):
             msg = NetMessage.broadcast(subject="subject", body="body")
         self.assertEqual(msg.node_origin, self.local)
-        self.assertIsNone(msg.reach)
+        self.assertEqual(msg.reach, self.role)
 
     @patch("requests.post")
     @patch("core.notifications.notify")
@@ -4707,6 +4885,38 @@ class ContentClassifierTests(TestCase):
         tags = ContentClassification.objects.filter(sample=sample)
         self.assertTrue(tags.filter(tag__slug="screenshot-tag").exists())
 
+    def test_save_screenshot_returns_none_for_duplicate_without_linking(self):
+        with TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            first_path = base / "capture.png"
+            first_path.write_bytes(b"binary image data")
+            duplicate_path = base / "duplicate.png"
+            duplicate_path.write_bytes(b"binary image data")
+            with override_settings(LOG_DIR=base):
+                original = save_screenshot(first_path, method="TEST")
+                duplicate = save_screenshot(duplicate_path, method="TEST")
+
+        self.assertIsNotNone(original)
+        self.assertIsNone(duplicate)
+        self.assertEqual(ContentSample.objects.count(), 1)
+
+    def test_save_screenshot_reuses_existing_sample_when_linking(self):
+        with TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            first_path = base / "capture.png"
+            first_path.write_bytes(b"binary image data")
+            duplicate_path = base / "duplicate.png"
+            duplicate_path.write_bytes(b"binary image data")
+            with override_settings(LOG_DIR=base):
+                original = save_screenshot(first_path, method="TEST")
+                reused = save_screenshot(
+                    duplicate_path, method="TEST", link_duplicates=True
+                )
+
+        self.assertIsNotNone(original)
+        self.assertEqual(reused, original)
+        self.assertEqual(ContentSample.objects.count(), 1)
+
     def test_text_sample_runs_default_classifiers_without_duplicates(self):
         sample = ContentSample.objects.create(
             content="Example content", kind=ContentSample.TEXT

nodes/urls.py

@@ -12,6 +12,11 @@ urlpatterns = [
     path("rfid/export/", views.export_rfids, name="node-rfid-export"),
     path("rfid/import/", views.import_rfids, name="node-rfid-import"),
     path("network/chargers/", views.network_chargers, name="node-network-chargers"),
+    path(
+        "network/chargers/forward/",
+        views.forward_chargers,
+        name="node-network-forward-chargers",
+    ),
     path(
         "network/chargers/action/",
         views.network_charger_action,

nodes/utils.py

@@ -90,10 +90,13 @@ def save_screenshot(
     *,
     content: str | None = None,
     user=None,
+    link_duplicates: bool = False,
 ):
     """Save screenshot file info if not already recorded.
 
-    Returns the created :class:`ContentSample` or ``None`` if duplicate.
+    Returns the created :class:`ContentSample`. If ``link_duplicates`` is ``True``
+    and a sample with identical content already exists, the existing record is
+    returned instead of ``None``.
     """
 
     original = path
@@ -101,7 +104,11 @@ def save_screenshot(
         path = settings.LOG_DIR / path
     with path.open("rb") as fh:
         digest = hashlib.sha256(fh.read()).hexdigest()
-    if ContentSample.objects.filter(hash=digest).exists():
+    existing = ContentSample.objects.filter(hash=digest).first()
+    if existing:
+        if link_duplicates:
+            logger.info("Duplicate screenshot content; reusing existing sample")
+            return existing
         logger.info("Duplicate screenshot content; record not created")
         return None
     stored_path = (original if not original.is_absolute() else path).as_posix()