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

core/tests.py

@@ -15,11 +15,13 @@ from unittest.mock import patch
 from pathlib import Path
 import subprocess
 from glob import glob
-from datetime import timedelta
+from datetime import datetime, timedelta, timezone as datetime_timezone
 import tempfile
+from urllib.parse import quote
 
 from django.utils import timezone
 from django.contrib.auth.models import Permission
+from django.contrib.messages import get_messages
 from .models import (
     User,
     UserPhoneNumber,
@@ -51,6 +53,7 @@ from django.core.management import call_command
 from django.db import IntegrityError
 from .backends import LocalhostAdminBackend
 from core.views import _step_check_version, _step_promote_build, _step_publish
+from core import views as core_views
 from core import public_wifi
 
 
@@ -828,15 +831,21 @@ class ReleaseProcessTests(TestCase):
         )
         version_path.write_text(original, encoding="utf-8")
 
+    @mock.patch("core.views.timezone.now")
     @mock.patch("core.views.PackageRelease.dump_fixture")
     @mock.patch("core.views.release_utils.publish")
-    def test_publish_sets_pypi_url(self, publish, dump_fixture):
+    def test_publish_sets_pypi_url(self, publish, dump_fixture, now):
+        now.return_value = datetime(2025, 3, 4, 5, 6, tzinfo=datetime_timezone.utc)
         _step_publish(self.release, {}, Path("rel.log"))
         self.release.refresh_from_db()
         self.assertEqual(
             self.release.pypi_url,
             f"https://pypi.org/project/{self.package.name}/{self.release.version}/",
         )
+        self.assertEqual(
+            self.release.release_on,
+            datetime(2025, 3, 4, 5, 6, tzinfo=datetime_timezone.utc),
+        )
         dump_fixture.assert_called_once()
 
     @mock.patch("core.views.PackageRelease.dump_fixture")
@@ -846,8 +855,33 @@ class ReleaseProcessTests(TestCase):
             _step_publish(self.release, {}, Path("rel.log"))
         self.release.refresh_from_db()
         self.assertEqual(self.release.pypi_url, "")
+        self.assertIsNone(self.release.release_on)
         dump_fixture.assert_not_called()
 
+    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"])
+        Todo.objects.create(request="Initial checklist item")
+        steps = [("Confirm release TODO completion", core_views._step_check_todos)]
+        with mock.patch("core.views.PUBLISH_STEPS", steps):
+            self.client.force_login(user)
+            response = self.client.get(url)
+            self.assertTrue(response.context["has_pending_todos"])
+            self.client.get(f"{url}?ack_todos=1")
+            self.client.get(f"{url}?start=1")
+            self.client.get(f"{url}?step=0")
+            Todo.objects.create(request="Follow-up checklist item")
+            response = self.client.get(url)
+            self.assertEqual(
+                Todo.objects.filter(is_deleted=False, done_on__isnull=True).count(),
+                1,
+            )
+            self.assertIsNone(response.context["todos"])
+            self.assertFalse(response.context["has_pending_todos"])
+            session = self.client.session
+            ctx = session.get(f"release_publish_{self.release.pk}")
+            self.assertTrue(ctx.get("todos_ack"))
+
     def test_release_progress_uses_lockfile(self):
         run = []
 
@@ -901,6 +935,139 @@ class ReleaseProcessTests(TestCase):
             self.assertEqual(count_file.read_text(), "1")
 
 
