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

nodes/tests.py

@@ -7,6 +7,7 @@ django.setup()
 
 from pathlib import Path
 from types import SimpleNamespace
+import unittest.mock as mock
 from unittest.mock import patch, call, MagicMock
 from django.core import mail
 from django.core.mail import EmailMessage
@@ -21,7 +22,7 @@ import stat
 import time
 from datetime import timedelta
 
-from django.test import Client, TestCase, TransactionTestCase, override_settings
+from django.test import Client, SimpleTestCase, TestCase, TransactionTestCase, override_settings
 from django.urls import reverse
 from django.contrib.auth import get_user_model
 from django.contrib import admin
@@ -29,9 +30,12 @@ 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 dns import resolver as dns_resolver
 from .actions import NodeAction
+from . import dns as dns_utils
 from selenium.common.exceptions import WebDriverException
 from .utils import capture_screenshot
+from django.db.utils import DatabaseError
 
 from .models import (
     Node,
@@ -41,6 +45,8 @@ from .models import (
     NodeFeature,
     NodeFeatureAssignment,
     NetMessage,
+    NodeManager,
+    DNSRecord,
 )
 from .backends import OutboxEmailBackend
 from .tasks import capture_node_screenshot, sample_clipboard
@@ -57,7 +63,23 @@ class NodeTests(TestCase):
         self.client.force_login(self.user)
         NodeRole.objects.get_or_create(name="Terminal")
 
+
+class NodeGetLocalDatabaseUnavailableTests(SimpleTestCase):
+    def test_get_local_handles_database_errors(self):
+        with patch.object(Node.objects, "filter", side_effect=DatabaseError("fail")):
+            with self.assertLogs("nodes.models", level="DEBUG") as logs:
+                result = Node.get_local()
+
+        self.assertIsNone(result)
+        self.assertTrue(
+            any("Node.get_local skipped: database unavailable" in message for message in logs.output)
+        )
+
+
+class NodeGetLocalTests(TestCase):
     def test_register_current_does_not_create_release(self):
+        node = None
+        created = False
         with TemporaryDirectory() as tmp:
             base = Path(tmp)
             with override_settings(BASE_DIR=base):
@@ -73,8 +95,11 @@ class NodeTests(TestCase):
                     patch("nodes.models.revision.get_revision", return_value="rev"),
                     patch.object(Node, "ensure_keys"),
                 ):
-                    Node.register_current()
+                    node, created = Node.register_current()
         self.assertEqual(PackageRelease.objects.count(), 0)
+        self.assertIsNotNone(node)
+        self.assertTrue(created)
+        self.assertEqual(node.current_relation, Node.Relation.SELF)
 
     def test_register_and_list_node(self):
         response = self.client.post(
@@ -89,6 +114,8 @@ class NodeTests(TestCase):
         )
         self.assertEqual(response.status_code, 200)
         self.assertEqual(Node.objects.count(), 1)
+        node = Node.objects.get(mac_address="00:11:22:33:44:55")
+        self.assertEqual(node.current_relation, Node.Relation.PEER)
 
         # allow same IP with different MAC
         self.client.post(
@@ -371,6 +398,48 @@ class NodeTests(TestCase):
         self.assertEqual(response.status_code, 200)
         self.assertTrue(Node.objects.filter(mac_address="aa:bb:cc:dd:ee:ff").exists())
 
+    def test_register_node_respects_relation_payload(self):
+        payload = {
+            "hostname": "relation",
+            "address": "127.0.0.2",
+            "port": 8100,
+            "mac_address": "11:22:33:44:55:66",
+            "current_relation": "Downstream",
+        }
+        response = self.client.post(
+            reverse("register-node"),
+            data=json.dumps(payload),
+            content_type="application/json",
+        )
+        self.assertEqual(response.status_code, 200)
+        node = Node.objects.get(mac_address="11:22:33:44:55:66")
+        self.assertEqual(node.current_relation, Node.Relation.DOWNSTREAM)
+
+        update_payload = {
+            **payload,
+            "hostname": "relation-updated",
+            "current_relation": "Upstream",
+        }
+        second = self.client.post(
+            reverse("register-node"),
+            data=json.dumps(update_payload),
+            content_type="application/json",
+        )
+        self.assertEqual(second.status_code, 200)
+        node.refresh_from_db()
+        self.assertEqual(node.current_relation, Node.Relation.UPSTREAM)
+
+        final_payload = {**update_payload, "hostname": "relation-final"}
+        final_payload.pop("current_relation")
+        third = self.client.post(
+            reverse("register-node"),
+            data=json.dumps(final_payload),
+            content_type="application/json",
+        )
+        self.assertEqual(third.status_code, 200)
+        node.refresh_from_db()
+        self.assertEqual(node.current_relation, Node.Relation.UPSTREAM)
+
 
 class NodeRegisterCurrentTests(TestCase):
     def setUp(self):
@@ -1005,6 +1074,17 @@ class NetMessageReachTests(TestCase):
         self.assertEqual(roles, {"Constellation", "Satellite", "Control"})
         self.assertEqual(mock_post.call_count, 3)
 
+    @patch("requests.post")
+    def test_default_reach_not_limited_to_terminal(self, mock_post):
+        msg = NetMessage.objects.create(subject="s", body="b")
+        with patch.object(Node, "get_local", return_value=None), patch(
+            "random.shuffle", side_effect=lambda seq: None
+        ):
+            msg.propagate()
+        roles = set(msg.propagated_to.values_list("role__name", flat=True))
+        self.assertIn("Control", roles)
+        self.assertEqual(mock_post.call_count, 3)
+
 
 class NetMessagePropagationTests(TestCase):
     def setUp(self):
@@ -1034,6 +1114,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)
 
     @patch("requests.post")
     @patch("core.notifications.notify")
