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

nodes/tests.py

@@ -3,7 +3,15 @@ import os
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
 import django
 
-django.setup()
+try:  # Use the pytest-specific setup when available for database readiness
+    from tests.conftest import safe_setup as _safe_setup  # type: ignore
+except Exception:  # pragma: no cover - fallback for direct execution
+    _safe_setup = None
+
+if _safe_setup is not None:
+    _safe_setup()
+else:  # pragma: no cover - fallback when pytest fixtures are unavailable
+    django.setup()
 
 from pathlib import Path
 from types import SimpleNamespace
@@ -27,7 +35,7 @@ from django.urls import reverse
 from django.contrib.auth import get_user_model
 from django.contrib import admin
 from django.contrib.sites.models import Site
-from django_celery_beat.models import PeriodicTask
+from django_celery_beat.models import IntervalSchedule, PeriodicTask
 from django.conf import settings
 from django.utils import timezone
 from dns import resolver as dns_resolver
@@ -55,6 +63,43 @@ from cryptography.hazmat.primitives import serialization, hashes
 from core.models import PackageRelease, SecurityGroup
 
 
+class NodeBadgeColorTests(TestCase):
+    def setUp(self):
+        self.constellation, _ = NodeRole.objects.get_or_create(name="Constellation")
+        self.control, _ = NodeRole.objects.get_or_create(name="Control")
+
+    def test_constellation_role_defaults_to_goldenrod(self):
+        node = Node.objects.create(
+            hostname="constellation",
+            address="10.1.0.1",
+            port=8000,
+            mac_address="00:aa:bb:cc:dd:01",
+            role=self.constellation,
+        )
+        self.assertEqual(node.badge_color, "#daa520")
+
+    def test_control_role_defaults_to_deep_purple(self):
+        node = Node.objects.create(
+            hostname="control",
+            address="10.1.0.2",
+            port=8001,
+            mac_address="00:aa:bb:cc:dd:02",
+            role=self.control,
+        )
+        self.assertEqual(node.badge_color, "#673ab7")
+
+    def test_custom_badge_color_is_preserved(self):
+        node = Node.objects.create(
+            hostname="custom",
+            address="10.1.0.3",
+            port=8002,
+            mac_address="00:aa:bb:cc:dd:03",
+            role=self.constellation,
+            badge_color="#123456",
+        )
+        self.assertEqual(node.badge_color, "#123456")
+
+
 class NodeTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -101,6 +146,54 @@ class NodeGetLocalTests(TestCase):
         self.assertTrue(created)
         self.assertEqual(node.current_relation, Node.Relation.SELF)
 