+class ReleaseProgressSyncTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        self.user = User.objects.create_superuser("admin", "admin@example.com", "pw")
+        self.client.force_login(self.user)
+        self.package = Package.objects.get(name="arthexis")
+        self.version_path = Path("VERSION")
+        self.original_version = self.version_path.read_text(encoding="utf-8")
+        self.version_path.write_text("1.2.3", encoding="utf-8")
+
+    def tearDown(self):
+        self.version_path.write_text(self.original_version, encoding="utf-8")
+
+    @mock.patch("core.views.PackageRelease.dump_fixture")
+    @mock.patch("core.views.revision.get_revision", return_value="abc123")
+    def test_unpublished_release_syncs_version_and_revision(
+        self, get_revision, dump_fixture
+    ):
+        release = PackageRelease.objects.create(
+            package=self.package,
+            version="1.0.0",
+        )
+        release.revision = "oldrev"
+        release.save(update_fields=["revision"])
+
+        url = reverse("release-progress", args=[release.pk, "publish"])
+        response = self.client.get(url)
+
+        self.assertEqual(response.status_code, 200)
+        release.refresh_from_db()
+        self.assertEqual(release.version, "1.2.4")
+        self.assertEqual(release.revision, "abc123")
+        dump_fixture.assert_called_once()
+
+    def test_published_release_not_current_returns_404(self):
+        release = PackageRelease.objects.create(
+            package=self.package,
+            version="1.2.4",
+            pypi_url="https://example.com",
+        )
+
+        url = reverse("release-progress", args=[release.pk, "publish"])
+        response = self.client.get(url)
+
+        self.assertEqual(response.status_code, 404)
+
+
+class ReleaseProgressFixtureVisibilityTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        self.user = User.objects.create_superuser(
+            "fixture-check", "fixture@example.com", "pw"
+        )
+        self.client.force_login(self.user)
+        current_version = Path("VERSION").read_text(encoding="utf-8").strip()
+        package = Package.objects.filter(is_active=True).first()
+        if package is None:
+            package = Package.objects.create(name="fixturepkg", is_active=True)
+        try:
+            self.release = PackageRelease.objects.get(
+                package=package, version=current_version
+            )
+        except PackageRelease.DoesNotExist:
+            self.release = PackageRelease.objects.create(
+                package=package, version=current_version
+            )
+        self.session_key = f"release_publish_{self.release.pk}"
+        self.log_name = f"{self.release.package.name}-{self.release.version}.log"
+        self.lock_path = Path("locks") / f"{self.session_key}.json"
+        self.restart_path = Path("locks") / f"{self.session_key}.restarts"
+        self.log_path = Path("logs") / self.log_name
+        for path in (self.lock_path, self.restart_path, self.log_path):
+            if path.exists():
+                path.unlink()
+        try:
+            self.fixture_step_index = next(
+                idx
+                for idx, (name, _) in enumerate(core_views.PUBLISH_STEPS)
+                if name == core_views.FIXTURE_REVIEW_STEP_NAME
+            )
+        except StopIteration:  # pragma: no cover - defensive guard
+            self.fail("Fixture review step not configured in publish steps")
+        self.url = reverse("release-progress", args=[self.release.pk, "publish"])
+
+    def tearDown(self):
+        session = self.client.session
+        if self.session_key in session:
+            session.pop(self.session_key)
+            session.save()
+        for path in (self.lock_path, self.restart_path, self.log_path):
+            if path.exists():
+                path.unlink()
+        super().tearDown()
+
+    def _set_session(self, step: int, fixtures: list[dict]):
+        session = self.client.session
+        session[self.session_key] = {
+            "step": step,
+            "fixtures": fixtures,
+            "log": self.log_name,
+            "started": True,
+        }
+        session.save()
+
+    def test_fixture_summary_visible_until_migration_step(self):
+        fixtures = [
+            {
+                "path": "core/fixtures/example.json",
+                "count": 2,
+                "models": ["core.Model"],
+            }
+        ]
+        self._set_session(self.fixture_step_index, fixtures)
+        response = self.client.get(self.url)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.context["fixtures"], fixtures)
+        self.assertContains(response, "Fixture changes")
+
+    def test_fixture_summary_hidden_after_migration_step(self):
+        fixtures = [
+            {
+                "path": "core/fixtures/example.json",
+                "count": 2,
+                "models": ["core.Model"],
+            }
+        ]
+        self._set_session(self.fixture_step_index + 1, fixtures)
+        response = self.client.get(self.url)
+        self.assertEqual(response.status_code, 200)
+        self.assertIsNone(response.context["fixtures"])
+        self.assertNotContains(response, "Fixture changes")
+
+
 class PackageReleaseAdminActionTests(TestCase):
     def setUp(self):
         self.factory = RequestFactory()
