arthexis 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

core/tests.py

@@ -10,6 +10,7 @@ from django.urls import reverse
 from django.http import HttpRequest
 import csv
 import json
+import importlib.util
 from decimal import Decimal
 from unittest import mock
 from unittest.mock import patch
@@ -19,9 +20,11 @@ import types
 from glob import glob
 from datetime import datetime, timedelta, timezone as datetime_timezone
 import tempfile
+from io import StringIO
 from urllib.parse import quote
 
 from django.utils import timezone
+from django.conf import settings
 from django.contrib.auth.models import Permission
 from django.contrib.messages import get_messages
 from tablib import Dataset
@@ -51,9 +54,11 @@ from core.admin import (
     USER_PROFILE_INLINES,
 )
 from ocpp.models import Transaction, Charger
+from nodes.models import ContentSample
 
 from django.core.exceptions import ValidationError
 from django.core.management import call_command
+from django.core.management.base import CommandError
 from django.db import IntegrityError
 from .backends import LocalhostAdminBackend
 from core.views import (
@@ -365,6 +370,45 @@ class RFIDLoginTests(TestCase):
         self.assertEqual(response.status_code, 401)
         mock_run.assert_called_once()
 
+    @patch("core.backends.subprocess.Popen")
+    def test_rfid_login_post_command_runs_after_success(self, mock_popen):
+        tag = self.account.rfids.first()
+        tag.post_auth_command = "echo welcome"
+        tag.save(update_fields=["post_auth_command"])
+
+        response = self.client.post(
+            reverse("rfid-login"),
+            data={"rfid": "CARD123"},
+            content_type="application/json",
+        )
+
+        self.assertEqual(response.status_code, 200)
+        mock_popen.assert_called_once()
+        args, kwargs = mock_popen.call_args
+        self.assertEqual(args[0], "echo welcome")
+        self.assertTrue(kwargs.get("shell"))
+        env = kwargs.get("env", {})
+        self.assertEqual(env.get("RFID_VALUE"), "CARD123")
+        self.assertEqual(env.get("RFID_LABEL_ID"), str(tag.pk))
+        self.assertIs(kwargs.get("stdout"), subprocess.DEVNULL)
+        self.assertIs(kwargs.get("stderr"), subprocess.DEVNULL)
+
+    @patch("core.backends.subprocess.Popen")
+    def test_rfid_login_post_command_skipped_on_failure(self, mock_popen):
+        tag = self.account.rfids.first()
+        tag.post_auth_command = "echo welcome"
+        tag.allowed = False
+        tag.save(update_fields=["post_auth_command", "allowed"])
+
+        response = self.client.post(
+            reverse("rfid-login"),
+            data={"rfid": "CARD123"},
+            content_type="application/json",
+        )
+
+        self.assertEqual(response.status_code, 401)
+        mock_popen.assert_not_called()
+
 
 class RFIDBatchApiTests(TestCase):
     def setUp(self):
@@ -387,6 +431,8 @@ class RFIDBatchApiTests(TestCase):
                         "rfid": "CARD999",
                         "custom_label": "Main Tag",
                         "energy_accounts": [self.account.id],
+                        "external_command": "",
+                        "post_auth_command": "",
                         "allowed": True,
                         "color": "B",
                         "released": False,
@@ -406,6 +452,8 @@ class RFIDBatchApiTests(TestCase):
                         "rfid": "CARD111",
                         "custom_label": "",
                         "energy_accounts": [],
+                        "external_command": "",
+                        "post_auth_command": "",
                         "allowed": True,
                         "color": "W",
                         "released": False,
@@ -426,6 +474,8 @@ class RFIDBatchApiTests(TestCase):
                         "rfid": "CARD112",
                         "custom_label": "",
                         "energy_accounts": [],
+                        "external_command": "",
+                        "post_auth_command": "",
                         "allowed": True,
                         "color": "B",
                         "released": True,
@@ -441,6 +491,8 @@ class RFIDBatchApiTests(TestCase):
                     "rfid": "A1B2C3D4",
                     "custom_label": "Imported Tag",
                     "energy_accounts": [self.account.id],
+                    "external_command": "echo pre",
+                    "post_auth_command": "echo post",
                     "allowed": True,
                     "color": "W",
                     "released": True,
@@ -459,6 +511,8 @@ class RFIDBatchApiTests(TestCase):
                 rfid="A1B2C3D4",
                 custom_label="Imported Tag",
                 energy_accounts=self.account,
+                external_command="echo pre",
+                post_auth_command="echo post",
                 color=RFID.WHITE,
                 released=True,
             ).exists()