@@ -1403,6 +1484,68 @@ class EmailOutboxTests(TestCase):
 
         self.assertEqual(str(outbox), "mailer@smtp.example.com")
 
+    def test_string_representation_does_not_duplicate_email_hostname(self):
+        outbox = EmailOutbox.objects.create(
+            host="smtp.example.com",
+            port=587,
+            username="mailer@example.com",
+            password="secret",
+        )
+
+        self.assertEqual(str(outbox), "mailer@example.com")
+
+    def test_unattached_outbox_used_as_fallback(self):
+        EmailOutbox.objects.create(
+            group=SecurityGroup.objects.create(name="Attached"),
+            host="smtp.attached.example.com",
+            port=587,
+            username="attached",
+            password="secret",
+        )
+        fallback = EmailOutbox.objects.create(
+            host="smtp.fallback.example.com",
+            port=587,
+            username="fallback",
+            password="secret",
+        )
+
+        backend = OutboxEmailBackend()
+        message = EmailMessage("subject", "body", to=["to@example.com"])
+
+        selected, fallbacks = backend._select_outbox(message)
+
+        self.assertEqual(selected, fallback)
+        self.assertEqual(fallbacks, [])
+
+    def test_disabled_outbox_excluded_from_selection(self):
+        EmailOutbox.objects.create(
+            host="smtp.disabled.example.com",
+            port=587,
+            username="disabled@example.com",
+            password="secret",
+            from_email="disabled@example.com",
+            is_enabled=False,
+        )
+        enabled = EmailOutbox.objects.create(
+            host="smtp.enabled.example.com",
+            port=587,
+            username="enabled@example.com",
+            password="secret",
+        )
+
+        backend = OutboxEmailBackend()
+        message = EmailMessage(
+            "subject",
+            "body",
+            from_email="disabled@example.com",
+            to=["to@example.com"],
+        )
+
+        selected, fallbacks = backend._select_outbox(message)
+
+        self.assertEqual(selected, enabled)
+        self.assertEqual(fallbacks, [])
+
 
 class ClipboardTaskTests(TestCase):
     @patch("nodes.tasks.pyperclip.paste")
@@ -1856,3 +1999,170 @@ class NodeRpiCameraDetectionTests(TestCase):
         self.assertFalse(Node._has_rpi_camera())
         missing_index = Node.RPI_CAMERA_BINARIES.index(Node.RPI_CAMERA_BINARIES[-1])
         self.assertEqual(mock_run.call_count, missing_index)
