arthexis 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

core/tests.py

@@ -4,11 +4,13 @@ os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
 import django
 django.setup()
 
-from django.test import Client, TestCase
+from django.test import Client, TestCase, RequestFactory
 from django.urls import reverse
 from django.http import HttpRequest
 import json
 from unittest import mock
+from pathlib import Path
+import subprocess
 
 from django.utils import timezone
 from .models import (
@@ -24,13 +26,18 @@ from .models import (
     RFID,
     FediverseProfile,
     SecurityGroup,
+    Package,
+    PackageRelease,
 )
+from django.contrib.admin.sites import AdminSite
+from core.admin import PackageReleaseAdmin, PackageAdmin
 from ocpp.models import Transaction, Charger
 
 from django.core.exceptions import ValidationError
 from django.core.management import call_command
 from django.db import IntegrityError
 from .backends import LocalhostAdminBackend
+from core.views import _step_check_pypi, _step_promote_build, _step_publish
 
 
 class DefaultAdminTests(TestCase):
@@ -481,3 +488,287 @@ class FediverseProfileTests(TestCase):
             profile.test_connection()
         self.assertIsNone(profile.verified_on)
 
+
+class ReleaseProcessTests(TestCase):
+    def setUp(self):
+        self.package = Package.objects.create(name="pkg")
+        self.release = PackageRelease.objects.create(
+            package=self.package, version="1.0.0"
+        )
+
+    @mock.patch("core.views.release_utils._git_clean", return_value=False)
+    def test_step_check_requires_clean_repo(self, git_clean):
+        with self.assertRaises(Exception):
+            _step_check_pypi(self.release, {}, Path("rel.log"))
+
+    @mock.patch("core.views.release_utils._git_clean", return_value=True)
+    @mock.patch("core.views.release_utils.network_available", return_value=False)
+    def test_step_check_keeps_repo_clean(self, network_available, git_clean):
+        version_path = Path("VERSION")
+        original = version_path.read_text(encoding="utf-8")
+        _step_check_pypi(self.release, {}, Path("rel.log"))
+        proc = subprocess.run(
+            ["git", "status", "--porcelain", str(version_path)],
+            capture_output=True,
+            text=True,
+        )
+        self.assertFalse(proc.stdout.strip())
+        self.assertEqual(version_path.read_text(encoding="utf-8"), original)
+
+    @mock.patch("core.models.PackageRelease.dump_fixture")
+    def test_save_does_not_dump_fixture(self, dump):
+        self.release.pypi_url = "https://example.com"
+        self.release.save()
+        dump.assert_not_called()
+
+    @mock.patch("core.views.subprocess.run")
+    @mock.patch("core.views.PackageRelease.dump_fixture")
+    @mock.patch("core.views.release_utils.promote", side_effect=Exception("boom"))
+    def test_promote_cleans_repo_on_failure(
+        self, promote, dump_fixture, run
+    ):
+        with self.assertRaises(Exception):
+            _step_promote_build(self.release, {}, Path("rel.log"))
+        dump_fixture.assert_not_called()
+        run.assert_any_call(["git", "reset", "--hard"], check=False)
+        run.assert_any_call(["git", "clean", "-fd"], check=False)
+
+    @mock.patch("core.views.subprocess.run")
+    @mock.patch("core.views.PackageRelease.dump_fixture")
+    @mock.patch("core.views.release_utils.promote")
+    def test_promote_rebases_and_pushes_main(self, promote, dump_fixture, run):
+        import subprocess as sp
+
+        def fake_run(cmd, check=True, capture_output=False, text=False):
+            if capture_output:
+                return sp.CompletedProcess(cmd, 0, stdout="", stderr="")
+            return sp.CompletedProcess(cmd, 0)
+
+        run.side_effect = fake_run
+        _step_promote_build(self.release, {}, Path("rel.log"))
+        run.assert_any_call(["git", "fetch", "origin", "main"], check=True)
+        run.assert_any_call(["git", "rebase", "origin/main"], check=True)
+        run.assert_any_call(["git", "push"], check=True)
+
+    @mock.patch("core.views.subprocess.run")
+    @mock.patch("core.views.PackageRelease.dump_fixture")
+    def test_promote_advances_version(self, dump_fixture, run):
+        import subprocess as sp
+
+        def fake_run(cmd, check=True, capture_output=False, text=False):
+            if capture_output:
+                return sp.CompletedProcess(cmd, 0, stdout="", stderr="")
+            return sp.CompletedProcess(cmd, 0)
+
+        run.side_effect = fake_run
+
+        version_path = Path("VERSION")
+        original = version_path.read_text(encoding="utf-8")
+        version_path.write_text("0.0.1\n", encoding="utf-8")
+
+        def fake_promote(*args, **kwargs):
+            version_path.write_text(self.release.version + "\n", encoding="utf-8")
+
+        with mock.patch("core.views.release_utils.promote", side_effect=fake_promote):
+            _step_promote_build(self.release, {}, Path("rel.log"))
+
+        self.assertEqual(
+            version_path.read_text(encoding="utf-8"),
+            self.release.version + "\n",
+        )
+        version_path.write_text(original, encoding="utf-8")
+
+    @mock.patch("core.views.PackageRelease.dump_fixture")
+    @mock.patch("core.views.release_utils.publish")
+    def test_publish_sets_pypi_url(self, publish, dump_fixture):
+        _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}/",
+        )
+        dump_fixture.assert_called_once()
+
+    @mock.patch("core.views.PackageRelease.dump_fixture")
+    @mock.patch("core.views.release_utils.publish", side_effect=Exception("boom"))
+    def test_publish_failure_keeps_url_blank(self, publish, dump_fixture):
+        with self.assertRaises(Exception):
+            _step_publish(self.release, {}, Path("rel.log"))
+        self.release.refresh_from_db()
+        self.assertEqual(self.release.pypi_url, "")
+        dump_fixture.assert_not_called()
+
+    def test_release_progress_uses_lockfile(self):
+        run = []
+
+        def step1(release, ctx, log_path):
+            run.append("step1")
+
+        def step2(release, ctx, log_path):
+            run.append("step2")
+
+        steps = [("One", step1), ("Two", step2)]
+        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)
+            self.client.get(f"{url}?step=0")
+            self.assertEqual(run, ["step1"])
+            client2 = Client()
+            client2.force_login(user)
+            client2.get(f"{url}?step=1")
+            self.assertEqual(run, ["step1", "step2"])
+            lock_file = Path("locks") / f"release_publish_{self.release.pk}.json"
+            self.assertFalse(lock_file.exists())
+
+    def test_release_progress_restart(self):
+        run = []
+
+        def step_fail(release, ctx, log_path):
+            run.append("step")
+            raise Exception("boom")
+
+        steps = [("Fail", step_fail)]
+        user = User.objects.create_superuser("admin", "admin@example.com", "pw")
+        url = reverse("release-progress", args=[self.release.pk, "publish"])
+        count_file = Path("locks") / f"release_publish_{self.release.pk}.restarts"
+        if count_file.exists():
+            count_file.unlink()
+        with mock.patch("core.views.PUBLISH_STEPS", steps):
+            self.client.force_login(user)
+            self.assertFalse(count_file.exists())
+            self.client.get(f"{url}?step=0")
+            self.client.get(f"{url}?step=0")
+            self.assertEqual(run, ["step"])
+            self.assertFalse(count_file.exists())
+            self.client.get(f"{url}?restart=1")
+            self.assertTrue(count_file.exists())
+            self.assertEqual(count_file.read_text(), "1")
+            self.client.get(f"{url}?step=0")
+            self.assertEqual(run, ["step", "step"])
+            self.client.get(f"{url}?restart=1")
+            # Restart counter resets after running a step
+            self.assertEqual(count_file.read_text(), "1")
+
+
+class PackageReleaseAdminActionTests(TestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.site = AdminSite()
+        self.admin = PackageReleaseAdmin(PackageRelease, self.site)
+        self.admin.message_user = lambda *args, **kwargs: None
+        self.package = Package.objects.create(name="pkg")
+        self.release = PackageRelease.objects.create(
+            package=self.package,
+            version="1.0.0",
+            pypi_url="https://pypi.org/project/pkg/1.0.0/",
+        )
+        self.request = self.factory.get("/")
+
+    @mock.patch("core.admin.PackageRelease.dump_fixture")
+    @mock.patch("core.admin.requests.get")
+    def test_validate_deletes_missing_release(self, mock_get, dump):
+        mock_get.return_value.status_code = 404
+        self.admin.validate_releases(self.request, PackageRelease.objects.all())
+        self.assertEqual(PackageRelease.objects.count(), 0)
+        dump.assert_called_once()
+
+    @mock.patch("core.admin.PackageRelease.dump_fixture")
+    @mock.patch("core.admin.requests.get")
+    def test_validate_keeps_existing_release(self, mock_get, dump):
+        mock_get.return_value.status_code = 200
+        self.admin.validate_releases(self.request, PackageRelease.objects.all())
+        self.assertEqual(PackageRelease.objects.count(), 1)
+        dump.assert_not_called()
+
+    @mock.patch("core.admin.PackageRelease.dump_fixture")
+    @mock.patch("core.admin.requests.get")
+    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": []}
+        }
+        self.admin.refresh_from_pypi(
+            self.request, PackageRelease.objects.none()
+        )
+        self.assertTrue(
+            PackageRelease.objects.filter(version="1.1.0").exists()
+        )
+        dump.assert_called_once()
+
+
+class PackageActiveTests(TestCase):
+    def test_only_one_active_package(self):
+        default = Package.objects.get(name="arthexis")
+        self.assertTrue(default.is_active)
+        other = Package.objects.create(name="pkg", is_active=True)
+        default.refresh_from_db()
+        other.refresh_from_db()
+        self.assertFalse(default.is_active)
+        self.assertTrue(other.is_active)
+
+
+class PackageReleaseCurrentTests(TestCase):
+    def setUp(self):
+        self.package = Package.objects.get(name="arthexis")
+        self.version_path = Path("VERSION")
+        self.original = self.version_path.read_text()
+        self.version_path.write_text("1.0.0")
+        self.release = PackageRelease.objects.create(
+            package=self.package, version="1.0.0"
+        )
+
+    def tearDown(self):
+        self.version_path.write_text(self.original)
+
+    def test_is_current_true_when_version_matches_and_package_active(self):
+        self.assertTrue(self.release.is_current)
+
+    def test_is_current_false_when_package_inactive(self):
+        self.package.is_active = False
+        self.package.save()
+        self.assertFalse(self.release.is_current)
+
+    def test_is_current_false_when_version_differs(self):
+        self.release.version = "2.0.0"
+        self.release.save()
+        self.assertFalse(self.release.is_current)
+
+
+class PackageAdminPrepareNextReleaseTests(TestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.site = AdminSite()
+        self.admin = PackageAdmin(Package, self.site)
+        self.admin.message_user = lambda *args, **kwargs: None
+        self.package = Package.objects.get(name="arthexis")
+
+    def test_prepare_next_release_active_creates_release(self):
+        PackageRelease.all_objects.filter(package=self.package).delete()
+        request = self.factory.get("/admin/core/package/prepare-next-release/")
+        response = self.admin.prepare_next_release_active(request)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(
+            PackageRelease.all_objects.filter(package=self.package).count(), 1
+        )
+
+
+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"))
+        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"]
+        )
+        self.assertContains(response, refresh_url, html=False)
+