@@ -931,6 +985,40 @@ class RFIDImportExportCommandTests(TestCase):
         self.assertTrue(tag.energy_accounts.filter(pk=account.pk).exists())
 
 
+class CheckRFIDCommandTests(TestCase):
+    def test_successful_validation_outputs_json(self):
+        out = StringIO()
+
+        call_command("check_rfid", "abcd1234", stdout=out)
+
+        payload = json.loads(out.getvalue())
+        self.assertEqual(payload["rfid"], "ABCD1234")
+        self.assertTrue(payload["created"])
+        self.assertTrue(RFID.objects.filter(rfid="ABCD1234").exists())
+
+    def test_invalid_value_raises_error(self):
+        with self.assertRaises(CommandError):
+            call_command("check_rfid", "invalid!")
+
+    def test_kind_option_updates_existing_tag(self):
+        tag = RFID.objects.create(rfid="EXISTING", allowed=False, kind=RFID.CLASSIC)
+        out = StringIO()
+
+        call_command(
+            "check_rfid",
+            "existing",
+            "--kind",
+            RFID.NTAG215,
+            stdout=out,
+        )
+
+        payload = json.loads(out.getvalue())
+        tag.refresh_from_db()
+        self.assertFalse(payload["created"])
+        self.assertEqual(payload["kind"], RFID.NTAG215)
+        self.assertEqual(tag.kind, RFID.NTAG215)
+
+
 class RFIDKeyVerificationFlagTests(TestCase):
     def test_flags_reset_on_key_change(self):
         tag = RFID.objects.create(
@@ -985,6 +1073,44 @@ class ReleaseProcessTests(TestCase):
         )
         sync_main.assert_called_once_with(Path("rel.log"))
 
+    def test_step_check_todos_logs_instruction_when_pending(self):
+        log_path = Path("rel.log")
+        log_path.unlink(missing_ok=True)
+        Todo.objects.create(request="Review checklist")
+        ctx: dict[str, object] = {}
+
+        try:
+            with self.assertRaises(core_views.PendingTodos):
+                core_views._step_check_todos(self.release, ctx, log_path)
+
+            contents = log_path.read_text(encoding="utf-8")
+            message = "Release checklist requires acknowledgment before continuing."
+            self.assertIn(message, contents)
+            self.assertIn("Review outstanding TODO items", contents)
+
+            with self.assertRaises(core_views.PendingTodos):
+                core_views._step_check_todos(self.release, ctx, log_path)
+
+            contents = log_path.read_text(encoding="utf-8")
+            self.assertEqual(contents.count(message), 1)
+        finally:
+            log_path.unlink(missing_ok=True)
+
+    def test_step_check_todos_auto_ack_when_no_pending(self):
+        log_path = Path("rel.log")
+        log_path.unlink(missing_ok=True)
+        ctx: dict[str, object] = {}
+
+        try:
+            with mock.patch("core.views._refresh_changelog_once"):
+                core_views._step_check_todos(self.release, ctx, log_path)
+        finally:
+            log_path.unlink(missing_ok=True)
+
+        self.assertTrue(ctx.get("todos_ack"))
+        self.assertNotIn("todos_required", ctx)
+        self.assertIsNone(ctx.get("todos"))
+
     @mock.patch("core.views._sync_with_origin_main")
     @mock.patch("core.views.release_utils._git_clean", return_value=True)
     @mock.patch("core.views.release_utils.network_available", return_value=False)
@@ -1475,6 +1601,54 @@ class ReleaseProcessTests(TestCase):
         ctx = session.get(f"release_publish_{self.release.pk}")
         self.assertTrue(ctx.get("dry_run"))
 
