arthexis 0.1.14__py3-none-any.whl → 0.1.16__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
@@ -22,6 +23,7 @@ import tempfile
 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,6 +53,7 @@ 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
@@ -365,6 +368,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 +429,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 +450,8 @@ class RFIDBatchApiTests(TestCase):
                         "rfid": "CARD111",
                         "custom_label": "",
                         "energy_accounts": [],
+                        "external_command": "",
+                        "post_auth_command": "",
                         "allowed": True,
                         "color": "W",
                         "released": False,
@@ -426,6 +472,8 @@ class RFIDBatchApiTests(TestCase):
                         "rfid": "CARD112",
                         "custom_label": "",
                         "energy_accounts": [],
+                        "external_command": "",
+                        "post_auth_command": "",
                         "allowed": True,
                         "color": "B",
                         "released": True,
@@ -441,6 +489,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 +509,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()
@@ -1051,6 +1103,79 @@ class ReleaseProcessTests(TestCase):
         requests_get.assert_called_once()
         sync_main.assert_called_once_with(Path("rel.log"))
 
+    @mock.patch("core.views.release_utils.network_available", return_value=False)
+    @mock.patch("core.views._collect_dirty_files")
+    @mock.patch("core.views._sync_with_origin_main")
+    @mock.patch("core.views.subprocess.run")
+    @mock.patch("core.views.release_utils._git_clean", return_value=False)
+    def test_step_check_commits_release_prep_changes(
+        self,
+        git_clean,
+        subprocess_run,
+        sync_main,
+        collect_dirty,
+        network_available,
+    ):
+        fixture_path = next(Path("core/fixtures").glob("releases__*.json"))
+        collect_dirty.return_value = [
+            {
+                "path": str(fixture_path),
+                "status": "M",
+                "status_label": "Modified",
+            },
+            {"path": "CHANGELOG.rst", "status": "M", "status_label": "Modified"},
+        ]
+        subprocess_run.return_value = mock.Mock(returncode=0, stdout="", stderr="")
+
+        ctx: dict[str, object] = {}
+        _step_check_version(self.release, ctx, Path("rel.log"))
+
+        add_call = mock.call(
+            ["git", "add", str(fixture_path), "CHANGELOG.rst"],
+            check=True,
+        )
+        commit_call = mock.call(
+            [
+                "git",
+                "commit",
+                "-m",
+                "chore: sync release fixtures and changelog",
+            ],
+            check=True,
+        )
+        self.assertIn(add_call, subprocess_run.call_args_list)
+        self.assertIn(commit_call, subprocess_run.call_args_list)
+        self.assertNotIn("dirty_files", ctx)
+
+    @mock.patch("core.views.release_utils.network_available", return_value=False)
+    @mock.patch("core.views._collect_dirty_files")
+    @mock.patch("core.views._sync_with_origin_main")
+    @mock.patch("core.views.subprocess.run")
+    @mock.patch("core.views.release_utils._git_clean", return_value=False)
+    def test_step_check_commits_changelog_only(
+        self,
+        git_clean,
+        subprocess_run,
+        sync_main,
+        collect_dirty,
+        network_available,
+    ):
+        collect_dirty.return_value = [
+            {"path": "CHANGELOG.rst", "status": "M", "status_label": "Modified"}
+        ]
+        subprocess_run.return_value = mock.Mock(returncode=0, stdout="", stderr="")
+
+        ctx: dict[str, object] = {}
+        _step_check_version(self.release, ctx, Path("rel.log"))
+
+        subprocess_run.assert_any_call(
+            ["git", "add", "CHANGELOG.rst"], check=True
+        )
+        subprocess_run.assert_any_call(
+            ["git", "commit", "-m", "docs: refresh changelog"], check=True
+        )
+        self.assertNotIn("dirty_files", ctx)
+
     @mock.patch("core.models.PackageRelease.dump_fixture")
     def test_save_does_not_dump_fixture(self, dump):
         self.release.pypi_url = "https://example.com"
@@ -1479,6 +1604,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()
@@ -1971,6 +2161,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):
@@ -1990,6 +2216,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")
@@ -2061,6 +2290,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")