arthexis 0.1.23__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
@@ -66,6 +67,7 @@ from .models import (
 )
 from .backends import OutboxEmailBackend
 from .tasks import capture_node_screenshot, poll_unreachable_upstream, sample_clipboard
+from ocpp.models import Charger
 from cryptography.hazmat.primitives.asymmetric import rsa, padding
 from cryptography.hazmat.primitives import serialization, hashes
 from core.models import Package, PackageRelease, SecurityGroup, RFID, EnergyAccount, Todo
@@ -132,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),
@@ -173,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"),
                 ):
@@ -201,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"),
@@ -220,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"),
@@ -241,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"),
@@ -259,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"),
@@ -281,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"),
@@ -376,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)
@@ -805,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",
@@ -833,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"]):
@@ -854,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):
@@ -935,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,
@@ -962,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"),
                 ):
@@ -980,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"),
                 ):
@@ -999,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"),
                 ):
@@ -1024,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,
                 ):
@@ -1051,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(
@@ -1069,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,
                 ):
@@ -1094,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):
@@ -1730,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",
         }
@@ -1739,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())
 
@@ -1757,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",
         }
@@ -1766,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())
@@ -1816,132 +1948,6 @@ class NodeAdminTests(TestCase):
         self.assertEqual(response.status_code, 200)
         self.assertContains(response, "data:image/png;base64")
 
-    @patch("nodes.admin.requests.post")
-    def test_proxy_view_uses_remote_login_url(self, mock_post):
-        self.client.get(reverse("admin:nodes_node_register_current"))
-        local_node = Node.objects.get()
-        remote = Node.objects.create(
-            hostname="remote",
-            address="192.0.2.10",
-            port=8443,
-            mac_address="aa:bb:cc:dd:ee:ff",
-        )
-        mock_post.return_value = SimpleNamespace(
-            ok=True,
-            json=lambda: {
-                "login_url": "https://remote.example/nodes/proxy/login/token",
-                "expires": "2025-01-01T00:00:00",
-            },
-            status_code=200,
-            text="ok",
-        )
-        response = self.client.get(
-            reverse("admin:nodes_node_proxy", args=[remote.pk])
-        )
-        self.assertEqual(response.status_code, 200)
-        self.assertTemplateUsed(response, "admin/nodes/node/proxy.html")
-        self.assertContains(response, "<iframe", html=False)
-        mock_post.assert_called()
-        payload = json.loads(mock_post.call_args[1]["data"])
-        self.assertEqual(payload.get("requester"), str(local_node.uuid))
-        self.assertEqual(payload.get("requester_mac"), local_node.mac_address)
-        self.assertEqual(payload.get("requester_public_key"), local_node.public_key)
-
-    @patch("nodes.admin.requests.post")
-    def test_proxy_view_falls_back_to_http_after_ssl_error(self, mock_post):
-        self.client.get(reverse("admin:nodes_node_register_current"))
-        remote = Node.objects.create(
-            hostname="remote-https",
-            address="198.51.100.20",
-            port=443,
-            mac_address="aa:bb:cc:dd:ee:10",
-        )
-        local_node = Node.get_local()
-        success_response = SimpleNamespace(
-            ok=True,
-            json=lambda: {
-                "login_url": "http://remote.example/nodes/proxy/login/token",
-                "expires": "2025-01-01T00:00:00",
-            },
-            status_code=200,
-            text="ok",
-        )
-        mock_post.side_effect = [
-            SSLError("wrong version number"),
-            success_response,
-        ]
-
-        response = self.client.get(
-            reverse("admin:nodes_node_proxy", args=[remote.pk])
-        )
-
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(mock_post.call_count, 2)
-        first_url = mock_post.call_args_list[0].args[0]
-        second_url = mock_post.call_args_list[1].args[0]
-        self.assertTrue(first_url.startswith("https://"))
-        self.assertTrue(second_url.startswith("http://"))
-        self.assertIn("/nodes/proxy/session/", second_url)
-        payload = json.loads(mock_post.call_args_list[-1].kwargs["data"])
-        self.assertEqual(payload.get("requester"), str(local_node.uuid))
-        self.assertEqual(payload.get("requester_mac"), local_node.mac_address)
-        self.assertEqual(payload.get("requester_public_key"), local_node.public_key)
-
-    @patch("nodes.admin.requests.post")
-    def test_proxy_view_retries_post_after_redirect(self, mock_post):
-        self.client.get(reverse("admin:nodes_node_register_current"))
-        remote = Node.objects.create(
-            hostname="redirect-node",
-            public_endpoint="http://remote.example",
-            address="198.51.100.30",
-            mac_address="aa:bb:cc:dd:ee:20",
-        )
-
-        redirect_response = SimpleNamespace(
-            status_code=301,
-            ok=True,
-            text="redirect",
-            headers={"Location": "https://remote.example/nodes/proxy/session/"},
-        )
-        success_response = SimpleNamespace(
-            status_code=200,
-            ok=True,
-            text="ok",
-            headers={},
-            json=lambda: {
-                "login_url": "https://remote.example/nodes/proxy/login/token",
-                "expires": "2025-01-01T00:00:00",
-            },
-        )
-
-        mock_post.side_effect = [redirect_response, success_response]
-
-        response = self.client.get(
-            reverse("admin:nodes_node_proxy", args=[remote.pk])
-        )
-
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(mock_post.call_count, 2)
-
-        first_call_kwargs = mock_post.call_args_list[0].kwargs
-        self.assertFalse(first_call_kwargs.get("allow_redirects", True))
-
-        second_url = mock_post.call_args_list[1].args[0]
-        self.assertEqual(second_url, "https://remote.example/nodes/proxy/session/")
-        second_call_kwargs = mock_post.call_args_list[1].kwargs
-        self.assertFalse(second_call_kwargs.get("allow_redirects", True))
-
-    def test_proxy_link_displayed_for_remote_nodes(self):
-        Node.objects.create(
-            hostname="remote",
-            address="203.0.113.1",
-            port=8000,
-            mac_address="aa:aa:aa:aa:aa:01",
-        )
-        response = self.client.get(reverse("admin:nodes_node_changelist"))
-        proxy_url = reverse("admin:nodes_node_proxy", args=[1])
-        self.assertContains(response, proxy_url)
-
     def test_visit_link_uses_local_admin_dashboard_for_local_node(self):
         node_admin = admin.site._registry[Node]
         local_node = self._create_local_node()