+
+
+class DNSIntegrationTests(TestCase):
+    def setUp(self):
+        self.group = SecurityGroup.objects.create(name="Infra")
+
+    def test_deploy_records_success(self):
+        manager = NodeManager.objects.create(
+            group=self.group,
+            api_key="test-key",
+            api_secret="test-secret",
+        )
+        record_a = DNSRecord.objects.create(
+            domain="example.com",
+            name="@",
+            record_type=DNSRecord.Type.A,
+            data="1.2.3.4",
+            ttl=600,
+        )
+        record_b = DNSRecord.objects.create(
+            domain="example.com",
+            name="@",
+            record_type=DNSRecord.Type.A,
+            data="5.6.7.8",
+            ttl=600,
+        )
+
+        calls = []
+
+        class DummyResponse:
+            status_code = 200
+            reason = "OK"
+
+            def json(self):
+                return {}
+
+        class DummySession:
+            def __init__(self):
+                self.headers = {}
+
+            def put(self, url, json, timeout):
+                calls.append((url, json, timeout, dict(self.headers)))
+                return DummyResponse()
+
+        with mock.patch.object(dns_utils.requests, "Session", DummySession):
+            result = manager.publish_dns_records([record_a, record_b])
+
+        self.assertEqual(len(result.deployed), 2)
+        self.assertFalse(result.failures)
+        self.assertFalse(result.skipped)
+        self.assertTrue(calls)
+        url, payload, timeout, headers = calls[0]
+        self.assertTrue(url.endswith("/v1/domains/example.com/records/A/@"))
+        self.assertEqual(len(payload), 2)
+        self.assertEqual(headers["Authorization"], "sso-key test-key:test-secret")
+
+        record_a.refresh_from_db()
+        record_b.refresh_from_db()
+        self.assertIsNotNone(record_a.last_synced_at)
+        self.assertIsNotNone(record_b.last_synced_at)
+        self.assertEqual(record_a.node_manager_id, manager.pk)
+        self.assertEqual(record_b.node_manager_id, manager.pk)
+
+    def test_deploy_records_handles_error(self):
+        manager = NodeManager.objects.create(
+            group=self.group,
+            api_key="test-key",
+            api_secret="test-secret",
+        )
+        record = DNSRecord.objects.create(
+            domain="example.com",
+            name="www",
+            record_type=DNSRecord.Type.CNAME,
+            data="target.example.com",
+        )
+
+        class DummyResponse:
+            status_code = 400
+            reason = "Bad Request"
+
+            def json(self):
+                return {"message": "Invalid data"}
+
+        class DummySession:
+            def __init__(self):
+                self.headers = {}
+
+            def put(self, url, json, timeout):
+                return DummyResponse()
+
+        with mock.patch.object(dns_utils.requests, "Session", DummySession):
+            result = manager.publish_dns_records([record])
+
+        self.assertFalse(result.deployed)
+        self.assertIn(record, result.failures)
+        record.refresh_from_db()
+        self.assertEqual(record.last_error, "Invalid data")
+        self.assertIsNone(record.last_synced_at)
+
+    def test_validate_record_success(self):
+        record = DNSRecord.objects.create(
+            domain="example.com",
+            name="www",
+            record_type=DNSRecord.Type.A,
+            data="1.2.3.4",
+        )
+
+        class DummyRdata:
+            address = "1.2.3.4"
+
+        class DummyResolver:
+            def resolve(self, name, rtype):
+                self_calls.append((name, rtype))
+                return [DummyRdata()]
+
+        self_calls = []
+        ok, message = dns_utils.validate_record(record, resolver=DummyResolver())
+
+        self.assertTrue(ok)
+        self.assertEqual(message, "")
+        record.refresh_from_db()
+        self.assertIsNotNone(record.last_verified_at)
+        self.assertEqual(record.last_error, "")
+        self.assertEqual(self_calls, [("www.example.com", "A")])
+
+    def test_validate_record_mismatch(self):
+        record = DNSRecord.objects.create(
+            domain="example.com",
+            name="www",
+            record_type=DNSRecord.Type.A,
+            data="1.2.3.4",
+        )
+
+        class DummyRdata:
+            address = "5.6.7.8"
+
+        class DummyResolver:
+            def resolve(self, name, rtype):
+                return [DummyRdata()]
+
+        ok, message = dns_utils.validate_record(record, resolver=DummyResolver())
+
+        self.assertFalse(ok)
+        self.assertEqual(message, "DNS record does not match expected value")
+        record.refresh_from_db()
+        self.assertEqual(record.last_error, message)
+        self.assertIsNone(record.last_verified_at)
+
+    def test_validate_record_handles_exception(self):
+        record = DNSRecord.objects.create(
+            domain="example.com",
+            name="www",
+            record_type=DNSRecord.Type.A,
+            data="1.2.3.4",
+        )
+
+        class DummyResolver:
+            def resolve(self, name, rtype):
+                raise dns_resolver.NXDOMAIN()
+
+        ok, message = dns_utils.validate_record(record, resolver=DummyResolver())
+
+        self.assertFalse(ok)
+        self.assertEqual(message, "The DNS query name does not exist.")
+        record.refresh_from_db()
+        self.assertEqual(record.last_error, message)
+        self.assertIsNone(record.last_verified_at)

nodes/views.py

