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

core/release.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import subprocess
 import sys
+import shutil
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
@@ -82,20 +83,12 @@ def _git_clean() -> bool:
     return not proc.stdout.strip()
 
 
-def _current_commit() -> str:
-    return subprocess.check_output(["git", "rev-parse", "HEAD"]).decode().strip()
+def _git_has_staged_changes() -> bool:
+    """Return True if there are staged changes ready to commit."""
+    proc = subprocess.run(["git", "diff", "--cached", "--quiet"])
+    return proc.returncode != 0
 
 
-def _current_branch() -> str:
-    return (
-        subprocess.check_output([
-            "git",
-            "rev-parse",
-            "--abbrev-ref",
-            "HEAD",
-        ]).decode().strip()
-    )
-
 
 def _manager_credentials() -> Optional[Credentials]:
     """Return credentials from the Package's release manager if available."""
@@ -174,69 +167,6 @@ def _write_pyproject(package: Package, version: str, requirements: list[str]) ->
     Path("pyproject.toml").write_text(_dump_toml(content), encoding="utf-8")
 
 
-def _ensure_changelog() -> str:
-    header = "Changelog\n=========\n\n"
-    path = Path("CHANGELOG.rst")
-    text = path.read_text(encoding="utf-8") if path.exists() else ""
-    if not text.startswith("Changelog"):
-        text = header + text
-    if "Unreleased" not in text:
-        text = text[: len(header)] + "Unreleased\n----------\n\n" + text[len(header):]
-    return text
-
-
-def _pop_unreleased(text: str) -> tuple[str, str]:
-    lines = text.splitlines()
-    try:
-        idx = lines.index("Unreleased")
-    except ValueError:
-        return "", text
-    body = []
-    i = idx + 2
-    while i < len(lines) and lines[i].startswith("- "):
-        body.append(lines[i])
-        i += 1
-    if i < len(lines) and lines[i] == "":
-        i += 1
-    new_lines = lines[:idx] + lines[i:]
-    return "\n".join(body), "\n".join(new_lines) + ("\n" if text.endswith("\n") else "")
-
-
-def _last_changelog_revision() -> Optional[str]:
-    path = Path("CHANGELOG.rst")
-    if not path.exists():
-        return None
-    for line in path.read_text(encoding="utf-8").splitlines():
-        if "[revision" in line:
-            try:
-                return line.split("[revision", 1)[1].split("]", 1)[0].strip()
-            except Exception:
-                return None
-    return None
-
-
-def update_changelog(version: str, revision: str, prev_revision: Optional[str] = None) -> None:
-    text = _ensure_changelog()
-    body, text = _pop_unreleased(text)
-    if not body:
-        prev_revision = prev_revision or _last_changelog_revision()
-        log_range = f"{prev_revision}..HEAD" if prev_revision else "HEAD"
-        proc = subprocess.run(
-            ["git", "log", "--pretty=%h %s", "--no-merges", log_range],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        body = "\n".join(
-            f"- {l.strip()}" for l in proc.stdout.splitlines() if l.strip()
-        )
-    header = f"{version} [revision {revision}]"
-    underline = "-" * len(header)
-    entry = "\n".join([header, underline, "", body, ""]).rstrip() + "\n\n"
-    base_header = "Changelog\n=========\n\n"
-    remaining = text[len(base_header):]
-    new_text = base_header + "Unreleased\n----------\n\n" + entry + remaining
-    Path("CHANGELOG.rst").write_text(new_text, encoding="utf-8")
 
 
 @requires_network
@@ -268,8 +198,8 @@ def build(
                 "Git repository is not clean. Commit, stash, or enable auto stash before building."
             )
 
+    version_path = Path("VERSION")
     if version is None:
-        version_path = Path("VERSION")
         if not version_path.exists():
             raise ReleaseError("VERSION file not found")
         version = version_path.read_text().strip()
@@ -278,6 +208,9 @@ def build(
             patch += 1
             version = f"{major}.{minor}.{patch}"
             version_path.write_text(version + "\n")
+    else:
+        # Ensure the VERSION file reflects the provided release version
+        version_path.write_text(version + "\n")
 
     requirements = [
         line.strip()
@@ -291,16 +224,10 @@ def build(
         if proc.returncode != 0:
             raise TestsFailed(log_path, proc.stdout + proc.stderr)
 
-    commit_hash = _current_commit()
-    prev_revision = _last_changelog_revision()
-    update_changelog(version, commit_hash, prev_revision)
-
     _write_pyproject(package, version, requirements)
     if dist:
         if Path("dist").exists():
-            for p in Path("dist").glob("*"):
-                p.unlink()
-            Path("dist").rmdir()
+            shutil.rmtree("dist")
         try:
             import build  # type: ignore
         except Exception:
@@ -308,10 +235,11 @@ def build(
         _run([sys.executable, "-m", "build"])
 
     if git:
-        files = ["VERSION", "pyproject.toml", "CHANGELOG.rst"]
+        files = ["VERSION", "pyproject.toml"]
         _run(["git", "add"] + files)
         msg = f"PyPI Release v{version}" if twine else f"Release v{version}"
-        _run(["git", "commit", "-m", msg])
+        if _git_has_staged_changes():
+            _run(["git", "commit", "-m", msg])
         _run(["git", "push"])
 
     if tag:
@@ -359,63 +287,23 @@ def promote(
     package: Package = DEFAULT_PACKAGE,
     version: str,
     creds: Optional[Credentials] = None,
-) -> tuple[str, str, str]:
-    """Create a release branch and build the package without tests.
-
-    Returns a tuple of the release commit hash, the new branch name and the
-    original branch name.
-    """
-    current = _current_branch()
-    tmp_branch = f"release/{version}"
-    stashed = False
-    try:
-        try:
-            _run(["git", "checkout", "-b", tmp_branch])
-        except subprocess.CalledProcessError:
-            _run(["git", "checkout", tmp_branch])
-        if not _git_clean():
-            _run(["git", "stash", "--include-untracked"])
-            stashed = True
-        build(
-            package=package,
-            version=version,
-            creds=creds,
-            tests=False,
-            dist=True,
-            git=False,
-            tag=False,
-            stash=True,
-        )
-        try:  # best effort
-            _run(
-                [
-                    sys.executable,
-                    "manage.py",
-                    "squashmigrations",
-                    "core",
-                    "0001",
-                    "--noinput",
-                ],
-                check=False,
-            )
-        except Exception:
-            # The squashmigrations command may not be available or could fail
-            # (e.g. when no migrations exist). Any errors should not interrupt
-            # the release promotion flow.
-            pass
-        _run(["git", "add", "."])  # add all changes
+) -> None:
+    """Build the package and commit the release on the current branch."""
+    if not _git_clean():
+        raise ReleaseError("Git repository is not clean")
+    build(
+        package=package,
+        version=version,
+        creds=creds,
+        tests=False,
+        dist=True,
+        git=False,
+        tag=False,
+        stash=False,
+    )
+    _run(["git", "add", "."])  # add all changes
+    if _git_has_staged_changes():
         _run(["git", "commit", "-m", f"Release v{version}"])
-        commit_hash = _current_commit()
-        release_name = f"{package.name}-{version}-{commit_hash[:7]}"
-        branch = f"release-{release_name}"
-        _run(["git", "branch", "-m", branch])
-    except Exception:
-        _run(["git", "checkout", current])
-        raise
-    finally:
-        if stashed:
-            _run(["git", "stash", "pop"], check=False)
-    return commit_hash, branch, current
 
 
 def publish(

core/system.py

@@ -31,8 +31,8 @@ def _gather_info() -> dict:
     info["mode"] = mode
     info["port"] = 8000 if mode == "public" else 8888
 
-    role_file = lock_dir / "role.lck"
-    info["role"] = role_file.read_text().strip() if role_file.exists() else "unknown"
+    # Use settings.NODE_ROLE as the single source of truth for the node role.
+    info["role"] = getattr(settings, "NODE_ROLE", "Terminal")
 
     info["features"] = {
         "celery": (lock_dir / "celery.lck").exists(),

core/test_system_info.py

@@ -0,0 +1,21 @@
+import os
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+
+import django
+django.setup()
+
+from django.test import SimpleTestCase, override_settings
+from core.system import _gather_info
+
+
+class SystemInfoRoleTests(SimpleTestCase):
+    @override_settings(NODE_ROLE="Terminal")
+    def test_defaults_to_terminal(self):
+        info = _gather_info()
+        self.assertEqual(info["role"], "Terminal")
+
+    @override_settings(NODE_ROLE="Satellite")
+    def test_uses_settings_role(self):
+        info = _gather_info()
+        self.assertEqual(info["role"], "Satellite")

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
 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,195 @@ 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")
+            self.assertEqual(count_file.read_text(), "2")
+
+
+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()
+