arthexis 0.1.22__py3-none-any.whl → 0.1.23__py3-none-any.whl

core/tests.py

@@ -2138,6 +2138,25 @@ class PackageReleaseCurrentTests(TestCase):
         self.package.save()
         self.assertFalse(self.release.is_current)
 
+    def test_is_current_false_when_version_has_plus(self):
+        self.version_path.write_text("1.0.0+")
+        self.assertFalse(self.release.is_current)
+
+
+class PackageReleaseRevisionTests(TestCase):
+    def setUp(self):
+        self.package = Package.objects.get(name="arthexis")
+        self.release = PackageRelease.objects.create(
+            package=self.package,
+            version="1.0.0",
+            revision="abcdef123456",
+        )
+
+    def test_matches_revision_ignores_plus_suffix(self):
+        self.assertTrue(
+            PackageRelease.matches_revision("1.0.0+", "abcdef123456")
+        )
+
     def test_is_current_false_when_version_differs(self):
         self.release.version = "2.0.0"
         self.release.save()
@@ -2188,13 +2207,22 @@ class PackageAdminPrepareNextReleaseTests(TestCase):
 
     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/")
+        request = self.factory.post("/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
         )
 
+    def test_prepare_next_release_active_get_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.assertTrue(
+            PackageRelease.all_objects.filter(package=self.package).exists()
+        )
+
 
 class PackageAdminChangeViewTests(TestCase):
     def setUp(self):

core/user_data.py

@@ -201,9 +201,49 @@ def dump_user_fixture(instance, user=None) -> None:
 
 def delete_user_fixture(instance, user=None) -> None:
     target_user = user or _resolve_fixture_user(instance)
-    if target_user is None:
+    filename = (
+        f"{instance._meta.app_label}_{instance._meta.model_name}_{instance.pk}.json"
+    )
+
+    def _remove_for_user(candidate) -> None:
+        if candidate is None:
+            return
+        base_path = Path(
+            getattr(candidate, "data_path", "") or Path(settings.BASE_DIR) / "data"
+        )
+        username = _username_for(candidate)
+        if not username:
+            return
+        user_dir = base_path / username
+        if user_dir.exists():
+            (user_dir / filename).unlink(missing_ok=True)
+
+    if target_user is not None:
+        _remove_for_user(target_user)
         return
-    _fixture_path(target_user, instance).unlink(missing_ok=True)
+
+    root = Path(settings.BASE_DIR) / "data"
+    if root.exists():
+        (root / filename).unlink(missing_ok=True)
+        for path in root.iterdir():
+            if path.is_dir():
+                (path / filename).unlink(missing_ok=True)
+
+    UserModel = get_user_model()
+    manager = getattr(UserModel, "all_objects", UserModel._default_manager)
+    for candidate in manager.all():
+        data_path = getattr(candidate, "data_path", "")
+        if not data_path:
+            continue
+        base_path = Path(data_path)
+        if not base_path.exists():
+            continue
+        username = _username_for(candidate)
+        if not username:
+            continue
+        user_dir = base_path / username
+        if user_dir.exists():
+            (user_dir / filename).unlink(missing_ok=True)
 
 
 def _mark_fixture_user_data(path: Path) -> None:

core/views.py

@@ -690,16 +690,17 @@ def _ensure_origin_main_unchanged(log_path: Path) -> None:
 def _next_patch_version(version: str) -> str:
     from packaging.version import InvalidVersion, Version
 
+    cleaned = version.rstrip("+")
     try:
-        parsed = Version(version)
+        parsed = Version(cleaned)
     except InvalidVersion:
-        parts = version.split(".")
+        parts = cleaned.split(".") if cleaned else []
         for index in range(len(parts) - 1, -1, -1):
             segment = parts[index]
             if segment.isdigit():
                 parts[index] = str(int(segment) + 1)
                 return ".".join(parts)
-        return version
+        return cleaned or version
     return f"{parsed.major}.{parsed.minor}.{parsed.micro + 1}"
 
 
@@ -768,7 +769,9 @@ def _sync_release_with_revision(release: PackageRelease) -> tuple[bool, str]:
     version_path = Path("VERSION")
     if version_path.exists():
         try:
-            repo_version = Version(version_path.read_text(encoding="utf-8").strip())
+            raw_version = version_path.read_text(encoding="utf-8").strip()
+            cleaned_version = raw_version.rstrip("+") or "0.0.0"
+            repo_version = Version(cleaned_version)
         except InvalidVersion:
             repo_version = None
 
@@ -935,7 +938,7 @@ def _refresh_changelog_once(ctx, log_path: Path) -> None:
     ctx["changelog_refreshed"] = True
 
 