@@ -204,6 +204,15 @@ def register_node(request):
     signature = data.get("signature")
     installed_version = data.get("installed_version")
     installed_revision = data.get("installed_revision")
+    relation_present = False
+    if hasattr(data, "getlist"):
+        relation_present = "current_relation" in data
+    else:
+        relation_present = "current_relation" in data
+    raw_relation = data.get("current_relation")
+    relation_value = (
+        Node.normalize_relation(raw_relation) if relation_present else None
+    )
 
     if not hostname or not address or not mac_address:
         response = JsonResponse(
@@ -242,6 +251,8 @@ def register_node(request):
         defaults["installed_version"] = str(installed_version)[:20]
     if installed_revision is not None:
         defaults["installed_revision"] = str(installed_revision)[:40]
+    if relation_value is not None:
+        defaults["current_relation"] = relation_value
 
     node, created = Node.objects.get_or_create(
         mac_address=mac_address,
@@ -265,6 +276,9 @@ def register_node(request):
             node.installed_revision = str(installed_revision)[:40]
             if "installed_revision" not in update_fields:
                 update_fields.append("installed_revision")
+        if relation_value is not None and node.current_relation != relation_value:
+            node.current_relation = relation_value
+            update_fields.append("current_relation")
         node.save(update_fields=update_fields)
         current_version = (node.installed_version or "").strip()
         current_revision = (node.installed_revision or "").strip()

ocpp/consumers.py

@@ -17,6 +17,7 @@ from . import store
 from decimal import Decimal
 from django.utils.dateparse import parse_datetime
 from .models import Transaction, Charger, MeterValue
+from .reference_utils import host_is_local_loopback
 
 FORWARDED_PAIR_RE = re.compile(r"for=(?:\"?)(?P<value>[^;,\"\s]+)(?:\"?)", re.IGNORECASE)
 
@@ -287,19 +288,21 @@ class CSMSConsumer(AsyncWebsocketConsumer):
         serial = (self.charger_id or "").strip()
         if not ip or not serial:
             return
+        if host_is_local_loopback(ip):
+            return
         host = ip
         if ":" in host and not host.startswith("["):
             host = f"[{host}]"
         url = f"http://{host}:8900"
         alt_text = f"{serial} Console"
-        reference, _ = Reference.objects.get_or_create(
-            alt_text=alt_text,
-            defaults={
-                "value": url,
-                "show_in_header": True,
-                "method": "link",
-            },
-        )
+        reference = Reference.objects.filter(alt_text=alt_text).order_by("id").first()
+        if reference is None:
+            reference = Reference.objects.create(
+                alt_text=alt_text,
+                value=url,
+                show_in_header=True,
+                method="link",
+            )
         updated_fields: list[str] = []
         if reference.value != url:
             reference.value = url

ocpp/models.py

@@ -18,6 +18,7 @@ from core.models import (
     Brand as CoreBrand,
     EVModel as CoreEVModel,
 )
+from .reference_utils import url_targets_local_loopback
 
 
 class Location(Entity):
@@ -279,6 +280,8 @@ class Charger(Entity):
             kwargs["update_fields"] = update_list
         super().save(*args, **kwargs)
         ref_value = self._full_url()
+        if url_targets_local_loopback(ref_value):
+            return
         if not self.reference or self.reference.value != ref_value:
             self.reference = Reference.objects.create(
                 value=ref_value, alt_text=self.charger_id

ocpp/reference_utils.py

@@ -0,0 +1,42 @@
+"""Helpers related to console Reference creation."""
+
+from __future__ import annotations
+
+import ipaddress
+from urllib.parse import urlparse
+
+
+def _normalize_host(host: str | None) -> str:
+    """Return a trimmed host string without surrounding brackets."""
+
+    if not host:
+        return ""
+    host = host.strip()
+    if host.startswith("[") and host.endswith("]"):
+        return host[1:-1]
+    return host
+
+
+def host_is_local_loopback(host: str | None) -> bool:
+    """Return ``True`` when the host string points to 127.0.0.1."""
+
+    normalized = _normalize_host(host)
+    if not normalized:
+        return False
+    try:
+        return ipaddress.ip_address(normalized) == ipaddress.ip_address("127.0.0.1")
+    except ValueError:
+        return False
+
+
+def url_targets_local_loopback(url: str | None) -> bool:
+    """Return ``True`` when the parsed URL host equals 127.0.0.1."""
+
+    if not url:
+        return False
+    parsed = urlparse(url)
+    return host_is_local_loopback(parsed.hostname)
+
+
+__all__ = ["host_is_local_loopback", "url_targets_local_loopback"]
+