+    def test_register_current_updates_role_from_lock_file(self):
+        NodeRole.objects.get_or_create(name="Terminal")
+        NodeRole.objects.get_or_create(name="Constellation")
+        with TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            lock_dir = base / "locks"
+            lock_dir.mkdir(parents=True, exist_ok=True)
+            role_file = lock_dir / "role.lck"
+            role_file.write_text("Terminal")
+            with override_settings(BASE_DIR=base):
+                with (
+                    patch(
+                        "nodes.models.Node.get_current_mac",
+                        return_value="00:aa:bb:cc:dd:ee",
+                    ),
+                    patch("nodes.models.socket.gethostname", return_value="role-host"),
+                    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"),
+                ):
+                    node, created = Node.register_current()
+            self.assertTrue(created)
+            self.assertEqual(node.role.name, "Terminal")
+
+            role_file.write_text("Constellation")
+            with override_settings(BASE_DIR=base):
+                with (
+                    patch(
+                        "nodes.models.Node.get_current_mac",
+                        return_value="00:aa:bb:cc:dd:ee",
+                    ),
+                    patch("nodes.models.socket.gethostname", return_value="role-host"),
+                    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"),
+                ):
+                    _, created_again = Node.register_current()
+
+            self.assertFalse(created_again)
+            node.refresh_from_db()
+            self.assertEqual(node.role.name, "Constellation")
+
     def test_register_and_list_node(self):
         response = self.client.post(
             reverse("register-node"),
@@ -833,6 +926,33 @@ class NodeAdminTests(TestCase):
         if security_dir.exists():
             shutil.rmtree(security_dir)
 
+    def _create_local_node(self):
+        return Node.objects.create(
+            hostname="localnode",
+            address="127.0.0.1",
+            port=8000,
+            mac_address=Node.get_current_mac(),
+        )
+
+    def test_node_feature_list_shows_default_action_when_enabled(self):
+        node = self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="rfid-scanner", defaults={"display": "RFID Scanner"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        response = self.client.get(reverse("admin:nodes_nodefeature_changelist"))
+        action_url = reverse("admin:core_rfid_scan")
+        self.assertContains(response, f'href="{action_url}"')
+
+    def test_node_feature_list_hides_default_action_when_disabled(self):
+        self._create_local_node()
+        NodeFeature.objects.get_or_create(
+            slug="screenshot-poll", defaults={"display": "Screenshot Poll"}
+        )
+        response = self.client.get(reverse("admin:nodes_nodefeature_changelist"))
+        action_url = reverse("admin:nodes_nodefeature_take_screenshot")
+        self.assertNotContains(response, f'href="{action_url}"')
+
     def test_register_current_host(self):
         url = reverse("admin:nodes_node_register_current")
         hostname = socket.gethostname()
@@ -967,6 +1087,160 @@ class NodeAdminTests(TestCase):
         samples = list(ContentSample.objects.filter(kind=ContentSample.IMAGE))
         self.assertEqual(samples[0].transaction_uuid, samples[1].transaction_uuid)
 
+    @patch("nodes.admin.capture_screenshot")
+    def test_take_screenshot_default_action_creates_sample(
+        self, mock_capture_screenshot
+    ):
+        node = self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="screenshot-poll", defaults={"display": "Screenshot Poll"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        screenshot_dir = settings.LOG_DIR / "screenshots"
+        screenshot_dir.mkdir(parents=True, exist_ok=True)
+        file_path = screenshot_dir / "default.png"
+        file_path.write_bytes(b"default")
+        mock_capture_screenshot.return_value = Path("screenshots/default.png")
+        response = self.client.get(
+            reverse("admin:nodes_nodefeature_take_screenshot"), follow=True
+        )
+        self.assertEqual(response.status_code, 200)
+        sample = ContentSample.objects.get(kind=ContentSample.IMAGE)
+        self.assertEqual(sample.node, node)
+        self.assertEqual(sample.method, "DEFAULT_ACTION")
+        mock_capture_screenshot.assert_called_once_with("http://testserver/")
+        change_url = reverse("admin:nodes_contentsample_change", args=[sample.pk])
+        self.assertEqual(response.redirect_chain[-1][0], change_url)
+
+    def test_check_features_for_eligibility_action_success(self):
+        node = self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="rfid-scanner", defaults={"display": "RFID Scanner"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        changelist_url = reverse("admin:nodes_nodefeature_changelist")
+        response = self.client.post(
+            changelist_url,
+            {
+                "action": "check_features_for_eligibility",
+                "_selected_action": [str(feature.pk)],
+            },
+            follow=True,
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(
+            response,
+            "RFID Scanner is enabled on localnode. This feature cannot be enabled manually.",
+            html=False,
+        )
+        self.assertContains(
+            response, "Completed 1 of 1 feature check(s) successfully.", html=False
+        )
+
+    def test_check_features_for_eligibility_action_warns_when_disabled(self):
+        self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="rfid-scanner", defaults={"display": "RFID Scanner"}
+        )
+        changelist_url = reverse("admin:nodes_nodefeature_changelist")
+        response = self.client.post(
+            changelist_url,
+            {
+                "action": "check_features_for_eligibility",
+                "_selected_action": [str(feature.pk)],
+            },
+            follow=True,
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(
+            response,
+            "RFID Scanner is not enabled on localnode. This feature cannot be enabled manually.",
+            html=False,
+        )
+        self.assertContains(
+            response, "Completed 0 of 1 feature check(s) successfully.", html=False
+        )
+
+    def test_enable_selected_features_enables_manual_feature(self):
+        node = self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="screenshot-poll", defaults={"display": "Screenshot Poll"}
+        )
+        changelist_url = reverse("admin:nodes_nodefeature_changelist")
+        response = self.client.post(
+            changelist_url,
+            {
+                "action": "enable_selected_features",
+                "_selected_action": [str(feature.pk)],
+            },
+            follow=True,
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(Node.objects.get(pk=node.pk).has_feature("screenshot-poll"))
+        self.assertContains(
+            response, "Enabled 1 feature(s): Screenshot Poll", html=False
+        )
+
+    def test_enable_selected_features_warns_for_non_manual(self):
+        self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="rfid-scanner", defaults={"display": "RFID Scanner"}
+        )
+        changelist_url = reverse("admin:nodes_nodefeature_changelist")
+        response = self.client.post(
+            changelist_url,
+            {
+                "action": "enable_selected_features",
+                "_selected_action": [str(feature.pk)],
+            },
+            follow=True,
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(
+            response, "RFID Scanner cannot be enabled manually.", html=False
+        )
+        self.assertContains(
+            response,
+            "None of the selected features can be enabled manually.",
+            html=False,
+        )
+
+    def test_take_screenshot_default_action_requires_enabled_feature(self):
+        self._create_local_node()
+        NodeFeature.objects.get_or_create(
+            slug="screenshot-poll", defaults={"display": "Screenshot Poll"}
+        )
+        response = self.client.get(
+            reverse("admin:nodes_nodefeature_take_screenshot"), follow=True
+        )
+        self.assertEqual(response.status_code, 200)
+        changelist_url = reverse("admin:nodes_nodefeature_changelist")
+        self.assertEqual(response.wsgi_request.path, changelist_url)
+        self.assertEqual(ContentSample.objects.count(), 0)
+        self.assertContains(response, "Screenshot Poll feature is not enabled")
+
+    @patch("nodes.admin.capture_rpi_snapshot")
+    def test_take_snapshot_default_action_creates_sample(self, mock_snapshot):
+        node = self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="rpi-camera", defaults={"display": "Raspberry Pi Camera"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        camera_dir = settings.LOG_DIR / "camera"
+        camera_dir.mkdir(parents=True, exist_ok=True)
+        file_path = camera_dir / "snap.jpg"
+        file_path.write_bytes(b"camera")
+        mock_snapshot.return_value = file_path
+        response = self.client.get(
+            reverse("admin:nodes_nodefeature_take_snapshot"), follow=True
+        )
+        self.assertEqual(response.status_code, 200)
+        sample = ContentSample.objects.get(kind=ContentSample.IMAGE)
+        self.assertEqual(sample.node, node)
+        self.assertEqual(sample.method, "RPI_CAMERA")
+        change_url = reverse("admin:nodes_contentsample_change", args=[sample.pk])
+        self.assertEqual(response.redirect_chain[-1][0], change_url)
+
 
 class NetMessageAdminTests(TransactionTestCase):
     reset_sequences = True
@@ -1494,6 +1768,16 @@ class EmailOutboxTests(TestCase):
 
         self.assertEqual(str(outbox), "mailer@example.com")
 
+    def test_string_representation_trims_trailing_at_symbol(self):
+        outbox = EmailOutbox.objects.create(
+            host="smtp.example.com",
+            port=587,
+            username="mailer@",
+            password="secret",
+        )
+
+        self.assertEqual(str(outbox), "mailer@smtp.example.com")
+
     def test_unattached_outbox_used_as_fallback(self):
         EmailOutbox.objects.create(
             group=SecurityGroup.objects.create(name="Attached"),
@@ -1713,6 +1997,30 @@ class NodeFeatureTests(TestCase):
                 role=self.role,
             )
 
+    def test_default_action_mapping_for_known_feature(self):
+        feature = NodeFeature.objects.create(
+            slug="rfid-scanner", display="RFID Scanner"
+        )
+        action = feature.get_default_action()
+        self.assertIsNotNone(action)
+        self.assertEqual(action.label, "Scan RFIDs")
+        self.assertEqual(action.url_name, "admin:core_rfid_scan")
+
+    def test_celery_feature_default_action(self):
+        feature = NodeFeature.objects.create(
+            slug="celery-queue", display="Celery Queue"
+        )
+        action = feature.get_default_action()
+        self.assertIsNotNone(action)
+        self.assertEqual(action.label, "Celery Report")
+        self.assertEqual(action.url_name, "admin:nodes_nodefeature_celery_report")
+
+    def test_default_action_missing_when_unconfigured(self):
+        feature = NodeFeature.objects.create(
+            slug="custom-feature", display="Custom Feature"
+        )
+        self.assertIsNone(feature.get_default_action())
+
     def test_lcd_screen_enabled(self):
         feature = NodeFeature.objects.create(slug="lcd-screen", display="LCD")
         feature.roles.add(self.role)
@@ -1884,45 +2192,66 @@ class NodeFeatureTests(TestCase):
             NodeFeatureAssignment.objects.filter(node=node, feature=feature).exists()
         )
 
-    @patch("nodes.models.Node._uses_postgres", return_value=True)
-    def test_postgres_detection(self, mock_postgres):
-        feature = NodeFeature.objects.create(
-            slug="postgres-db", display="PostgreSQL Database"
+
+class CeleryReportAdminViewTests(TestCase):
+    def setUp(self):
+        User = get_user_model()
+        self.superuser = User.objects.create_superuser(
+            username="admin", email="admin@example.com", password="secret"
         )
-        feature.roles.add(self.role)
-        with patch(
-            "nodes.models.Node.get_current_mac", return_value="00:11:22:33:44:55"
-        ):
-            self.node.refresh_features()
-        self.assertTrue(
-            NodeFeatureAssignment.objects.filter(
-                node=self.node, feature=feature
-            ).exists()
+        self.client.force_login(self.superuser)
+
+        self.log_file = Path(settings.LOG_DIR) / settings.LOG_FILE_NAME
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+        self._original_log_contents: str | None = None
+        if self.log_file.exists():
+            self._original_log_contents = self.log_file.read_text(encoding="utf-8")
+        self.addCleanup(self._restore_log_file)
+
+        PeriodicTask.objects.all().delete()
+
+    def _restore_log_file(self):
+        if self._original_log_contents is None:
+            try:
+                self.log_file.unlink()
+            except FileNotFoundError:
+                pass
+        else:
+            self.log_file.write_text(
+                self._original_log_contents, encoding="utf-8"
+            )
+
+    def test_report_includes_tasks_and_logs(self):
+        now = timezone.now()
+        schedule = IntervalSchedule.objects.create(
+            every=1, period=IntervalSchedule.HOURS
+        )
+        PeriodicTask.objects.create(
+            name="test-task",
+            task="core.tasks.heartbeat",
+            interval=schedule,
+            enabled=True,
+            last_run_at=now - timedelta(minutes=30),
         )
 
-    @patch("nodes.models.Node._uses_postgres", side_effect=[True, False])
-    def test_postgres_removed_when_not_in_use(self, mock_postgres):
-        feature = NodeFeature.objects.create(
-            slug="postgres-db", display="PostgreSQL Database"
+        localized = timezone.localtime(now)
+        log_line = (
+            f"{localized.strftime('%Y-%m-%d %H:%M:%S,%f')} "
+            "[INFO] core.tasks: Heartbeat task executed\n"
         )
-        feature.roles.add(self.role)
-        with patch(
-            "nodes.models.Node.get_current_mac", return_value="00:11:22:33:44:55"
-        ):
-            self.node.refresh_features()
-        self.assertTrue(
-            NodeFeatureAssignment.objects.filter(
-                node=self.node, feature=feature
-            ).exists()
+        self.log_file.write_text(log_line, encoding="utf-8")
+
+        response = self.client.get(
+            reverse("admin:nodes_nodefeature_celery_report")
         )
-        with patch(
-            "nodes.models.Node.get_current_mac", return_value="00:11:22:33:44:55"
-        ):
-            self.node.refresh_features()
-        self.assertFalse(
-            NodeFeatureAssignment.objects.filter(
-                node=self.node, feature=feature
-            ).exists()
+
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, "Celery Report")
+        self.assertContains(response, "test-task")
+        self.assertContains(response, settings.LOG_FILE_NAME)
+        entries = response.context_data["log_entries"]
+        self.assertTrue(
+            any("Heartbeat task executed" in entry.message for entry in entries)
         )
 
 

nodes/utils.py

@@ -2,6 +2,8 @@ from datetime import datetime
 from pathlib import Path
 import hashlib
 import logging
+import shutil
+import subprocess
 
 from django.conf import settings
 from selenium import webdriver
@@ -11,6 +13,7 @@ from selenium.common.exceptions import WebDriverException
 from .models import ContentSample
 
 SCREENSHOT_DIR = settings.LOG_DIR / "screenshots"
+CAMERA_DIR = settings.LOG_DIR / "camera"
 logger = logging.getLogger(__name__)
 
 
@@ -46,6 +49,35 @@ def capture_screenshot(url: str, cookies=None) -> Path:
         raise RuntimeError(f"Screenshot capture failed: {exc}") from exc
 
 
+def capture_rpi_snapshot(timeout: int = 10) -> Path:
+    """Capture a snapshot using the Raspberry Pi camera stack."""
+
+    tool_path = shutil.which("rpicam-still")
+    if not tool_path:
+        raise RuntimeError("rpicam-still is not available")
+    CAMERA_DIR.mkdir(parents=True, exist_ok=True)
+    filename = CAMERA_DIR / f"{datetime.utcnow():%Y%m%d%H%M%S}.jpg"
+    try:
+        result = subprocess.run(
+            [tool_path, "-o", str(filename), "-t", "1"],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=timeout,
+        )
+    except Exception as exc:  # pragma: no cover - depends on camera stack
+        logger.error("Failed to invoke %s: %s", tool_path, exc)
+        raise RuntimeError(f"Snapshot capture failed: {exc}") from exc
+    if result.returncode != 0:
+        error = (result.stderr or result.stdout or "Snapshot capture failed").strip()
+        logger.error("rpicam-still exited with %s: %s", result.returncode, error)
+        raise RuntimeError(error)
+    if not filename.exists():
+        logger.error("Snapshot file %s was not created", filename)
+        raise RuntimeError("Snapshot capture failed")
+    return filename
+
+
 def save_screenshot(path: Path, node=None, method: str = "", transaction_uuid=None):
     """Save screenshot file info if not already recorded.