Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

39.4 KB
Raw Blame
"""Standalone tests for release artifact identity and source-run validation."""

# allow: no-sut-import — imports the standalone CI script directly.

import copy
import http.client
import importlib.util
import io
import json
import tarfile
import tempfile
import unittest
import unittest.mock
import urllib.error
import zipfile
from pathlib import Path

ROOT = Path(__file__).resolve().parents[3]
SPEC = importlib.util.spec_from_file_location(
    "release_package", ROOT / ".github/scripts/release_package.py"
)
POLICY = importlib.util.module_from_spec(SPEC)
SPEC.loader.exec_module(POLICY)
SHA = "a" * 40


class PackageTests(unittest.TestCase):
    def setUp(self):
        self.temp = tempfile.TemporaryDirectory()
        self.addCleanup(self.temp.cleanup)
        self.directory = Path(self.temp.name) / "dist"
        self.directory.mkdir()
        self.wheel = (
            self.directory / "local_deep_research-1.2.3-py3-none-any.whl"
        )
        self.sdist = self.directory / "local_deep_research-1.2.3.tar.gz"
        self.build()
        self.data = POLICY.manifest(self.directory, SHA, "123", "1")
        self.path = Path(self.temp.name) / "manifest.json"
        self.path.write_text(json.dumps(self.data))
        self.hash = POLICY.digest(self.path)

    def build(
        self, wheel_version="1.2.3", sdist_version="1.2.3", frontend=True
    ):
        with zipfile.ZipFile(self.wheel, "w") as archive:
            archive.writestr(
                "local_deep_research-1.2.3.dist-info/METADATA",
                f"Name: local-deep-research\nVersion: {wheel_version}\n",
            )
            if frontend:
                for name in (
                    ".vite/manifest.json",
                    "assets/app.js",
                    "assets/app.css",
                ):
                    archive.writestr(
                        "local_deep_research/web/static/dist/" + name, "{}"
                    )
        data = f"Name: local-deep-research\nVersion: {sdist_version}\n".encode()
        with tarfile.open(self.sdist, "w:gz") as archive:
            member = tarfile.TarInfo("local_deep_research-1.2.3/PKG-INFO")
            member.size = len(data)
            archive.addfile(member, io.BytesIO(data))

    def verify(self, **kwargs):
        args = dict(
            expected_hash=self.hash,
            sha=SHA,
            run_id="123",
            attempt="1",
            tag="v1.2.3",
        )
        args.update(kwargs)
        return POLICY.verify(self.directory, self.path, **args)

    def test_clean_artifact_and_rerun_preserved_attempt(self):
        self.assertEqual(self.verify(), self.data)
        self.assertEqual(self.verify(attempt=None), self.data)

    def test_changed_artifact_and_manifest_fail(self):
        with zipfile.ZipFile(self.wheel, "a") as archive:
            archive.writestr("changed.py", "value = 1")
        with self.assertRaisesRegex(ValueError, "hashes"):
            self.verify()
        self.path.write_text("{}")
        with self.assertRaisesRegex(ValueError, "digest"):
            self.verify()

    def test_identity_and_version_mismatch_fail(self):
        for args in (
            {"sha": "b" * 40},
            {"run_id": "124"},
            {"attempt": "2"},
            {"tag": "v9.9.9"},
            {"expected_hash": "0" * 64},
        ):
            with self.subTest(args=args), self.assertRaises(ValueError):
                self.verify(**args)

    def test_tag_matches_the_normalized_package_version(self):
        self.wheel.unlink()
        self.sdist.unlink()
        self.build(wheel_version="1.2.0rc1", sdist_version="1.2.0rc1")
        self.data = POLICY.manifest(self.directory, SHA, "123", "1")
        self.path.write_text(json.dumps(self.data))
        self.hash = POLICY.digest(self.path)
        for tag in ("v1.2.0-rc1", "v1.2.0rc1", "v1.2.0.RC1", "v1.2.0c1"):
            with self.subTest(tag=tag):
                self.assertEqual(self.verify(tag=tag), self.data)
        for tag in ("v1.2.0", "v1.2.0rc2", "1.2.0rc1", "v1.2.0-rc1-x"):
            with self.subTest(tag=tag), self.assertRaises(ValueError):
                self.verify(tag=tag)

    def test_version_normalization_matches_pep_440(self):
        cases = {
            "1.2.0-rc1": "1.2.0rc1",
            "1.2.0_RC_1": "1.2.0rc1",
            "1.0alpha": "1.0a0",
            "1.0-beta.2": "1.0b2",
            "1.0pre3": "1.0rc3",
            "01.02.03": "1.2.3",
            "1.0-1": "1.0.post1",
            "1.0.rev2": "1.0.post2",
            "1.0-dev": "1.0.dev0",
            "1.0rc1.post2.dev3": "1.0rc1.post2.dev3",
            "0!1.0": "1.0",
            "2!1.0+Local-01_x": "2!1.0+local.1.x",
            "v1.10.7": "1.10.7",
        }
        for raw, normal in cases.items():
            with self.subTest(raw=raw):
                self.assertEqual(POLICY.normalize_version(raw), normal)
        for raw in ("1.2.0-", "rc1", "1..2", "1.0+"):
            with self.subTest(raw=raw), self.assertRaises(ValueError):
                POLICY.normalize_version(raw)

    def test_distribution_set_and_links_fail(self):
        extra = self.directory / "extra.txt"
        extra.write_text("unexpected")
        with self.assertRaises(ValueError):
            self.verify()
        extra.unlink()
        self.sdist.unlink()
        self.sdist.symlink_to(self.wheel)
        with self.assertRaises(ValueError):
            self.verify()

    def test_frontend_and_matching_package_metadata_are_required(self):
        for args in ({"frontend": False}, {"sdist_version": "2.0.0"}):
            with self.subTest(args=args), self.assertRaises(ValueError):
                self.build(**args)
                POLICY.manifest(self.directory, SHA, "123", "1")

    def test_each_built_frontend_asset_is_required(self):
        prefix = "local_deep_research/web/static/dist/"
        for missing in (
            ".vite/manifest.json",
            "assets/app.js",
            "assets/app.css",
        ):
            self.build()
            with zipfile.ZipFile(self.wheel) as archive:
                entries = {
                    name: archive.read(name)
                    for name in archive.namelist()
                    if name != prefix + missing
                }
            with zipfile.ZipFile(self.wheel, "w") as archive:
                for name, data in entries.items():
                    archive.writestr(name, data)
            with (
                self.subTest(missing=missing),
                self.assertRaisesRegex(ValueError, "frontend"),
            ):
                POLICY.manifest(self.directory, SHA, "123", "1")

    def test_identifiers_reject_newlines_and_partial_values(self):
        for sha, run_id, attempt in (
            (SHA + "\n", "123", "1"),
            (SHA[:8], "123", "1"),
            (SHA, "../1", "1"),
            (SHA, "123", "0"),
        ):
            with (
                self.subTest(sha=sha, run_id=run_id, attempt=attempt),
                self.assertRaises(ValueError),
            ):
                POLICY.manifest(self.directory, sha, run_id, attempt)