+    def test_resume_button_shown_when_credentials_missing(self):
+        user = User.objects.create_superuser("admin", "admin@example.com", "pw")
+        url = reverse("release-progress", args=[self.release.pk, "publish"])
+        self.client.force_login(user)
+
+        self.client.get(f"{url}?start=1")
+
+        session = self.client.session
+        ctx = session.get(f"release_publish_{self.release.pk}") or {}
+        ctx.update({"step": 7, "started": True, "paused": False})
+        session[f"release_publish_{self.release.pk}"] = ctx
+        session.save()
+
+        response = self.client.get(f"{url}?step=7")
+        self.assertEqual(response.status_code, 200)
+        context = response.context
+        if isinstance(context, list):
+            context = context[-1]
+        self.assertTrue(context["resume_available"])
+        self.assertIn(b"Resume Publish", response.content)
+
+    def test_resume_without_step_parameter_defaults_to_current_progress(self):
+        run: list[str] = []
+
+        def step_fn(release, ctx, log_path):
+            run.append("step")
+
+        steps = [("Only step", step_fn)]
+        user = User.objects.create_superuser("admin", "admin@example.com", "pw")
+        url = reverse("release-progress", args=[self.release.pk, "publish"])
+        with mock.patch("core.views.PUBLISH_STEPS", steps):
+            self.client.force_login(user)
+            session = self.client.session
+            session[f"release_publish_{self.release.pk}"] = {
+                "step": 0,
+                "started": True,
+                "paused": False,
+            }
+            session.save()
+
+            response = self.client.get(f"{url}?resume=1")
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(run, ["step"])
+
+            session = self.client.session
+            ctx = session.get(f"release_publish_{self.release.pk}")
+            self.assertEqual(ctx.get("step"), 1)
+
     def test_new_todo_does_not_reset_pending_flow(self):
         user = User.objects.create_superuser("admin", "admin@example.com", "pw")
         url = reverse("release-progress", args=[self.release.pk, "publish"])
@@ -1552,6 +1726,71 @@ class ReleaseProcessTests(TestCase):
             self.assertEqual(count_file.read_text(), "1")
 
 
+class PackageReleaseFixtureTests(TestCase):
+    def setUp(self):
+        self.base = Path("core/fixtures")
+        self.existing_fixtures = {
+            path: path.read_text(encoding="utf-8")
+            for path in self.base.glob("releases__*.json")
+        }
+        self.addCleanup(self._restore_fixtures)
+
+        self.package = Package.objects.create(name="fixture-pkg")
+        self.release_one = PackageRelease.objects.create(
+            package=self.package,
+            version="9.9.9",
+        )
+        self.release_two = PackageRelease.objects.create(
+            package=self.package,
+            version="9.9.10",
+        )
+
+    def _restore_fixtures(self):
+        current_paths = set(self.base.glob("releases__*.json"))
+        for path in current_paths:
+            if path not in self.existing_fixtures:
+                path.unlink()
+        for path, content in self.existing_fixtures.items():
+            path.write_text(content, encoding="utf-8")
+
+    def test_dump_fixture_only_writes_changed_releases(self):
+        PackageRelease.dump_fixture()
+        target_one = self.base / "releases__packagerelease_9_9_9.json"
+        target_two = self.base / "releases__packagerelease_9_9_10.json"
+
+        self.assertTrue(target_one.exists())
+        self.assertTrue(target_two.exists())
+
+        self.release_two.changelog = "updated notes"
+        self.release_two.save(update_fields=["changelog"])
+
+        original_write = Path.write_text
+        written_paths: list[Path] = []
+
+        def tracking_write_text(path_obj, data, *args, **kwargs):
+            written_paths.append(path_obj)
+            return original_write(path_obj, data, *args, **kwargs)
+
+        with mock.patch("pathlib.Path.write_text", tracking_write_text):
+            PackageRelease.dump_fixture()
+
+        written_set = set(written_paths)
+        self.assertNotIn(target_one, written_set)
+        self.assertIn(target_two, written_set)
+        self.assertIn("updated notes", target_two.read_text(encoding="utf-8"))
+
+    def test_dump_fixture_removes_missing_release_files(self):
+        PackageRelease.dump_fixture()
+        target_two = self.base / "releases__packagerelease_9_9_10.json"
+        self.assertTrue(target_two.exists())
+
+        self.release_two.delete()
+
+        PackageRelease.dump_fixture()
+
+        self.assertFalse(target_two.exists())
+
+
 class ReleaseProgressSyncTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -2044,6 +2283,42 @@ class TodoDoneTests(TestCase):
         todo.refresh_from_db()
         self.assertIsNotNone(todo.done_on)
 