-def _step_check_todos(release, ctx, log_path: Path) -> None:
+def _step_check_todos(release, ctx, log_path: Path, *, user=None) -> None:
     _refresh_changelog_once(ctx, log_path)
 
     pending_qs = Todo.objects.filter(is_deleted=False, done_on__isnull=True)
@@ -975,7 +978,7 @@ def _step_check_todos(release, ctx, log_path: Path) -> None:
     ctx["todos_ack"] = True
 
 
-def _step_check_version(release, ctx, log_path: Path) -> None:
+def _step_check_version(release, ctx, log_path: Path, *, user=None) -> None:
     from . import release as release_utils
     from packaging.version import InvalidVersion, Version
 
@@ -1110,10 +1113,12 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
     version_path = Path("VERSION")
     if version_path.exists():
         current = version_path.read_text(encoding="utf-8").strip()
-        if current and Version(release.version) < Version(current):
-            raise Exception(
-                f"Version {release.version} is older than existing {current}"
-            )
+        if current:
+            current_clean = current.rstrip("+") or "0.0.0"
+            if Version(release.version) < Version(current_clean):
+                raise Exception(
+                    f"Version {release.version} is older than existing {current}"
+                )
 
     _append_log(log_path, f"Checking if version {release.version} exists on PyPI")
     if release_utils.network_available():
@@ -1163,17 +1168,17 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
         _append_log(log_path, "Network unavailable, skipping PyPI check")
 
 
-def _step_handle_migrations(release, ctx, log_path: Path) -> None:
+def _step_handle_migrations(release, ctx, log_path: Path, *, user=None) -> None:
     _append_log(log_path, "Freeze, squash and approve migrations")
     _append_log(log_path, "Migration review acknowledged (manual step)")
 
 
-def _step_changelog_docs(release, ctx, log_path: Path) -> None:
+def _step_changelog_docs(release, ctx, log_path: Path, *, user=None) -> None:
     _append_log(log_path, "Compose CHANGELOG and documentation")
     _append_log(log_path, "CHANGELOG and documentation review recorded")
 
 
-def _step_pre_release_actions(release, ctx, log_path: Path) -> None:
+def _step_pre_release_actions(release, ctx, log_path: Path, *, user=None) -> None:
     _append_log(log_path, "Execute pre-release actions")
     if ctx.get("dry_run"):
         _append_log(log_path, "Dry run: skipping pre-release actions")
@@ -1249,12 +1254,12 @@ def _step_pre_release_actions(release, ctx, log_path: Path) -> None:
     _append_log(log_path, "Pre-release actions complete")
 
 
-def _step_run_tests(release, ctx, log_path: Path) -> None:
+def _step_run_tests(release, ctx, log_path: Path, *, user=None) -> None:
     _append_log(log_path, "Complete test suite with --all flag")
     _append_log(log_path, "Test suite completion acknowledged")
 
 
-def _step_promote_build(release, ctx, log_path: Path) -> None:
+def _step_promote_build(release, ctx, log_path: Path, *, user=None) -> None:
     from . import release as release_utils
 
     _append_log(log_path, "Generating build files")