class PublishedTests(unittest.TestCase):
    def test_existing_files_must_match_tested_hashes(self):
        expected = {"package.whl": "a" * 64, "package.tar.gz": "b" * 64}
        response = {
            "urls": [
                {"filename": name, "digests": {"sha256": value}}
                for name, value in expected.items()
            ]
        }
        POLICY.check_published_hashes(expected, response)
        response["urls"][0]["digests"]["sha256"] = "c" * 64
        with self.assertRaisesRegex(ValueError, "differ"):
            POLICY.check_published_hashes(expected, response)
        with self.assertRaises(ValueError):
            POLICY.check_published_hashes(expected, {"urls": []})


class PublishedRetryTests(unittest.TestCase):
    expected = {"package.whl": "a" * 64, "package.tar.gz": "b" * 64}

    def setUp(self):
        patcher = unittest.mock.patch.dict(
            "os.environ",
            {
                "PACKAGE_VERSION": "1.2.3",
                "EXPECTED_HASHES": json.dumps(self.expected),
            },
        )
        patcher.start()
        self.addCleanup(patcher.stop)
        self.sleeps = []

    def opener(self, responses):
        def open_url(url, timeout):
            self.assertEqual(
                url, "https://pypi.org/pypi/local-deep-research/1.2.3/json"
            )
            response = responses.pop(0)
            if isinstance(response, Exception):
                raise response
            return io.BytesIO(json.dumps(response).encode())

        return open_url

    def published(self, hashes):
        return {
            "urls": [
                {"filename": name, "digests": {"sha256": value}}
                for name, value in hashes.items()
            ]
        }

    def test_default_schedule_sleeps_610_seconds(self):
        self.assertEqual(sum(POLICY.PUBLISHED_RETRY_DELAYS), 610)

    def test_slow_index_is_retried_with_backoff(self):
        responses = [
            urllib.error.URLError("unavailable"),
            TimeoutError("read timed out"),
            {"urls": []},
            self.published(self.expected),
        ]
        POLICY.verify_published(
            (1, 2, 3, 4), self.opener(responses), self.sleeps.append
        )
        self.assertEqual(self.sleeps, [1, 2, 3])
        self.assertEqual(responses, [])

    def test_truncated_response_is_retried(self):
        responses = [
            http.client.IncompleteRead(b"{", 10),
            http.client.RemoteDisconnected("closed"),
            self.published(self.expected),
        ]
        POLICY.verify_published(
            (1, 2), self.opener(responses), self.sleeps.append
        )
        self.assertEqual(self.sleeps, [1, 2])
        self.assertEqual(responses, [])

    def test_truncated_response_fails_cleanly_after_the_schedule(self):
        responses = [http.client.IncompleteRead(b"{", 10)] * 2
        # main() calls verify_published() with its bound defaults.
        defaults = ((1,), self.opener(responses), self.sleeps.append)
        with (
            unittest.mock.patch.object(
                POLICY.verify_published, "__defaults__", defaults
            ),
            unittest.mock.patch(
                "sys.argv", ["release_package.py", "published"]
            ),
            unittest.mock.patch("sys.stdout", io.StringIO()) as stdout,
        ):
            self.assertEqual(POLICY.main(), 1)
        self.assertEqual(self.sleeps, [1])
        self.assertEqual(responses, [])
        self.assertIn(
            "::error::Release package verification failed", stdout.getvalue()
        )

    def test_present_file_with_other_hash_fails_immediately(self):
        # PyPI files are immutable (skip-existing may leave foreign bytes),
        # so retrying a real mismatch only burns monitor-pypi's budget.
        wrong = self.published({**self.expected, "package.whl": "c" * 64})
        responses = [urllib.error.URLError("unavailable"), wrong, wrong]
        with self.assertRaises(POLICY.PublishedHashMismatch):
            POLICY.verify_published(
                (1, 2, 3), self.opener(responses), self.sleeps.append
            )
        self.assertEqual(self.sleeps, [1])
        self.assertEqual(responses, [wrong])

    def test_missing_files_and_not_found_are_retried(self):
        partial = self.published({"package.whl": "a" * 64})
        not_found = urllib.error.HTTPError(
            "https://pypi.org", 404, "Not Found", {}, None
        )
        responses = [not_found, partial, self.published(self.expected)]
        POLICY.verify_published(
            (1, 2), self.opener(responses), self.sleeps.append
        )
        self.assertEqual(self.sleeps, [1, 2])

    def test_incomplete_file_set_fails_after_the_schedule(self):
        partial = self.published({"package.whl": "a" * 64})
        with self.assertRaisesRegex(ValueError, "exactly"):
            POLICY.verify_published(
                (1, 2), self.opener([partial] * 3), self.sleeps.append
            )
        self.assertEqual(self.sleeps, [1, 2])

    def test_unnormalized_version_queries_the_normal_form(self):
        urls = []

        def open_url(url, timeout):
            urls.append(url)
            return io.BytesIO(
                json.dumps(self.published(self.expected)).encode()
            )

        with unittest.mock.patch.dict(
            "os.environ", {"PACKAGE_VERSION": "1.2.3-rc1"}
        ):
            POLICY.verify_published((), open_url, self.sleeps.append)
        self.assertEqual(
            urls, ["https://pypi.org/pypi/local-deep-research/1.2.3rc1/json"]
        )


