arthexis 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

nodes/tests.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from types import SimpleNamespace
 from unittest.mock import patch, call, MagicMock
 from django.core import mail
+from django.core.mail import EmailMessage
 from django.core.management import call_command
 import socket
 import base64
@@ -18,6 +19,7 @@ from tempfile import TemporaryDirectory
 import shutil
 import stat
 import time
+from datetime import timedelta
 
 from django.test import Client, TestCase, TransactionTestCase, override_settings
 from django.urls import reverse
@@ -26,6 +28,7 @@ from django.contrib import admin
 from django.contrib.sites.models import Site
 from django_celery_beat.models import PeriodicTask
 from django.conf import settings
+from django.utils import timezone
 from .actions import NodeAction
 from selenium.common.exceptions import WebDriverException
 from .utils import capture_screenshot
@@ -43,7 +46,7 @@ from .backends import OutboxEmailBackend
 from .tasks import capture_node_screenshot, sample_clipboard
 from cryptography.hazmat.primitives.asymmetric import rsa, padding
 from cryptography.hazmat.primitives import serialization, hashes
-from core.models import PackageRelease
+from core.models import PackageRelease, SecurityGroup
 
 
 class NodeTests(TestCase):
@@ -156,6 +159,118 @@ class NodeTests(TestCase):
         node.refresh_from_db()
         self.assertFalse(node.has_feature("clipboard-poll"))
 