@@ -1266,7 +1271,7 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
         release_utils.promote(
             package=release.to_package(),
             version=release.version,
-            creds=release.to_credentials(),
+            creds=release.to_credentials(user=user),
         )
         _append_log(
             log_path,
@@ -1314,8 +1319,10 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
     _append_log(new_log, "Build complete")
 
 
-def _step_release_manager_approval(release, ctx, log_path: Path) -> None:
-    if release.to_credentials() is None:
+def _step_release_manager_approval(
+    release, ctx, log_path: Path, *, user=None
+) -> None:
+    if release.to_credentials(user=user) is None:
         ctx.pop("release_approval", None)
         if not ctx.get("approval_credentials_missing"):
             _append_log(log_path, "Release manager publishing credentials missing")
@@ -1349,14 +1356,14 @@ def _step_release_manager_approval(release, ctx, log_path: Path) -> None:
     raise ApprovalRequired()
 
 
-def _step_publish(release, ctx, log_path: Path) -> None:
+def _step_publish(release, ctx, log_path: Path, *, user=None) -> None:
     from . import release as release_utils
 
     if ctx.get("dry_run"):
         test_repository_url = os.environ.get(
             "PYPI_TEST_REPOSITORY_URL", "https://test.pypi.org/legacy/"
         )
-        test_creds = release.to_credentials()
+        test_creds = release.to_credentials(user=user)
         if not (test_creds and test_creds.has_auth()):
             test_creds = release_utils.Credentials(
                 token=os.environ.get("PYPI_TEST_API_TOKEN"),
@@ -1396,7 +1403,7 @@ def _step_publish(release, ctx, log_path: Path) -> None:
                 release_utils.build(
                     package=package,
                     version=release.version,
-                    creds=release.to_credentials(),
+                    creds=release.to_credentials(user=user),
                     dist=True,
                     tests=False,
                     twine=False,
@@ -1425,13 +1432,13 @@ def _step_publish(release, ctx, log_path: Path) -> None:
         release_utils.publish(
             package=release.to_package(),
             version=release.version,
-            creds=target.credentials or release.to_credentials(),
+            creds=target.credentials or release.to_credentials(user=user),
             repositories=[target],
         )
         _append_log(log_path, "Dry run: skipped release metadata updates")
         return
 
-    targets = release.build_publish_targets()
+    targets = release.build_publish_targets(user=user)
     repo_labels = []
     for target in targets:
         label = target.name
@@ -1450,7 +1457,7 @@ def _step_publish(release, ctx, log_path: Path) -> None:
         release_utils.publish(
             package=release.to_package(),
             version=release.version,
-            creds=release.to_credentials(),
+            creds=release.to_credentials(user=user),
             repositories=targets,
         )
     except release_utils.PostPublishWarning as warning:
@@ -1819,7 +1826,7 @@ def release_progress(request, pk: int, action: str):
         return redirect(request.path)
 
     manager = release.release_manager or release.package.release_manager
-    credentials_ready = bool(release.to_credentials())
+    credentials_ready = bool(release.to_credentials(user=request.user))
     if credentials_ready and ctx.get("approval_credentials_missing"):
         ctx.pop("approval_credentials_missing", None)
 
@@ -1990,7 +1997,7 @@ def release_progress(request, pk: int, action: str):
         if to_run == step_count:
             name, func = steps[to_run]
             try:
-                func(release, ctx, log_path)
+                func(release, ctx, log_path, user=request.user)
             except PendingTodos:
                 pass
             except ApprovalRequired:

nodes/admin.py

@@ -19,7 +19,7 @@ from django.utils.html import format_html, format_html_join
 from django.utils.translation import gettext_lazy as _
 from pathlib import Path
 from types import SimpleNamespace
-from urllib.parse import urlparse, urlsplit, urlunsplit
+from urllib.parse import urljoin, urlparse, urlsplit, urlunsplit
 import base64
 import ipaddress
 import json
@@ -440,6 +440,12 @@ class NodeAdmin(EntityModelAdmin):
             },
             "target": reverse("admin:index"),
         }
+        mac_address = str(local_node.mac_address or "").strip()
+        if mac_address:
+            payload["requester_mac"] = mac_address
+        public_key = local_node.public_key
+        if public_key:
+            payload["requester_public_key"] = public_key
         return payload
 
     def _start_proxy_session(self, request, node):
@@ -474,29 +480,64 @@ class NodeAdmin(EntityModelAdmin):
         }
 
         last_error = ""
+        redirect_codes = {301, 302, 303, 307, 308}
+
         for url in self._iter_remote_urls(node, "/nodes/proxy/session/"):