class SourceTests(unittest.TestCase):
    def setUp(self):
        self.payload = {
            "sha": SHA,
            "run_id": "123",
            "artifact_id": "456",
            "manifest_sha256": "b" * 64,
            "tag": "v1.2.3",
        }
        self.run = {
            "repository": {"full_name": "owner/repo"},
            "path": ".github/workflows/release.yml",
            "head_sha": SHA,
            "event": "push",
            "head_branch": "main",
            "status": "in_progress",
            "run_attempt": 1,
        }
        self.jobs = [
            {
                "id": i,
                "name": name,
                "status": "completed",
                "conclusion": "success",
                "run_attempt": 1,
                **self.execution(i),
            }
            for i, name in enumerate(
                (
                    "release-gate / Release Gate Summary",
                    "build",
                    "release-gate / pip Install Verification",
                    "release-gate / Package install (3.13, wheel)",
                    "release-gate / Package install (3.14, wheel)",
                    "release-gate / Package install (3.12, sdist)",
                ),
                1,
            )
        ]
        self.artifact = {
            "id": 456,
            "name": "verified-python-dist-1",
            "expired": False,
            "workflow_run": {"id": 123, "head_sha": SHA},
        }
        self.decision_artifact = {
            "expired": False,
            "workflow_run": {"id": 123, "head_sha": SHA},
        }
        self.select_decision(1)
        self.run_artifacts = [{"name": "verified-python-dist-1"}]
        self.ancestry = "ahead"
        self.calls = []

    @staticmethod
    def execution(runner):
        """A job record's execution fields; distinct per runner."""
        return {
            "started_at": f"2026-08-07T23:{runner:02d}:00Z",
            "completed_at": f"2026-08-07T23:{runner:02d}:30Z",
            "runner_id": 1000418800 + runner,
            "runner_name": f"GitHub Actions {1000418800 + runner}",
        }

    def fetch(self, endpoint):
        self.calls.append(endpoint)
        if "/jobs?" in endpoint:
            page = int(endpoint.rsplit("page=", 1)[1])
            return {"jobs": self.jobs[(page - 1) * 100 : page * 100]}
        if "/artifacts?" in endpoint:
            return {"artifacts": self.run_artifacts}
        if endpoint.endswith(
            f"/artifacts/{self.payload['release_decision_artifact_id']}"
        ):
            return self.decision_artifact
        if "/artifacts/" in endpoint:
            return self.artifact
        if "/compare/" in endpoint:
            return {"status": self.ancestry}
        return self.run

    def validate(self):
        return POLICY.validate_source("owner/repo", self.payload, self.fetch)

    def select_decision(self, attempt):
        self.decision_artifact.update(
            id=788 + attempt, name=f"release-security-decision-{attempt}"
        )
        self.payload["release_decision_artifact_id"] = str(788 + attempt)

    def rerun(self, *names, attempt=2):
        """Model a GitHub rerun: named jobs run again on new runners; every
        other job is carried into the new attempt as a new record that keeps
        its original runner and timestamps (as observed in release run
        31226451323 and publish run 23679807987)."""
        self.run["run_attempt"] = attempt
        previous = {job["name"]: job for job in self.jobs}
        carried = [name for name in previous if name not in names]
        for name in carried + list(names):
            fresh = {}
            if name in names:
                fresh = {
                    "status": "completed",
                    "conclusion": "success",
                    **self.execution(len(self.jobs) + 1),
                }
            self.jobs.append(
                {
                    **previous[name],
                    "id": max(job["id"] for job in self.jobs) + 1,
                    "run_attempt": attempt,
                    **fresh,
                }
            )

    def test_in_progress_release_with_successful_gates_is_valid(self):
        self.assertEqual(self.validate(), "1")
        self.assertTrue(
            any("/artifacts/456" in endpoint for endpoint in self.calls)
        )

    def test_full_rerun_rejects_the_superseded_artifact(self):
        self.rerun(*(job["name"] for job in self.jobs))
        with self.assertRaises(ValueError):
            self.validate()
        self.artifact["name"] = "verified-python-dist-2"
        self.run_artifacts.append({"name": "verified-python-dist-2"})
        self.select_decision(2)
        self.assertEqual(self.validate(), "2")

    def test_rerun_failed_jobs_keeps_the_carried_over_package_build(self):
        # Only the failed downstream job runs again; GitHub copies the
        # successful package build into attempt 2 with run_attempt 2 but
        # uploads no new artifact.
        self.jobs[1]["conclusion"] = "failure"
        self.rerun("build")
        self.select_decision(2)
        self.assertTrue(
            any(
                job["name"] == "release-gate / pip Install Verification"
                and job["run_attempt"] == 2
                for job in self.jobs
            )
        )
        self.assertEqual(self.validate(), "1")
        # A copy cannot vouch for an artifact its attempt never built.
        self.artifact["name"] = "verified-python-dist-2"
        with self.assertRaises(ValueError):
            self.validate()

    def test_full_rerun_before_the_package_job_is_listed_rejects(self):
        # The jobs API omits jobs still waiting on ``needs`` (release run
        # 37041154628 listed 3 jobs while its dependants were pending), so
        # right after "Re-run all jobs" only attempt-1 records are visible.
        self.run["run_attempt"] = 2
        with self.assertRaises(ValueError) as caught:
            self.validate()
        self.assertIn("current source run attempt", str(caught.exception))
        # Once the new package record is listed it must still rebuild.
        self.rerun("release-gate / pip Install Verification")
        with self.assertRaises(ValueError):
            self.validate()

    def test_rerun_failed_jobs_with_a_carried_package_copy_is_valid(self):
        # "Re-run failed jobs" lists the carried copies at the start of the
        # new attempt, so the package job has a current-attempt record.
        self.jobs[0]["conclusion"] = "failure"
        self.rerun("release-gate / Release Gate Summary", attempt=2)
        self.assertEqual(self.validate(), "1")
        self.rerun("release-gate / Release Gate Summary", attempt=3)
        self.assertEqual(self.validate(), "1")

    def test_real_rerun_failed_jobs_records_are_carried_over(self):
        # Job records from release.yml run 31226451323, whose attempt 2
        # re-ran failed jobs only (GET runs/31226451323/jobs?filter=all).
        def record(job_id, attempt, name, started, completed, runner):
            return {
                "id": job_id,
                "name": f"release-gate / {name}",
                "status": "completed",
                "conclusion": "success",
                "run_attempt": attempt,
                "started_at": started,
                "completed_at": completed,
                "runner_id": runner,
                "runner_name": f"GitHub Actions {runner}",
            }

        pip = ("pip Install Verification", "2026-08-07T23:38:50Z")
        pip += ("2026-08-07T23:42:10Z", 1000418864)
        gate = ("Release Gate Summary", "2026-08-08T00:09:32Z")
        gate += ("2026-08-08T00:09:42Z", 1000418969)
        real = [
            record(93023115290, 1, *pip),
            record(93029267734, 1, *gate),
            record(93059343189, 2, *pip),
            record(93059344806, 2, *gate),
        ]
        self.jobs = [
            job
            for job in self.jobs
            if job["name"]
            not in {
                "release-gate / pip Install Verification",
                "release-gate / Release Gate Summary",
            }
        ] + real
        # Attempt 2 also listed a new build record (93060201602) because build
        # depends on the re-run jobs. That run skipped build again; here it
        # succeeds and records its own decision.
        build = next(job for job in self.jobs if job["name"] == "build")
        self.jobs.append(
            {**build, "id": 93060201602, "run_attempt": 2, **self.execution(7)}
        )
        self.select_decision(2)
        self.run["run_attempt"] = 2
        self.assertEqual(self.validate(), "1")
        self.assertEqual(
            POLICY.executed_attempt(real[2], real[::2]),
            1,
        )

    def test_rebuild_on_the_same_name_with_new_execution_supersedes(self):
        for field, value in (
            ("started_at", "2026-08-08T04:50:37Z"),
            ("completed_at", "2026-08-08T04:54:00Z"),
            ("runner_id", 1000419999),
            ("runner_name", "GitHub Actions 1000419999"),
        ):
            self.setUp()
            self.rerun()
            pip = next(
                job
                for job in reversed(self.jobs)
                if job["name"] == "release-gate / pip Install Verification"
            )
            pip[field] = value
            with self.subTest(field=field), self.assertRaises(ValueError):
                self.validate()

    def test_carried_copy_without_execution_metadata_fails_closed(self):
        for field in ("started_at", "completed_at", "runner_id", "runner_name"):
            for value in (None, "", True):
                self.setUp()
                self.rerun()
                for job in self.jobs:
                    if job["name"] == "release-gate / pip Install Verification":
                        job[field] = value
                with (
                    self.subTest(field=field, value=value),
                    self.assertRaises(ValueError),
                ):
                    self.validate()

    def test_newer_package_artifact_in_the_run_rejects_the_old_one(self):
        for name in ("verified-python-dist-2", "verified-python-dist-10"):
            self.run_artifacts = [
                {"name": "verified-python-dist-1"},
                {"name": "python-dist-7"},
                {"name": name},
            ]
            with self.subTest(name=name), self.assertRaises(ValueError):
                self.validate()
        self.run_artifacts = [{"name": "python-dist-7"}]
        self.assertEqual(self.validate(), "1")

    def test_newer_package_artifact_on_a_later_page_rejects(self):
        self.run_artifacts = [{"name": f"sbom-{i}"} for i in range(100)]

        def fetch(endpoint):
            if "/artifacts?" in endpoint and endpoint.endswith("page=2"):
                return {"artifacts": [{"name": "verified-python-dist-2"}]}
            return self.fetch(endpoint)

        with self.assertRaises(ValueError):
            POLICY.validate_source("owner/repo", self.payload, fetch)

    def test_publish_recheck_rejects_a_changed_package_build(self):
        real = POLICY.validate_source

        def validate(repo, payload, **kwargs):
            return real(repo, payload, self.fetch, **kwargs)

        with tempfile.TemporaryDirectory() as directory:
            event = Path(directory, "event.json")
            event.write_text(
                json.dumps({"client_payload": self.payload}), encoding="utf-8"
            )
            output = Path(directory, "output")
            output.touch()
            for expected, result in ((None, 0), ("1", 0), ("2", 1)):
                env = {
                    "GITHUB_EVENT_PATH": str(event),
                    "GITHUB_OUTPUT": str(output),
                    "GITHUB_REPOSITORY": "owner/repo",
                }
                if expected is not None:
                    env["EXPECTED_ARTIFACT_ATTEMPT"] = expected
                with (
                    self.subTest(expected=expected),
                    unittest.mock.patch.dict("os.environ", env),
                    unittest.mock.patch.object(
                        POLICY, "validate_source", validate
                    ),
                    unittest.mock.patch(
                        "sys.argv", ["release_package", "source"]
                    ),
                    unittest.mock.patch("sys.stdout", io.StringIO()),
                ):
                    self.assertEqual(POLICY.main(), result)

    def test_publish_retry_rechecks_cached_dispatch_after_source_rebuild(self):
        """A publish-only retry retains its dispatch and verified attempt,
        but must reject those outputs once the source rebuilds the package."""
        cached_attempt = self.validate()
        names = tuple(dict.fromkeys(job["name"] for job in self.jobs))
        real = POLICY.validate_source

        def validate(repo, payload, **kwargs):
            return real(repo, payload, self.fetch, **kwargs)

        with tempfile.TemporaryDirectory() as directory:
            event = Path(directory, "event.json")
            event.write_text(
                json.dumps({"client_payload": self.payload}), encoding="utf-8"
            )
            output = Path(directory, "output")
            env = {
                "GITHUB_EVENT_PATH": str(event),
                "GITHUB_OUTPUT": str(output),
                "GITHUB_REPOSITORY": "owner/repo",
                "EXPECTED_ARTIFACT_ATTEMPT": cached_attempt,
            }
            phases = (
                ("original", (), None, 0, None),
                ("carried-over jobs", (), 2, 0, None),
                (
                    "rebuilt release decision",
                    ("build",),
                    3,
                    1,
                    "Security decision is not from the latest successful release build",
                ),
                (
                    "rebuilt package",
                    names,
                    4,
                    1,
                    "Artifact is not from the latest successful package build",
                ),
            )
            for phase, rerun, attempt, result, error in phases:
                if attempt is not None:
                    self.rerun(*rerun, attempt=attempt)
                output.write_text("", encoding="utf-8")
                log = io.StringIO()
                with (
                    self.subTest(phase=phase),
                    unittest.mock.patch.dict("os.environ", env),
                    unittest.mock.patch.object(
                        POLICY, "validate_source", validate
                    ),
                    unittest.mock.patch(
                        "sys.argv", ["release_package", "source"]
                    ),
                    unittest.mock.patch("sys.stdout", log),
                ):
                    self.assertEqual(POLICY.main(), result)
                    if result:
                        self.assertEqual(output.read_text(), "")
                        self.assertIn(error, log.getvalue())
                    else:
                        self.assertEqual(
                            output.read_text(), "artifact_attempt=1\n"
                        )

    def test_partial_reruns_preserve_the_package_build_attempt(self):
        self.rerun("release-gate / Release Gate Summary", "build")
        self.select_decision(2)
        self.assertEqual(self.validate(), "1")
        self.rerun(
            "release-gate / Package install (3.13, wheel)",
            "release-gate / Release Gate Summary",
            "build",
            attempt=3,
        )
        self.select_decision(3)
        self.assertEqual(self.validate(), "1")

    def test_rebuilt_package_requires_fresh_install_and_release_gates(self):
        self.run["run_attempt"] = 2
        self.artifact["name"] = "verified-python-dist-2"
        self.select_decision(2)
        for job in self.jobs:
            job["run_attempt"] = 2
        for job in self.jobs:
            if job["name"] == "release-gate / pip Install Verification":
                continue
            job["run_attempt"] = 1
            with self.subTest(name=job["name"]), self.assertRaises(ValueError):
                self.validate()
            job["run_attempt"] = 2
        self.assertEqual(self.validate(), "2")

    def test_failed_pending_and_missing_package_checks_reject(self):
        original = copy.deepcopy(self.jobs)
        for name in (job["name"] for job in original[2:]):
            for state in ("failure", None, "missing"):
                self.jobs = copy.deepcopy(original)
                if state == "missing":
                    self.jobs = [j for j in self.jobs if j["name"] != name]
                else:
                    job = next(j for j in self.jobs if j["name"] == name)
                    job["conclusion"] = state
                    if state is None:
                        job["status"] = "in_progress"
                with (
                    self.subTest(name=name, state=state),
                    self.assertRaises(ValueError),
                ):
                    self.validate()

    def test_failed_rebuild_cannot_reuse_an_older_success(self):
        self.rerun("release-gate / pip Install Verification")
        self.jobs[-1]["conclusion"] = "failure"
        with self.assertRaises(ValueError):
            self.validate()

    def test_invalid_or_future_attempt_metadata_rejects(self):
        for target in (self.run, *self.jobs):
            for attempt in (None, 0, -1, "1\n", True):
                target["run_attempt"] = attempt
                with (
                    self.subTest(name=target.get("name"), attempt=attempt),
                    self.assertRaises(ValueError),
                ):
                    self.validate()
            target["run_attempt"] = 1
        for job in self.jobs:
            job["run_attempt"] = 2
            with self.subTest(name=job["name"]), self.assertRaises(ValueError):
                self.validate()
            job["run_attempt"] = 1
        self.artifact["name"] = "verified-python-dist-2"
        with self.assertRaises(ValueError):
            self.validate()

    def paginate_jobs(self, page_one):
        """Pad the job list so its first ``page_one`` records end page 1 of
        the jobs API (100 per page) and the rest land on page 2, as in
        release run 31226451323 (180 job records); IDs follow list order."""
        self.jobs[page_one:page_one] = [
            {"name": f"unrelated-{i}", "status": "completed"}
            for i in range(100 - page_one)
        ]
        for job_id, job in enumerate(self.jobs, 1):
            job["id"] = job_id
        self.assertGreater(len(self.jobs), 100)

    def test_failed_rerun_on_a_later_job_page_rejects(self):
        # Re-running the summary carries the package job into attempt 2 on
        # page 1; the fresh summary record, which failed, is on page 2.
        self.rerun("release-gate / Release Gate Summary")
        self.jobs[-1]["conclusion"] = "failure"
        self.paginate_jobs(len(self.jobs) - 1)
        page_one = self.fetch(
            "repos/owner/repo/actions/runs/123/jobs?filter=all&page=1"
        )["jobs"]
        self.assertTrue(
            any(
                job["name"] == "release-gate / pip Install Verification"
                and job["run_attempt"] == 2
                for job in page_one
            )
        )
        with self.assertRaises(ValueError) as caught:
            self.validate()
        self.assertIn("Release Gate Summary", str(caught.exception))
        self.jobs[-1]["conclusion"] = "success"
        self.assertEqual(self.validate(), "1")

    def test_newer_build_on_later_job_page_supersedes_the_old_artifact(self):
        # A full rerun's fresh records, including the rebuilt package job,
        # are all on page 2; page 1 holds only attempt 1.
        attempt_one = len(self.jobs)
        self.rerun(*(job["name"] for job in self.jobs))
        self.paginate_jobs(attempt_one)
        with self.assertRaises(ValueError):
            self.validate()
        self.artifact["name"] = "verified-python-dist-2"
        self.run_artifacts.append({"name": "verified-python-dist-2"})
        self.select_decision(2)
        self.assertEqual(self.validate(), "2")

    def test_same_run_older_decision_cannot_authorize_a_rebuilt_package(self):
        self.rerun(*(job["name"] for job in self.jobs))
        self.artifact["name"] = "verified-python-dist-2"
        self.run_artifacts.append({"name": "verified-python-dist-2"})
        with self.assertRaisesRegex(
            ValueError, "latest successful release build"
        ):
            self.validate()
        self.select_decision(2)
        self.assertEqual(self.validate(), "2")

    def test_publish_recheck_rejects_new_build_with_unchanged_package(self):
        original_attempt = self.validate()
        self.rerun("release-gate / Release Gate Summary", "build")
        # The cached dispatch still selects decision 1, although a new build
        # has recorded decision 2. Package-only validation would accept it.
        with self.assertRaisesRegex(
            ValueError, "latest successful release build"
        ):
            POLICY.validate_source(
                "owner/repo",
                self.payload,
                self.fetch,
                expected_attempt=original_attempt,
            )
        self.select_decision(2)
        self.assertEqual(
            POLICY.validate_source(
                "owner/repo",
                self.payload,
                self.fetch,
                expected_attempt=original_attempt,
            ),
            "1",
        )

    def test_pending_build_rerun_cannot_reuse_the_previous_decision(self):
        # Re-running a job that build depends on, such as the alert check
        # that recomputes the deadline, re-runs the summary and build too.
        # The jobs API omits them while they wait on ``needs``, so attempt 2
        # lists only the carried package jobs at first, and then the summary
        # without build. The cached dispatch's decision 1 must not pass the
        # pre-approval check or the post-approval recheck in either state.
        original_attempt = self.validate()
        self.rerun("release-gate / Release Gate Summary", "build")
        summary, build = self.jobs[-2:]
        self.assertEqual(
            [summary["name"], build["name"], build["run_attempt"]],
            ["release-gate / Release Gate Summary", "build", 2],
        )
        listed = self.jobs[:-2]
        for phase, jobs in (
            ("summary and build waiting", listed),
            ("build waiting", [*listed, summary]),
        ):
            self.jobs = jobs
            for expected in (None, original_attempt):
                with (
                    self.subTest(phase=phase, expected=expected),
                    self.assertRaisesRegex(
                        ValueError,
                        "Build job has no record in the current source run",
                    ),
                ):
                    POLICY.validate_source(
                        "owner/repo",
                        self.payload,
                        self.fetch,
                        expected_attempt=expected,
                    )
        # Once the new build has run, only the decision it recorded counts.
        self.jobs = [*listed, summary, build]
        with self.assertRaisesRegex(
            ValueError, "latest successful release build"
        ):
            self.validate()
        self.select_decision(2)
        self.assertEqual(self.validate(), "1")

    def test_carried_build_keeps_its_original_decision_across_later_attempts(
        self,
    ):
        self.rerun()
        self.rerun(attempt=3)
        self.assertEqual(self.validate(), "1")
        self.assertEqual(
            self.decision_artifact["name"], "release-security-decision-1"
        )

    def test_invalid_decision_id_fails_before_api(self):
        for value in (None, "", "none", "0", "789\n", True):
            with self.subTest(value=value):
                self.payload["release_decision_artifact_id"] = value
                with self.assertRaises(ValueError):
                    self.validate()
                self.assertEqual(self.calls, [])
        del self.payload["release_decision_artifact_id"]
        with self.assertRaises(ValueError):
            self.validate()
        self.assertEqual(self.calls, [])

    def test_decision_ownership_expiry_and_build_attempt_are_required(self):
        original = copy.deepcopy(self.decision_artifact)
        for changes in (
            {"expired": True},
            {"id": 999},
            {"name": "release-security-decision-2"},
            {"name": "verified-python-dist-1"},
            {"workflow_run": {"id": 124, "head_sha": SHA}},
            {"workflow_run": {"id": 123, "head_sha": "c" * 40}},
        ):
            self.decision_artifact = {**original, **changes}
            with self.subTest(changes=changes), self.assertRaises(ValueError):
                self.validate()

    def test_wrong_workflow_commit_event_and_repository_fail(self):
        original = copy.deepcopy(self.run)
        for changes in (
            {"path": ".github/workflows/other.yml"},
            {"head_sha": "c" * 40},
            {"event": "pull_request"},
            {"repository": {"full_name": "another/repo"}},
            {"head_branch": "feature"},
            {"head_branch": "v9.9.9"},
            {"head_branch": None},
        ):
            self.run = {**original, **changes}
            with self.subTest(changes=changes), self.assertRaises(ValueError):
                self.validate()

    def test_main_and_release_tag_sources_are_valid(self):
        for head_branch in ("main", "v1.2.3"):
            self.run = {**self.run, "head_branch": head_branch}
            with self.subTest(head_branch=head_branch):
                self.assertEqual(self.validate(), "1")

    def test_failed_skipped_missing_and_superseded_gates_fail(self):
        original = copy.deepcopy(self.jobs)
        for state in ("failure", "skipped", "cancelled", None):
            self.jobs = copy.deepcopy(original)
            self.jobs[0]["conclusion"] = state
            with self.subTest(state=state), self.assertRaises(ValueError):
                self.validate()
        self.jobs = []
        with self.assertRaises(ValueError):
            self.validate()
        self.jobs = original + [
            {**original[0], "id": 999, "conclusion": "failure"}
        ]
        with self.assertRaises(ValueError):
            self.validate()

    def test_artifact_ownership_and_expiration_are_required(self):
        original = copy.deepcopy(self.artifact)
        for changes in (
            {"expired": True},
            {"id": 789},
            {"name": "python-dist"},
            {"workflow_run": {"id": 789, "head_sha": SHA}},
            {"workflow_run": {"id": 123, "head_sha": "c" * 40}},
        ):
            self.artifact = {**original, **changes}
            with self.subTest(changes=changes), self.assertRaises(ValueError):
                self.validate()

    def test_unreviewed_commit_and_incomplete_payload_fail(self):
        self.ancestry = "diverged"
        with self.assertRaises(ValueError):
            self.validate()
        self.payload["sha"] += "\n"
        with self.assertRaises(ValueError):
            self.validate()


if __name__ == "__main__":
    unittest.main()