@@ -908,6 +1075,8 @@ class PackageReleaseAdminActionTests(TestCase):
         self.admin = PackageReleaseAdmin(PackageRelease, self.site)
         self.admin.message_user = lambda *args, **kwargs: None
         self.package = Package.objects.create(name="pkg")
+        self.package.is_active = True
+        self.package.save(update_fields=["is_active"])
         self.release = PackageRelease.objects.create(
             package=self.package,
             version="1.0.0",
@@ -936,11 +1105,64 @@ class PackageReleaseAdminActionTests(TestCase):
     def test_refresh_from_pypi_creates_releases(self, mock_get, dump):
         mock_get.return_value.raise_for_status.return_value = None
         mock_get.return_value.json.return_value = {
-            "releases": {"1.0.0": [], "1.1.0": []}
+            "releases": {
+                "1.0.0": [
+                    {"upload_time_iso_8601": "2024-01-01T12:30:00.000000Z"}
+                ],
+                "1.1.0": [
+                    {"upload_time_iso_8601": "2024-02-02T15:45:00.000000Z"}
+                ],
+            }
         }
         self.admin.refresh_from_pypi(self.request, PackageRelease.objects.none())
         new_release = PackageRelease.objects.get(version="1.1.0")
         self.assertEqual(new_release.revision, "")
+        self.assertEqual(
+            new_release.release_on,
+            datetime(2024, 2, 2, 15, 45, tzinfo=datetime_timezone.utc),
+        )
+        dump.assert_called_once()
+
+    @mock.patch("core.admin.PackageRelease.dump_fixture")
+    @mock.patch("core.admin.requests.get")
+    def test_refresh_from_pypi_updates_release_date(self, mock_get, dump):
+        self.release.release_on = None
+        self.release.save(update_fields=["release_on"])
+        mock_get.return_value.raise_for_status.return_value = None
+        mock_get.return_value.json.return_value = {
+            "releases": {
+                "1.0.0": [
+                    {"upload_time_iso_8601": "2024-01-01T12:30:00.000000Z"}
+                ]
+            }
+        }
+        self.admin.refresh_from_pypi(self.request, PackageRelease.objects.none())
+        self.release.refresh_from_db()
+        self.assertEqual(
+            self.release.release_on,
+            datetime(2024, 1, 1, 12, 30, tzinfo=datetime_timezone.utc),
+        )
+        dump.assert_called_once()
+
+    @mock.patch("core.admin.PackageRelease.dump_fixture")
+    @mock.patch("core.admin.requests.get")
+    def test_refresh_from_pypi_restores_deleted_release(self, mock_get, dump):
+        self.release.is_deleted = True
+        self.release.save(update_fields=["is_deleted"])
+        mock_get.return_value.raise_for_status.return_value = None
+        mock_get.return_value.json.return_value = {
+            "releases": {
+                "1.0.0": [
+                    {"upload_time_iso_8601": "2024-01-01T12:30:00.000000Z"}
+                ]
+            }
+        }
+
+        self.admin.refresh_from_pypi(self.request, PackageRelease.objects.none())
+
+        self.assertTrue(
+            PackageRelease.objects.filter(version="1.0.0").exists()
+        )
         dump.assert_called_once()
 
 
@@ -982,6 +1204,40 @@ class PackageReleaseCurrentTests(TestCase):
         self.assertFalse(self.release.is_current)
 
 
+class PackageReleaseChangelistTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User.objects.create_superuser("admin", "admin@example.com", "pw")
+        self.client.force_login(User.objects.get(username="admin"))
+
+    def test_prepare_next_release_button_present(self):
+        response = self.client.get(reverse("admin:core_packagerelease_changelist"))
+        prepare_url = reverse(
+            "admin:core_packagerelease_actions", args=["prepare_next_release"]
+        )
+        self.assertContains(response, prepare_url, html=False)
+
+    def test_refresh_from_pypi_button_present(self):
+        response = self.client.get(reverse("admin:core_packagerelease_changelist"))
+        refresh_url = reverse(
+            "admin:core_packagerelease_actions", args=["refresh_from_pypi"]
+        )
+        self.assertContains(response, refresh_url, html=False)
+
+    def test_prepare_next_release_action_creates_release(self):
+        package = Package.objects.get(name="arthexis")
+        PackageRelease.all_objects.filter(package=package).delete()
+        response = self.client.post(
+            reverse(
+                "admin:core_packagerelease_actions", args=["prepare_next_release"]
+            )
+        )
+        self.assertEqual(response.status_code, 302)
+        self.assertTrue(
+            PackageRelease.all_objects.filter(package=package).exists()
+        )
+
+
 class PackageAdminPrepareNextReleaseTests(TestCase):
     def setUp(self):
         self.factory = RequestFactory()
@@ -1000,24 +1256,18 @@ class PackageAdminPrepareNextReleaseTests(TestCase):
         )
 
 