@@ -1974,14 +1980,14 @@ class NodeAdminTests(TestCase):
             port=8443,
         )
 
-        urls = list(node_admin._iter_remote_urls(remote, "/nodes/proxy/session/"))
+        urls = list(node_admin._iter_remote_urls(remote, "/nodes/info/"))
 
         self.assertIn(
-            "https://example.com:8443/interface/nodes/proxy/session/",
+            "https://example.com:8443/interface/nodes/info/",
             urls,
         )
         self.assertIn(
-            "http://example.com:8443/interface/nodes/proxy/session/",
+            "http://example.com:8443/interface/nodes/info/",
             urls,
         )
         combined = "".join(urls)
@@ -2532,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(
@@ -3189,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")
@@ -3605,6 +3658,82 @@ class NetMessageSignatureTests(TestCase):
         self.assertTrue(signature_one)
         self.assertTrue(signature_two)
         self.assertNotEqual(signature_one, signature_two)
+
+
+class NetworkChargerActionSecurityTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        self.local_node = Node.objects.create(
+            hostname="local-node",
+            address="127.0.0.1",
+            port=8000,
+            mac_address="00:aa:bb:cc:dd:10",
+            public_endpoint="local-endpoint",
+        )
+        self.authorized_node = Node.objects.create(
+            hostname="authorized-node",
+            address="127.0.0.2",
+            port=8001,
+            mac_address="00:aa:bb:cc:dd:11",
+            public_endpoint="authorized-endpoint",
+        )
+        self.unauthorized_node, self.unauthorized_key = self._create_signed_node(
+            "unauthorized-node",
+            mac_suffix=0x12,
+        )
+        self.charger = Charger.objects.create(
+            charger_id="SECURE-TEST-1",
+            allow_remote=True,
+            manager_node=self.authorized_node,
+            node_origin=self.local_node,
+        )
+
+    def _create_signed_node(self, hostname: str, *, mac_suffix: int):
+        key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+        public_bytes = key.public_key().public_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo,
+        )
+        node = Node.objects.create(
+            hostname=hostname,
+            address="10.0.0.{:d}".format(mac_suffix),
+            port=8020,
+            mac_address="00:aa:bb:cc:dd:{:02x}".format(mac_suffix),
+            public_key=public_bytes.decode(),
+            public_endpoint=f"{hostname}-endpoint",
+        )
+        return node, key
+
+    def test_rejects_requests_from_unmanaged_nodes(self):
+        url = reverse("node-network-charger-action")
+        payload = {
+            "requester": str(self.unauthorized_node.uuid),
+            "charger_id": self.charger.charger_id,
+            "action": "reset",
+        }
+        body = json.dumps(payload).encode()
+        signature = self.unauthorized_key.sign(
+            body,
+            padding.PKCS1v15(),
+            hashes.SHA256(),
+        )
+        headers = {"HTTP_X_SIGNATURE": base64.b64encode(signature).decode()}
+
+        with patch.object(Node, "get_local", return_value=self.local_node):
+            response = self.client.post(
+                url,
+                data=body,
+                content_type="application/json",
+                **headers,
+            )
+
+        self.assertEqual(response.status_code, 403)
+        self.assertEqual(
+            response.json().get("detail"),
+            "requester does not manage this charger",
+        )
+
+
 class StartupNotificationTests(TestCase):
     def test_startup_notification_uses_hostname_and_revision(self):
         from nodes.apps import _startup_notification
@@ -4756,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

@@ -11,6 +11,17 @@ urlpatterns = [
     path("net-message/pull/", views.net_message_pull, name="net-message-pull"),
     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,
+        name="node-network-charger-action",
+    ),
     path("proxy/session/", views.proxy_session, name="node-proxy-session"),
     path("proxy/login/<str:token>/", views.proxy_login, name="node-proxy-login"),
     path("proxy/execute/", views.proxy_execute, name="node-proxy-execute"),