+    def test_register_node_records_version_details(self):
+        url = reverse("register-node")
+        payload = {
+            "hostname": "versioned",
+            "address": "127.0.0.5",
+            "port": 8100,
+            "mac_address": "aa:bb:cc:dd:ee:10",
+            "installed_version": "2.0.1",
+            "installed_revision": "rev-abcdef",
+        }
+        response = self.client.post(
+            url, data=json.dumps(payload), content_type="application/json"
+        )
+        self.assertEqual(response.status_code, 200)
+        node = Node.objects.get(mac_address="aa:bb:cc:dd:ee:10")
+        self.assertEqual(node.installed_version, "2.0.1")
+        self.assertEqual(node.installed_revision, "rev-abcdef")
+
+        update_payload = {
+            **payload,
+            "installed_version": "2.1.0",
+            "installed_revision": "rev-fedcba",
+        }
+        second = self.client.post(
+            url, data=json.dumps(update_payload), content_type="application/json"
+        )
+        self.assertEqual(second.status_code, 200)
+        node.refresh_from_db()
+        self.assertEqual(node.installed_version, "2.1.0")
+        self.assertEqual(node.installed_revision, "rev-fedcba")
+
+    def test_register_node_update_triggers_notification(self):
+        node = Node.objects.create(
+            hostname="friend",
+            address="10.1.1.5",
+            port=8123,
+            mac_address="aa:bb:cc:dd:ee:01",
+            installed_version="1.0.0",
+            installed_revision="rev-old",
+        )
+        url = reverse("register-node")
+        payload = {
+            "hostname": "friend",
+            "address": "10.1.1.5",
+            "port": 8123,
+            "mac_address": "aa:bb:cc:dd:ee:01",
+            "installed_version": "2.0.0",
+            "installed_revision": "abcdef123456",
+        }
+        with patch("nodes.models.notify_async") as mock_notify:
+            response = self.client.post(
+                url, data=json.dumps(payload), content_type="application/json"
+            )
+        self.assertEqual(response.status_code, 200)
+        node.refresh_from_db()
+        self.assertEqual(node.installed_version, "2.0.0")
+        self.assertEqual(node.installed_revision, "abcdef123456")
+        mock_notify.assert_called_once()
+        subject, body = mock_notify.call_args[0]
+        self.assertEqual(subject, "UP friend")
+        self.assertEqual(body, "v2.0.0 r123456")
+
+    def test_register_node_update_without_version_change_still_notifies(self):
+        node = Node.objects.create(
+            hostname="friend",
+            address="10.1.1.5",
+            port=8123,
+            mac_address="aa:bb:cc:dd:ee:02",
+            installed_version="2.0.0",
+            installed_revision="abcdef123456",
+        )
+        url = reverse("register-node")
+        payload = {
+            "hostname": "friend",
+            "address": "10.1.1.5",
+            "port": 8123,
+            "mac_address": "aa:bb:cc:dd:ee:02",
+            "installed_version": "2.0.0",
+            "installed_revision": "abcdef123456",
+        }
+        with patch("nodes.models.notify_async") as mock_notify:
+            response = self.client.post(
+                url, data=json.dumps(payload), content_type="application/json"
+            )
+        self.assertEqual(response.status_code, 200)
+        node.refresh_from_db()
+        mock_notify.assert_called_once()
+        subject, body = mock_notify.call_args[0]
+        self.assertEqual(subject, "UP friend")
+        self.assertEqual(body, "v2.0.0 r123456")
+
+    def test_register_node_creation_triggers_notification(self):
+        url = reverse("register-node")
+        payload = {
+            "hostname": "newbie",
+            "address": "10.1.1.6",
+            "port": 8124,
+            "mac_address": "aa:bb:cc:dd:ee:03",
+            "installed_version": "3.0.0",
+            "installed_revision": "rev-1234567890",
+        }
+        with patch("nodes.models.notify_async") as mock_notify:
+            response = self.client.post(
+                url, data=json.dumps(payload), content_type="application/json"
+            )
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(Node.objects.filter(mac_address="aa:bb:cc:dd:ee:03").exists())
+        mock_notify.assert_called_once()
+        subject, body = mock_notify.call_args[0]
+        self.assertEqual(subject, "UP newbie")
+        self.assertEqual(body, "v3.0.0 r567890")
+
     def test_register_node_sets_cors_headers(self):
         payload = {
             "hostname": "cors",
@@ -173,6 +288,74 @@ class NodeTests(TestCase):
         self.assertEqual(response["Access-Control-Allow-Origin"], "http://example.com")
         self.assertEqual(response["Access-Control-Allow-Credentials"], "true")
 
+    def test_register_node_requires_auth_without_signature(self):
+        self.client.logout()
+        payload = {
+            "hostname": "visitor",
+            "address": "127.0.0.1",
+            "port": 8000,
+            "mac_address": "aa:bb:cc:dd:ee:00",
+        }
+        response = self.client.post(
+            reverse("register-node"),
+            data=json.dumps(payload),
+            content_type="application/json",
+            HTTP_ORIGIN="http://example.com",
+        )
+        self.assertEqual(response.status_code, 401)
+        data = response.json()
+        self.assertEqual(data["detail"], "authentication required")
+        self.assertEqual(response["Access-Control-Allow-Origin"], "http://example.com")
+
+    def test_register_node_allows_preflight_without_authentication(self):
+        self.client.logout()
+        response = self.client.options(
+            reverse("register-node"), HTTP_ORIGIN="https://example.com"
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response["Access-Control-Allow-Origin"], "https://example.com")
+        self.assertEqual(response["Access-Control-Allow-Credentials"], "true")
+
+    def test_register_node_accepts_signed_payload_without_login(self):
+        self.client.logout()
+        NodeFeature.objects.get_or_create(
+            slug="clipboard-poll", defaults={"display": "Clipboard Poll"}
+        )
+        private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+        public_bytes = private_key.public_key().public_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo,
+        ).decode()
+        token = "visitor-token"
+        signature = base64.b64encode(
+            private_key.sign(
+                token.encode(),
+                padding.PKCS1v15(),
+                hashes.SHA256(),
+            )
+        ).decode()
+        payload = {
+            "hostname": "visitor",
+            "address": "127.0.0.1",
+            "port": 8000,
+            "mac_address": "aa:bb:cc:dd:ee:11",
+            "public_key": public_bytes,
+            "token": token,
+            "signature": signature,
+            "features": ["clipboard-poll"],
+        }
+        response = self.client.post(
+            reverse("register-node"),
+            data=json.dumps(payload),
+            content_type="application/json",
+            HTTP_ORIGIN="http://example.com",
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response["Access-Control-Allow-Origin"], "http://example.com")
+        node = Node.objects.get(mac_address="aa:bb:cc:dd:ee:11")
+        self.assertEqual(node.public_key, public_bytes)
+        self.assertTrue(node.has_feature("clipboard-poll"))
+
     def test_register_node_accepts_text_plain_payload(self):
         payload = {
             "hostname": "plain",
@@ -197,6 +380,26 @@ class NodeRegisterCurrentTests(TestCase):
         self.client.force_login(self.user)
         NodeRole.objects.get_or_create(name="Terminal")
 
+    def test_register_current_notifies_peers_on_start(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:ff:ee:dd:cc:bb",
+                    ),
+                    patch("nodes.models.socket.gethostname", return_value="testhost"),
+                    patch(
+                        "nodes.models.socket.gethostbyname", return_value="127.0.0.1"
+                    ),
+                    patch("nodes.models.revision.get_revision", return_value="rev"),
+                    patch.object(Node, "ensure_keys"),
+                    patch.object(Node, "notify_peers_of_update") as mock_notify,
+                ):
+                    Node.register_current()
+        mock_notify.assert_called_once()
+
     def test_register_current_refreshes_lcd_feature(self):
         NodeFeature.objects.get_or_create(
             slug="lcd-screen", defaults={"display": "LCD Screen"}
@@ -262,6 +465,94 @@ class NodeRegisterCurrentTests(TestCase):
             node.refresh_from_db()
             self.assertTrue(node.has_feature("lcd-screen"))
 
+    def test_register_current_notifies_peers_on_version_upgrade(self):
+        remote = Node.objects.create(
+            hostname="remote",
+            address="10.0.0.2",
+            port=9100,
+            mac_address="aa:bb:cc:dd:ee:ff",
+        )
+        with TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            (base / "VERSION").write_text("2.0.0")
+            with override_settings(BASE_DIR=base):
+                with (
+                    patch(
+                        "nodes.models.Node.get_current_mac",
+                        return_value="00:ff:ee:dd:cc:bb",
+                    ),
+                    patch("nodes.models.socket.gethostname", return_value="localnode"),
+                    patch(
+                        "nodes.models.socket.gethostbyname",
+                        return_value="192.168.1.5",
+                    ),
+                    patch("nodes.models.revision.get_revision", return_value="newrev"),
+                    patch("requests.post") as mock_post,
+                ):
+                    Node.objects.create(
+                        hostname="localnode",
+                        address="192.168.1.5",
+                        port=8000,
+                        mac_address="00:ff:ee:dd:cc:bb",
+                        installed_version="1.9.0",
+                        installed_revision="oldrev",
+                    )
+                    mock_post.return_value = SimpleNamespace(
+                        ok=True, status_code=200, text=""
+                    )
+                    node, created = Node.register_current()
+        self.assertFalse(created)
+        self.assertGreaterEqual(mock_post.call_count, 1)
+        args, kwargs = mock_post.call_args
+        self.assertIn(str(remote.port), args[0])
+        payload = json.loads(kwargs["data"])
+        self.assertEqual(payload["hostname"], "localnode")
+        self.assertEqual(payload["installed_version"], "2.0.0")
+        self.assertEqual(payload["installed_revision"], "newrev")
+
+    def test_register_current_notifies_peers_without_version_change(self):
+        Node.objects.create(
+            hostname="remote",
+            address="10.0.0.3",
+            port=9200,
+            mac_address="aa:bb:cc:dd:ee:11",
+        )
+        with TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            (base / "VERSION").write_text("1.0.0")
+            with override_settings(BASE_DIR=base):
+                with (
+                    patch(
+                        "nodes.models.Node.get_current_mac",
+                        return_value="00:ff:ee:dd:cc:cc",
+                    ),
+                    patch("nodes.models.socket.gethostname", return_value="samever"),
+                    patch(
+                        "nodes.models.socket.gethostbyname",
+                        return_value="192.168.1.6",
+                    ),
+                    patch("nodes.models.revision.get_revision", return_value="rev1"),
+                    patch("requests.post") as mock_post,
+                ):
+                    Node.objects.create(
+                        hostname="samever",
+                        address="192.168.1.6",
+                        port=8000,
+                        mac_address="00:ff:ee:dd:cc:cc",
+                        installed_version="1.0.0",
+                        installed_revision="rev1",
+                    )
+                    mock_post.return_value = SimpleNamespace(
+                        ok=True, status_code=200, text=""
+                    )
+                    Node.register_current()
+        self.assertEqual(mock_post.call_count, 1)
+        args, kwargs = mock_post.call_args
+        self.assertIn("/nodes/register/", args[0])
+        payload = json.loads(kwargs["data"])
+        self.assertEqual(payload["installed_version"], "1.0.0")
+        self.assertEqual(payload.get("installed_revision"), "rev1")
+
     @patch("nodes.views.capture_screenshot")
     def test_capture_screenshot(self, mock_capture):
         hostname = socket.gethostname()
@@ -399,6 +690,7 @@ class NodeRegisterCurrentTests(TestCase):
             "body": "world",
             "seen": [],
             "sender": str(sender.uuid),
+            "origin": str(sender.uuid),
         }
         payload_json = json.dumps(payload, separators=(",", ":"), sort_keys=True)
         signature = key.sign(payload_json.encode(), padding.PKCS1v15(), hashes.SHA256())