+    def test_env_refresh_preserves_completed_fixture_todo(self):
+        base_dir = Path(settings.BASE_DIR)
+        fixture_path = base_dir / "core" / "fixtures" / "todo__validate_screen_system_reports.json"
+        spec = importlib.util.spec_from_file_location(
+            "env_refresh_todo", base_dir / "env-refresh.py"
+        )
+        env_refresh = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(env_refresh)
+        fixture_rel_path = str(fixture_path.relative_to(base_dir))
+        env_refresh._fixture_files = lambda: [fixture_rel_path]
+
+        from django.core.management import call_command as django_call
+
+        def fake_call_command(name, *args, **kwargs):
+            if name == "loaddata":
+                return django_call(name, *args, **kwargs)
+            return None
+
+        env_refresh.call_command = fake_call_command
+        env_refresh.load_shared_user_fixtures = lambda *args, **kwargs: None
+        env_refresh.load_user_fixtures = lambda *args, **kwargs: None
+        env_refresh.generate_model_sigils = lambda: None
+
+        env_refresh.run_database_tasks()
+
+        todo = Todo.objects.get(request="Validate screen System Reports")
+        self.assertTrue(todo.is_seed_data)
+        todo.done_on = timezone.now()
+        todo.save(update_fields=["done_on"])
+
+        env_refresh.run_database_tasks()
+
+        todo.refresh_from_db()
+        self.assertIsNotNone(todo.done_on)
+        self.assertTrue(todo.is_seed_data)
+
 
 class TodoFocusViewTests(TestCase):
     def setUp(self):
@@ -2063,6 +2338,9 @@ class TodoFocusViewTests(TestCase):
         self.assertContains(resp, f'src="{todo.url}"')
         self.assertContains(resp, "Done")
         self.assertContains(resp, "Back")
+        self.assertContains(resp, "Take Snapshot")
+        snapshot_url = reverse("todo-snapshot", args=[todo.pk])
+        self.assertContains(resp, snapshot_url)
 
     def test_focus_view_uses_admin_change_when_no_url(self):
         todo = Todo.objects.create(request="Task")
@@ -2134,6 +2412,57 @@ class TodoFocusViewTests(TestCase):
         self.assertRedirects(resp, next_url, target_status_code=200)
 
 
+class TodoSnapshotViewTests(TestCase):
+    PNG_PIXEL = (
+        "data:image/png;base64," "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACklEQVR42mP8/5+hHgAFgwJ/lSdX6QAAAABJRU5ErkJggg=="
+    )
+
+    def setUp(self):
+        self.user = User.objects.create_user(
+            username="manager", password="secret", is_staff=True
+        )
+        self.client.force_login(self.user)
+        self.todo = Todo.objects.create(
+            request="QA release notes", request_details="Verify layout"
+        )
+
+    def test_snapshot_creates_content_sample(self):
+        tmpdir = tempfile.TemporaryDirectory()
+        self.addCleanup(tmpdir.cleanup)
+        with override_settings(LOG_DIR=Path(tmpdir.name)):
+            response = self.client.post(
+                reverse("todo-snapshot", args=[self.todo.pk]),
+                data=json.dumps({"image": self.PNG_PIXEL}),
+                content_type="application/json",
+            )
+        self.assertEqual(response.status_code, 200)
+        payload = response.json()
+        self.assertIn("sample", payload)
+        self.assertEqual(ContentSample.objects.filter(kind=ContentSample.IMAGE).count(), 1)
+        sample = ContentSample.objects.get(pk=payload["sample"])
+        self.assertEqual(sample.method, "TODO_QA")
+        self.assertEqual(sample.user, self.user)
+        self.assertEqual(sample.content, "QA release notes — Verify layout")
+        rel_path = Path(sample.path)
+        self.assertTrue(rel_path.parts)
+        self.assertEqual(rel_path.parts[0], "screenshots")
+        self.assertTrue((Path(tmpdir.name) / rel_path).exists())
+
+    def test_snapshot_rejects_completed_todo(self):
+        self.todo.done_on = timezone.now()
+        self.todo.save(update_fields=["done_on"])
+        tmpdir = tempfile.TemporaryDirectory()
+        self.addCleanup(tmpdir.cleanup)
+        with override_settings(LOG_DIR=Path(tmpdir.name)):
+            response = self.client.post(
+                reverse("todo-snapshot", args=[self.todo.pk]),
+                data=json.dumps({"image": self.PNG_PIXEL}),
+                content_type="application/json",
+            )
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(ContentSample.objects.count(), 0)
+
+
 class TodoUrlValidationTests(TestCase):
     def test_relative_url_valid(self):
         todo = Todo(request="Task", url="/path")