-            try:
-                response = requests.post(url, data=body, headers=headers, timeout=5)
-            except RequestException as exc:
-                last_error = str(exc)
-                continue
-            if not response.ok:
-                last_error = f"{response.status_code} {response.text}"
-                continue
-            try:
-                data = response.json()
-            except ValueError:
-                last_error = "Invalid JSON response"
-                continue
-            login_url = data.get("login_url")
-            if not login_url:
-                last_error = "login_url missing"
-                continue
-            return {
-                "ok": True,
-                "login_url": login_url,
-                "expires": data.get("expires"),
-            }
+            candidate_url = url
+            redirects_followed = 0
+            success = False
+
+            while True:
+                try:
+                    response = requests.post(
+                        candidate_url,
+                        data=body,
+                        headers=headers,
+                        timeout=5,
+                        allow_redirects=False,
+                    )
+                except RequestException as exc:
+                    last_error = str(exc)
+                    break
+
+                if response.status_code in redirect_codes:
+                    location = response.headers.get("Location")
+                    if not location:
+                        last_error = f"{response.status_code} redirect missing Location header"
+                        break
+
+                    redirects_followed += 1
+                    if redirects_followed > 3:
+                        last_error = "Too many redirects"
+                        break
+
+                    candidate_url = urljoin(candidate_url, location)
+                    continue
+
+                if not response.ok:
+                    last_error = f"{response.status_code} {response.text}"
+                    break
+
+                try:
+                    data = response.json()
+                except ValueError:
+                    last_error = "Invalid JSON response"
+                    break
+
+                login_url = data.get("login_url")
+                if not login_url:
+                    last_error = "login_url missing"
+                    break
+
+                success = True
+                break
+
+            if success:
+                return {
+                    "ok": True,
+                    "login_url": login_url,
+                    "expires": data.get("expires"),
+                }
 
         return {
             "ok": False,

nodes/models.py

@@ -4,6 +4,7 @@ from collections.abc import Iterable
 from copy import deepcopy
 from dataclasses import dataclass
 from django.db import models
+from django.db.models import Q
 from django.db.utils import DatabaseError
 from django.db.models.signals import post_delete
 from django.dispatch import Signal, receiver
@@ -294,7 +295,14 @@ class Node(Entity):
         """Return the node representing the current host if it exists."""
         mac = cls.get_current_mac()
         try:
-            return cls.objects.filter(mac_address=mac).first()
+            node = cls.objects.filter(mac_address__iexact=mac).first()
+            if node:
+                return node
+            return (
+                cls.objects.filter(current_relation=cls.Relation.SELF)
+                .filter(Q(mac_address__isnull=True) | Q(mac_address=""))
+                .first()
+            )
         except DatabaseError:
             logger.debug("nodes.Node.get_local skipped: database unavailable", exc_info=True)
             return None

nodes/tests.py

@@ -1844,6 +1844,8 @@ class NodeAdminTests(TestCase):
         mock_post.assert_called()
         payload = json.loads(mock_post.call_args[1]["data"])
         self.assertEqual(payload.get("requester"), str(local_node.uuid))
+        self.assertEqual(payload.get("requester_mac"), local_node.mac_address)
+        self.assertEqual(payload.get("requester_public_key"), local_node.public_key)
 
     @patch("nodes.admin.requests.post")
     def test_proxy_view_falls_back_to_http_after_ssl_error(self, mock_post):
@@ -1882,6 +1884,52 @@ class NodeAdminTests(TestCase):
         self.assertIn("/nodes/proxy/session/", second_url)
         payload = json.loads(mock_post.call_args_list[-1].kwargs["data"])
         self.assertEqual(payload.get("requester"), str(local_node.uuid))
+        self.assertEqual(payload.get("requester_mac"), local_node.mac_address)
+        self.assertEqual(payload.get("requester_public_key"), local_node.public_key)
+
+    @patch("nodes.admin.requests.post")
+    def test_proxy_view_retries_post_after_redirect(self, mock_post):
+        self.client.get(reverse("admin:nodes_node_register_current"))
+        remote = Node.objects.create(
+            hostname="redirect-node",
+            public_endpoint="http://remote.example",
+            address="198.51.100.30",
+            mac_address="aa:bb:cc:dd:ee:20",
+        )
+
+        redirect_response = SimpleNamespace(
+            status_code=301,
+            ok=True,
+            text="redirect",
+            headers={"Location": "https://remote.example/nodes/proxy/session/"},
+        )
+        success_response = SimpleNamespace(
+            status_code=200,
+            ok=True,
+            text="ok",
+            headers={},
+            json=lambda: {
+                "login_url": "https://remote.example/nodes/proxy/login/token",
+                "expires": "2025-01-01T00:00:00",
+            },
+        )
+
+        mock_post.side_effect = [redirect_response, success_response]
+
+        response = self.client.get(
+            reverse("admin:nodes_node_proxy", args=[remote.pk])
+        )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(mock_post.call_count, 2)
+
+        first_call_kwargs = mock_post.call_args_list[0].kwargs
+        self.assertFalse(first_call_kwargs.get("allow_redirects", True))
+
+        second_url = mock_post.call_args_list[1].args[0]
+        self.assertEqual(second_url, "https://remote.example/nodes/proxy/session/")
+        second_call_kwargs = mock_post.call_args_list[1].kwargs
+        self.assertFalse(second_call_kwargs.get("allow_redirects", True))
 
     def test_proxy_link_displayed_for_remote_nodes(self):
         Node.objects.create(
@@ -2629,6 +2677,32 @@ class NodeProxyGatewayTests(TestCase):
         second = self.client.get(parsed.path)
         self.assertEqual(second.status_code, 410)
 
+    def test_proxy_session_accepts_mac_hint_when_uuid_unknown(self):
+        payload = {
+            "requester": str(uuid.uuid4()),
+            "requester_mac": self.node.mac_address,
+            "requester_public_key": self.node.public_key,
+            "user": {
+                "username": "proxy-user",
+                "email": "proxy@example.com",
+                "first_name": "Proxy",
+                "last_name": "User",
+                "is_staff": True,
+                "is_superuser": True,
+                "groups": [],
+                "permissions": [],
+            },
+            "target": "/admin/",
+        }
+        body, signature = self._sign(payload)
+        response = self.client.post(
+            reverse("node-proxy-session"),
+            data=body,
+            content_type="application/json",
+            HTTP_X_SIGNATURE=signature,
+        )
+        self.assertEqual(response.status_code, 200)
+
     def test_proxy_execute_lists_nodes(self):
         Node.objects.create(
             hostname="target",