@@ -410,6 +702,8 @@ class NodeRegisterCurrentTests(TestCase):
         )
         self.assertEqual(resp.status_code, 200)
         self.assertTrue(NetMessage.objects.filter(uuid=msg_id).exists())
+        message = NetMessage.objects.get(uuid=msg_id)
+        self.assertEqual(message.node_origin, sender)
 
     def test_clipboard_polling_creates_task(self):
         feature, _ = NodeFeature.objects.get_or_create(
@@ -446,6 +740,15 @@ class NodeRegisterCurrentTests(TestCase):
         self.assertFalse(PeriodicTask.objects.filter(name=task_name).exists())
 
 
+class CheckRegistrationReadyCommandTests(TestCase):
+    def test_command_completes_successfully(self):
+        NodeRole.objects.get_or_create(name="Terminal")
+        with TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            with override_settings(BASE_DIR=base):
+                call_command("check_registration_ready")
+
+
 class NodeAdminTests(TestCase):
 
     def setUp(self):
@@ -727,6 +1030,11 @@ class NetMessagePropagationTests(TestCase):
                 )
             )
 
+    def test_broadcast_sets_node_origin(self):
+        with patch.object(Node, "get_local", return_value=self.local):
+            msg = NetMessage.broadcast(subject="subject", body="body")
+        self.assertEqual(msg.node_origin, self.local)
+
     @patch("requests.post")
     @patch("core.notifications.notify")
     def test_propagate_forwards_to_three_and_notifies_local(
@@ -737,6 +1045,9 @@ class NetMessagePropagationTests(TestCase):
             msg.propagate(seen=[str(self.remotes[0].uuid)])
         mock_notify.assert_called_once_with("s", "b")
         self.assertEqual(mock_post.call_count, 3)
+        for call_args in mock_post.call_args_list:
+            payload = json.loads(call_args.kwargs["data"])
+            self.assertEqual(payload.get("origin"), str(self.local.uuid))
         targets = {
             call.args[0].split("//")[1].split("/")[0]
             for call in mock_post.call_args_list
@@ -746,6 +1057,41 @@ class NetMessagePropagationTests(TestCase):
         self.assertEqual(msg.propagated_to.count(), 4)
         self.assertTrue(msg.complete)
 
+    @patch("requests.post")
+    @patch("core.notifications.notify", return_value=True)
+    def test_propagate_prunes_old_local_messages(self, mock_notify, mock_post):
+        old_local = NetMessage.objects.create(
+            subject="old local",
+            body="body",
+            reach=self.role,
+            node_origin=self.local,
+        )
+        NetMessage.objects.filter(pk=old_local.pk).update(
+            created=timezone.now() - timedelta(days=8)
+        )
+        old_remote = NetMessage.objects.create(
+            subject="old remote",
+            body="body",
+            reach=self.role,
+            node_origin=self.remotes[0],
+        )
+        NetMessage.objects.filter(pk=old_remote.pk).update(
+            created=timezone.now() - timedelta(days=8)
+        )
+        msg = NetMessage.objects.create(
+            subject="fresh",
+            body="body",
+            reach=self.role,
+            node_origin=self.local,
+        )
+        with patch.object(Node, "get_local", return_value=self.local):
+            msg.propagate()
+
+        mock_notify.assert_called_once_with("fresh", "body")
+        self.assertFalse(NetMessage.objects.filter(pk=old_local.pk).exists())
+        self.assertTrue(NetMessage.objects.filter(pk=old_remote.pk).exists())
+        self.assertTrue(NetMessage.objects.filter(pk=msg.pk).exists())
+
 
 class NodeActionTests(TestCase):
     def setUp(self):
@@ -1034,6 +1380,29 @@ class EmailOutboxTests(TestCase):
         self.assertEqual(email.subject, "sub")
         self.assertEqual(email.to, ["to@example.com"])
 
+    def test_string_representation_prefers_from_email(self):
+        outbox = EmailOutbox.objects.create(
+            host="smtp.example.com",
+            port=587,
+            username="mailer",
+            password="secret",
+            from_email="noreply@example.com",
+        )
+
+        self.assertEqual(str(outbox), "noreply@example.com")
+
+    def test_string_representation_prefers_username_over_owner(self):
+        group = SecurityGroup.objects.create(name="Operators")
+        outbox = EmailOutbox.objects.create(
+            group=group,
+            host="smtp.example.com",
+            port=587,
+            username="mailer",
+            password="secret",
+        )
+
+        self.assertEqual(str(outbox), "mailer@smtp.example.com")
+
 
 class ClipboardTaskTests(TestCase):
     @patch("nodes.tasks.pyperclip.paste")