-class PackageReleaseChangelistTests(TestCase):
+class PackageAdminChangeViewTests(TestCase):
     def setUp(self):
         self.client = Client()
         User.objects.create_superuser("admin", "admin@example.com", "pw")
         self.client.force_login(User.objects.get(username="admin"))
+        self.package = Package.objects.get(name="arthexis")
 
-    def test_prepare_next_release_button_present(self):
-        response = self.client.get(reverse("admin:core_packagerelease_changelist"))
-        self.assertContains(
-            response, reverse("admin:core_package_prepare_next_release"), html=False
-        )
-
-    def test_refresh_from_pypi_button_present(self):
-        response = self.client.get(reverse("admin:core_packagerelease_changelist"))
-        refresh_url = reverse(
-            "admin:core_packagerelease_actions", args=["refresh_from_pypi"]
+    def test_prepare_next_release_button_visible_on_change_view(self):
+        response = self.client.get(
+            reverse("admin:core_package_change", args=[self.package.pk])
         )
-        self.assertContains(response, refresh_url, html=False)
+        self.assertContains(response, "Prepare next Release")
 
 
 class TodoDoneTests(TestCase):
@@ -1034,6 +1284,134 @@ class TodoDoneTests(TestCase):
         self.assertIsNotNone(todo.done_on)
         self.assertFalse(todo.is_deleted)
 
+    def test_mark_done_condition_failure_shows_message(self):
+        todo = Todo.objects.create(
+            request="Task",
+            on_done_condition="1 = 0",
+        )
+        resp = self.client.post(reverse("todo-done", args=[todo.pk]))
+        self.assertRedirects(resp, reverse("admin:index"))
+        messages = [m.message for m in get_messages(resp.wsgi_request)]
+        self.assertTrue(messages)
+        self.assertIn("1 = 0", messages[0])
+        todo.refresh_from_db()
+        self.assertIsNone(todo.done_on)
+
+    def test_mark_done_condition_invalid_expression(self):
+        todo = Todo.objects.create(
+            request="Task",
+            on_done_condition="1; SELECT 1",
+        )
+        resp = self.client.post(reverse("todo-done", args=[todo.pk]))
+        self.assertRedirects(resp, reverse("admin:index"))
+        messages = [m.message for m in get_messages(resp.wsgi_request)]
+        self.assertTrue(messages)
+        self.assertIn("Semicolons", messages[0])
+        todo.refresh_from_db()
+        self.assertIsNone(todo.done_on)
+
+    def test_mark_done_condition_resolves_sigils(self):
+        todo = Todo.objects.create(
+            request="Task",
+            on_done_condition="[TEST]",
+        )
+        with mock.patch.object(Todo, "resolve_sigils", return_value="1 = 1") as resolver:
+            resp = self.client.post(reverse("todo-done", args=[todo.pk]))
+        self.assertRedirects(resp, reverse("admin:index"))
+        resolver.assert_called_once_with("on_done_condition")
+        todo.refresh_from_db()
+        self.assertIsNotNone(todo.done_on)
+
+    def test_mark_done_respects_next_parameter(self):
+        todo = Todo.objects.create(request="Task")
+        next_url = reverse("admin:index") + "?section=todos"
+        resp = self.client.post(
+            reverse("todo-done", args=[todo.pk]),
+            {"next": next_url},
+        )
+        self.assertRedirects(resp, next_url, target_status_code=200)
+        todo.refresh_from_db()
+        self.assertIsNotNone(todo.done_on)
+
+    def test_mark_done_rejects_external_next(self):
+        todo = Todo.objects.create(request="Task")
+        resp = self.client.post(
+            reverse("todo-done", args=[todo.pk]),
+            {"next": "https://example.com/"},
+        )
+        self.assertRedirects(resp, reverse("admin:index"))
+        todo.refresh_from_db()
+        self.assertIsNotNone(todo.done_on)
+
+
+class TodoFocusViewTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User.objects.create_superuser("admin", "admin@example.com", "pw")
+        self.client.force_login(User.objects.get(username="admin"))
+
+    def test_focus_view_renders_requested_page(self):
+        todo = Todo.objects.create(request="Task", url="/docs/")
+        next_url = reverse("admin:index")
+        resp = self.client.get(
+            f"{reverse('todo-focus', args=[todo.pk])}?next={quote(next_url)}"
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertContains(resp, todo.request)
+        self.assertEqual(resp["X-Frame-Options"], "SAMEORIGIN")
+        self.assertContains(resp, f'src="{todo.url}"')
+        self.assertContains(resp, "Done")
+        self.assertContains(resp, "Back")
+
+    def test_focus_view_uses_admin_change_when_no_url(self):
+        todo = Todo.objects.create(request="Task")
+        resp = self.client.get(reverse("todo-focus", args=[todo.pk]))
+        change_url = reverse("admin:core_todo_change", args=[todo.pk])
+        self.assertContains(resp, f'src="{change_url}"')
+
+    def test_focus_view_sanitizes_loopback_absolute_url(self):
+        todo = Todo.objects.create(
+            request="Task",
+            url="http://127.0.0.1:8000/docs/?section=chart",
+        )
+        resp = self.client.get(reverse("todo-focus", args=[todo.pk]))
+        self.assertContains(resp, 'src="/docs/?section=chart"')
+
+    def test_focus_view_rejects_external_absolute_url(self):
+        todo = Todo.objects.create(
+            request="Task",
+            url="https://outside.invalid/external/",
+        )
+        resp = self.client.get(reverse("todo-focus", args=[todo.pk]))
+        change_url = reverse("admin:core_todo_change", args=[todo.pk])
+        self.assertContains(resp, f'src="{change_url}"')
+
+    def test_focus_view_avoids_recursive_focus_url(self):
+        todo = Todo.objects.create(request="Task")
+        focus_url = reverse("todo-focus", args=[todo.pk])
+        Todo.objects.filter(pk=todo.pk).update(url=focus_url)
+        resp = self.client.get(reverse("todo-focus", args=[todo.pk]))
+        change_url = reverse("admin:core_todo_change", args=[todo.pk])
+        self.assertContains(resp, f'src="{change_url}"')
+
+    def test_focus_view_avoids_recursive_focus_absolute_url(self):
+        todo = Todo.objects.create(request="Task")
+        focus_url = reverse("todo-focus", args=[todo.pk])
+        Todo.objects.filter(pk=todo.pk).update(url=f"http://testserver{focus_url}")
+        resp = self.client.get(reverse("todo-focus", args=[todo.pk]))
+        change_url = reverse("admin:core_todo_change", args=[todo.pk])
+        self.assertContains(resp, f'src="{change_url}"')
+
+    def test_focus_view_redirects_if_todo_completed(self):
+        todo = Todo.objects.create(request="Task")
+        todo.done_on = timezone.now()
+        todo.save(update_fields=["done_on"])
+        next_url = reverse("admin:index")
+        resp = self.client.get(
+            f"{reverse('todo-focus', args=[todo.pk])}?next={quote(next_url)}"
+        )
+        self.assertRedirects(resp, next_url, target_status_code=200)
+
 
 class TodoUrlValidationTests(TestCase):
     def test_relative_url_valid(self):