compforge-repokit 0.17.1__tar.gz → 0.17.2__tar.gz

{compforge_repokit-0.17.1 → compforge_repokit-0.17.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: compforge-repokit
-Version: 0.17.1
+Version: 0.17.2
 Summary: Native repository inspection, content identity, Git and Forge operations
 Requires-Python: >=3.11
 Requires-Dist: harness-common<0.7,>=0.6

{compforge_repokit-0.17.1 → compforge_repokit-0.17.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "compforge-repokit"
-version = "0.17.1"
+version = "0.17.2"
 description = "Native repository inspection, content identity, Git and Forge operations"
 readme = "README.md"
 requires-python = ">=3.11"

{compforge_repokit-0.17.1 → compforge_repokit-0.17.2}/repokit/forge/connection.py

@@ -41,12 +41,13 @@ class ForgeConnection:
     timeout: int = 10
 
     def __post_init__(self) -> None:
+        object.__setattr__(self, "host", self.host.lower())
         if not self.host or self.timeout <= 0:
             raise ValueError("Forge host and positive timeout are required")
         if not self.token.strip():
             raise ForgeAuthError(f"PR query unavailable: no credential for {self.host}")
         object.__setattr__(self, "provider", detect_provider(self.host, self.provider))
-        object.__setattr__(self, "api_host", self.api_host or self.host)
+        object.__setattr__(self, "api_host", (self.api_host or self.host).lower())
         object.__setattr__(self, "state_dir", Path(self.state_dir))
 
     @property
@@ -76,6 +77,7 @@ class ForgeConnection:
                 owner,
                 name,
                 self.token,
+                forge=self.name,
                 timeout=self.timeout,
                 state_dir=self.state_dir / "forge-http",
             )
@@ -83,6 +85,7 @@ class ForgeConnection:
             self.api_host or self.host,
             path,
             self.token,
+            forge=self.name,
             timeout=self.timeout,
             state_dir=self.state_dir / "forge-http",
         )

{compforge_repokit-0.17.1 → compforge_repokit-0.17.2}/repokit/forge/github.py

@@ -40,9 +40,14 @@ class GitHubForge(Forge):
         name: str,
         token: str,
         *,
+        forge: str | None = None,
         timeout: int = 10,
         state_dir: str | Path | None = None,
     ):
+        host = host.lower()
+        self.forge = ForgeIdentity(
+            forge if forge is not None else ("github" if host == "github.com" else host)
+        )
         # github.com → api.github.com; GitHub Enterprise → https://<host>/api/v3
         api = "https://api.github.com" if host == "github.com" else f"https://{host}/api/v3"
         graphql_api = (
@@ -68,7 +73,7 @@ class GitHubForge(Forge):
     def list_repositories(
         self, *, page_size: int | None = None, cursor: str | None = None
     ) -> Page[Repository]:
-        scope = f"github:{self.host}:repositories"
+        scope = f"github:{self.forge.name}:{self.host}:repositories"
         page, size = page_position(scope, page_size, cursor)
         rows = self._instance.get(
             "user/repos", sort="full_name", direction="asc", per_page=size, page=page
@@ -86,18 +91,14 @@ class GitHubForge(Forge):
                 or any(p in ("", ".", "..") for p in path.split("/"))
             ):
                 raise ForgeError("Invalid GitHub repository full_name")
-            items.append(
-                Repository(
-                    ForgeIdentity("github" if self.host == "github.com" else self.host), path
-                )
-            )
+            items.append(Repository(self.forge, path))
         return Page(tuple(items), page_continuation(scope, page, size, len(rows) >= size))
 
     def repository(self) -> Repository:
         data = self.c.get("")
         parent = (data.get("parent") or {}).get("full_name") or None
         return Repository(
-            ForgeIdentity("github" if self.host == "github.com" else self.host),
+            self.forge,
             data["full_name"],
             forked_from=parent,
         )
@@ -111,12 +112,13 @@ class GitHubForge(Forge):
             owner,
             name,
             self._token,
+            forge=self.forge.name,
             timeout=self.timeout,
             state_dir=self.state_dir,
         )
 
     def _repository_client(self, repository: Repository) -> GitHubForge:
-        forge = ForgeIdentity("github" if self.host == "github.com" else self.host)
+        forge = self.forge
         if repository.forge != forge:
             raise ValueError(
                 f"repository {repository.id()!r} does not belong to Forge {forge.name!r}"

{compforge_repokit-0.17.1 → compforge_repokit-0.17.2}/repokit/forge/gitlab.py

@@ -55,9 +55,14 @@ class GitLabForge(Forge):
         path: str,
         token: str,
         *,
+        forge: str | None = None,
         timeout: int = 10,
         state_dir: str | Path | None = None,
     ):
+        host = host.lower()
+        self.forge = ForgeIdentity(
+            forge if forge is not None else ("gitlab" if host == "gitlab.com" else host)
+        )
         self.host, self.path, self._token, self.timeout = host, path, token, timeout
         self.state_dir = state_dir
         enc = urllib.parse.quote(path, safe="")
@@ -77,7 +82,7 @@ class GitLabForge(Forge):
     def list_repositories(
         self, *, page_size: int | None = None, cursor: str | None = None
     ) -> Page[Repository]:
-        scope = f"gitlab:{self.host}:repositories"
+        scope = f"gitlab:{self.forge.name}:{self.host}:repositories"
         page, size = page_position(scope, page_size, cursor)
         rows = self._instance.get(
             "projects",
@@ -97,18 +102,14 @@ class GitLabForge(Forge):
             path = row.get("path_with_namespace") if isinstance(row, dict) else None
             if not isinstance(path, str) or any(p in ("", ".", "..") for p in path.split("/")):
                 raise ForgeError("Invalid GitLab repository path_with_namespace")
-            items.append(
-                Repository(
-                    ForgeIdentity("gitlab" if self.host == "gitlab.com" else self.host), path
-                )
-            )
+            items.append(Repository(self.forge, path))
         return Page(tuple(items), page_continuation(scope, page, size, len(rows) >= size))
 
     def repository(self) -> Repository:
         data = self.c.get("")
         parent = (data.get("forked_from_project") or {}).get("path_with_namespace") or None
         return Repository(
-            ForgeIdentity("gitlab" if self.host == "gitlab.com" else self.host),
+            self.forge,
             data["path_with_namespace"],
             forked_from=parent,
         )
@@ -117,11 +118,16 @@ class GitLabForge(Forge):
         if not path or ":" in path or path.startswith("/"):
             raise ValueError(f"invalid GitLab repository path: {path!r}")
         return GitLabForge(
-            self.host, path, self._token, timeout=self.timeout, state_dir=self.state_dir
+            self.host,
+            path,
+            self._token,
+            forge=self.forge.name,
+            timeout=self.timeout,
+            state_dir=self.state_dir,
         )
 
     def _repository_client(self, repository: Repository) -> GitLabForge:
-        forge = ForgeIdentity("gitlab" if self.host == "gitlab.com" else self.host)
+        forge = self.forge
         if repository.forge != forge:
             raise ValueError(
                 f"repository {repository.id()!r} does not belong to Forge {forge.name!r}"

{compforge_repokit-0.17.1 → compforge_repokit-0.17.2}/repokit/validation/report.py

@@ -37,12 +37,16 @@ def _decode(payload: str, repo: str, checks: Iterable[str]) -> dict[str, Any]:
         data.get("diagnostics"), list
     ):
         raise ValueError("ValidationReport results missing")
-    selected = set(checks) - {"format"}
+    requested = set(checks)
+    selected = requested - {"format"}
     if not selected <= {"lint", "test"}:
         raise ValueError("invalid requested validation checks")
     seen: set[tuple[str, str]] = set()
     coverage: dict[str, set[str]] = {}
+    statuses: list[str] = []
     for group in data["components"]:
+        if not isinstance(group["checks"], list) or not group["checks"]:
+            raise ValueError("ValidationReport omitted requested checks in Component")
         root = group["component"]["root"]
         if not isinstance(root, str) or not (Path(repo) / root).resolve().is_relative_to(
             Path(repo).resolve()
@@ -73,6 +77,7 @@ def _decode(payload: str, repo: str, checks: Iterable[str]) -> dict[str, Any]:
                 "status"
             ] not in {"passed", "failed", "skipped", "unavailable", "cancelled", "uncertain"}:
                 raise ValueError("invalid validation check status or scope")
+            statuses.append(check["status"])
             if type(check["reused"]) is not bool or not isinstance(check["witnesses"], dict):
                 raise ValueError("invalid validation evidence")
             if any(
@@ -96,4 +101,55 @@ def _decode(payload: str, repo: str, checks: Iterable[str]) -> dict[str, Any]:
                 raise ValueError("invalid validation command or file list")
     if any(checks != selected for checks in coverage.values()):
         raise ValueError("ValidationReport omitted requested checks")
+    preparation = data.get("preparation", [])
+    if not isinstance(preparation, list):
+        raise ValueError("invalid ValidationReport preparation")
+    prepared: list[str] = []
+    for group in preparation:
+        if (
+            "format" not in requested
+            or not isinstance(group["checks"], list)
+            or not group["checks"]
+        ):
+            raise ValueError("invalid ValidationReport preparation checks")
+        for check in group["checks"]:
+            if check["check"] != "format" or check["status"] not in {
+                "passed",
+                "failed",
+                "skipped",
+                "unavailable",
+                "cancelled",
+                "uncertain",
+            }:
+                raise ValueError("invalid ValidationReport preparation status")
+            prepared.append(check["status"])
+    if data["components"] and any(
+        status in {"failed", "cancelled", "uncertain"} for status in prepared
+    ):
+        raise ValueError("ValidationReport checks follow unsuccessful preparation")
+    # ExecuteValidation can reject a stale plan before producing any check results.
+    if (
+        not data["components"]
+        and not data["complete"]
+        and not data["passed"]
+        and not data["inputsConsistent"]
+    ):
+        return cast(dict[str, Any], data)
+    # Format can stop before lint/test; its resulting snapshot is not validation evidence.
+    preparation_only = (
+        not data["components"]
+        and "format" in requested
+        and (not selected or not data["complete"] or any(status == "failed" for status in prepared))
+    )
+    outcomes = prepared if preparation_only else statuses
+    complete = all(status in {"passed", "failed", "skipped", "unavailable"} for status in outcomes)
+    passed = all(status in {"passed", "skipped"} for status in outcomes)
+    if not preparation_only:
+        passed = passed and data["inputsConsistent"]
+        if data["complete"] != complete or data["passed"] != passed:
+            raise ValueError("ValidationReport outcome contradicts check results")
+    elif (data["complete"] and not complete) or (
+        data["passed"] and (not passed or not data["complete"])
+    ):
+        raise ValueError("ValidationReport outcome contradicts preparation results")
     return cast(dict[str, Any], data)

compforge_repokit-0.17.2/tests/test_forge_connection.py

@@ -0,0 +1,99 @@
+import json
+from pathlib import Path
+
+import pytest
+
+from repokit.forge import ForgeConnection, detect_provider
+from repokit.forge.model import ForgeAuthError
+
+
+def test_connection_identity_and_context_are_shared_with_typescript(repo, tmp_path):
+    """@case Credentials, provider and endpoint isolate caches; targets stay explicit."""
+    fixture = Path(__file__).resolve().parents[3] / "conformance/forge-connection.json"
+    for row in json.loads(fixture.read_text()):
+        connection = ForgeConnection(
+            host=row["host"],
+            provider=row["provider"],
+            api_host=row["apiHost"],
+            token=row["token"],
+            state_dir=tmp_path,
+        )
+        assert connection.name == row["name"]
+        assert connection.identity == row["identity"]
+        assert row["token"] not in repr(connection)
+        context = connection.pull_request_context(repo, source="owner/repo")
+        assert context.source == connection.repository("owner/repo")
+        assert context.targets == (context.source,)
+        assert context.observer.store.root == tmp_path
+        assert context.observer.reader.state_dir == tmp_path / "forge-http"
+        explicit = connection.pull_request_context(
+            repo, source="owner/repo", targets=("upstream/repo",)
+        )
+        assert explicit.targets == (connection.repository("upstream/repo"),)
+        with pytest.raises(ValueError):
+            connection.pull_request_context(repo, source="owner/repo", targets=())
+
+
+def test_access_configuration_requires_credentials_and_valid_timeout():
+    assert detect_provider("github.example") == "github"
+    assert detect_provider("forge.example", "github") == "github"
+    assert detect_provider("forge.example") == "gitlab"
+    with pytest.raises(ForgeAuthError):
+        ForgeConnection("github.com", " ")
+    with pytest.raises(ValueError):
+        ForgeConnection("github.com", "fixture", timeout=0)
+
+
+@pytest.mark.parametrize("provider", ["github", "gitlab"])
+def test_endpoint_override_preserves_identity_across_repository_queries(
+    tmp_path, monkeypatch, provider
+):
+    """@case Logical Forge identity survives endpoint overrides and nested repository clients."""
+    from repokit.forge._rest import RestClient
+
+    connection = ForgeConnection(
+        "Forge.Example", "fixture", provider=provider, api_host="API.Example", state_dir=tmp_path
+    )
+    calls = []
+
+    def get(client, path, **params):
+        calls.append((client.base_url, path))
+        row = {"id": 17, "full_name": "owner/repo", "path_with_namespace": "owner/repo"}
+        return [row] if path in {"user/repos", "projects"} else row
+
+    def get_all(client, path, **params):
+        calls.append((client.base_url, path))
+        return []
+
+    monkeypatch.setattr(RestClient, "get", get)
+    monkeypatch.setattr(RestClient, "get_all", get_all)
+    client = (
+        connection.client("owner/repo").for_repository("upstream/repo").for_repository("owner/repo")
+    )
+    assert client.repository() == connection.repository("owner/repo")
+    assert client.list_repositories().items == (connection.repository("owner/repo"),)
+    assert (
+        client.prs_for_branch("feature", source_repository=connection.repository("owner/repo"))
+        == []
+    )
+    assert calls and all(url.startswith("https://api.example/api/") for url, _ in calls)
+    foreign = ForgeConnection("other.example", "fixture", provider=provider)
+    with pytest.raises(ValueError, match="does not belong"):
+        client.prs_for_branch("feature", source_repository=foreign.repository("owner/repo"))
+
+
+def test_mixed_case_public_github_routes_to_public_api(tmp_path, monkeypatch):
+    """@case Host case does not select the Enterprise endpoint."""
+    from repokit.forge._rest import RestClient
+
+    calls = []
+
+    def get(client, path, **params):
+        calls.append(client.base_url)
+        return []
+
+    monkeypatch.setattr(RestClient, "get", get)
+    connection = ForgeConnection("GitHub.com", "fixture", state_dir=tmp_path)
+    connection.client("owner/repo").list_repositories()
+    assert calls == ["https://api.github.com"]
+    assert connection.identity == ForgeConnection("github.com", "fixture").identity

compforge_repokit-0.17.2/tests/test_validation_report.py

@@ -0,0 +1,176 @@
+import copy
+import json
+
+import pytest
+
+from repokit import decode_validation_report
+
+
+def report(checkout):
+    checks = [
+        {
+            "check": name,
+            "requestedComponents": ["."],
+            "status": "passed",
+            "scope": "full",
+            "command": ["make", name],
+            "files": [],
+            "reason": "fixture",
+            "reused": False,
+            "reuseReason": "no previous check",
+            "checkedAt": "2026-11-02T00:00:00Z",
+            "inputFingerprint": "sha256:inputs",
+            "environment": "test",
+            "witnesses": {},
+            "stdout": "",
+            "stderr": "",
+        }
+        for name in ("lint", "test")
+    ]
+    return {
+        "schemaVersion": 1,
+        "checkout": str(checkout),
+        "snapshot": "sha256:snapshot",
+        "inputsConsistent": True,
+        "complete": True,
+        "passed": True,
+        "components": [{"component": {"root": "."}, "checks": checks}],
+        "diagnostics": [],
+    }
+
+
+def test_failed_report_and_partial_fallback_groups_are_valid(tmp_path):
+    value = report(tmp_path)
+    lint, test = value["components"][0]["checks"]
+    lint["requestedComponents"] = test["requestedComponents"] = ["child"]
+    test["status"] = "failed"
+    value["passed"] = False
+    value["components"] = [
+        {"component": {"root": "."}, "checks": [lint]},
+        {"component": {"root": "child"}, "checks": [test]},
+    ]
+    assert (
+        decode_validation_report(
+            json.dumps(value), checkout=tmp_path, checks=("format", "lint", "test")
+        )
+        == value
+    )
+
+
+@pytest.mark.parametrize(
+    "mutation", ["checkout", "schema", "missing", "duplicate", "escape", "shape", "bool"]
+)
+def test_invalid_report_is_not_validation_evidence(tmp_path, mutation):
+    value = report(tmp_path)
+    if mutation == "checkout":
+        value["checkout"] = str(tmp_path / "other")
+    elif mutation == "schema":
+        value["schemaVersion"] = 2
+    elif mutation == "missing":
+        value["components"][0]["checks"].pop()
+    elif mutation == "duplicate":
+        value["components"] *= 2
+    elif mutation == "escape":
+        value["components"][0]["component"]["root"] = "../outside"
+    elif mutation == "shape":
+        value["components"] = [None]
+    else:
+        value["complete"] = 1
+    with pytest.raises(ValueError):
+        decode_validation_report(json.dumps(value), checkout=tmp_path)
+
+
+@pytest.mark.parametrize("sources", [[["child"]], [{"root": "."}], [1], [".", "."], []])
+def test_requested_component_identity_must_be_unique_strings(tmp_path, sources):
+    value = copy.deepcopy(report(tmp_path))
+    value["components"][0]["checks"][0]["requestedComponents"] = sources
+    with pytest.raises(ValueError, match="requestedComponents"):
+        decode_validation_report(json.dumps(value), checkout=tmp_path)
+
+
+@pytest.mark.parametrize(
+    "status,complete,passed",
+    [
+        ("passed", True, True),
+        ("failed", True, False),
+        ("skipped", True, True),
+        ("unavailable", True, False),
+        ("cancelled", False, False),
+        ("uncertain", False, False),
+    ],
+)
+def test_aggregate_outcome_matches_checks(tmp_path, status, complete, passed):
+    """@case Known failure is valid evidence; contradictory aggregate flags are not."""
+    value = report(tmp_path)
+    value["components"][0]["checks"][0]["status"] = status
+    value.update(complete=complete, passed=passed)
+    assert decode_validation_report(json.dumps(value), checkout=tmp_path) == value
+    for flag in ("complete", "passed"):
+        invalid = copy.deepcopy(value)
+        invalid[flag] = not invalid[flag]
+        with pytest.raises(ValueError, match="contradicts"):
+            decode_validation_report(json.dumps(invalid), checkout=tmp_path)
+
+
+def test_no_selected_tasks_is_distinct_from_empty_component_results(tmp_path):
+    value = report(tmp_path)
+    value["components"][0]["checks"] = []
+    with pytest.raises(ValueError, match="omitted requested checks"):
+        decode_validation_report(json.dumps(value), checkout=tmp_path)
+    value["components"] = []
+    assert decode_validation_report(json.dumps(value), checkout=tmp_path) == value
+
+
+def test_changed_inputs_cannot_claim_validation_passed(tmp_path):
+    value = report(tmp_path)
+    value["inputsConsistent"] = False
+    with pytest.raises(ValueError, match="contradicts"):
+        decode_validation_report(json.dumps(value), checkout=tmp_path)
+    value["passed"] = False
+    assert decode_validation_report(json.dumps(value), checkout=tmp_path) == value
+
+
+@pytest.mark.parametrize(
+    "status,complete,passed,checks",
+    [
+        ("passed", True, True, ("format",)),
+        ("unavailable", True, False, ("format",)),
+        ("failed", True, False, ("format", "lint", "test")),
+        ("cancelled", False, False, ("format", "lint", "test")),
+        ("passed", False, False, ("format", "lint", "test")),
+    ],
+)
+def test_format_only_and_early_termination_are_valid(tmp_path, status, complete, passed, checks):
+    """@case Format can stop before validation and does not promise input consistency."""
+    value = report(tmp_path)
+    value.update(
+        components=[],
+        preparation=[{"checks": [{"check": "format", "status": status}]}],
+        inputsConsistent=False,
+        complete=complete,
+        passed=passed,
+    )
+    assert decode_validation_report(json.dumps(value), checkout=tmp_path, checks=checks) == value
+
+
+def test_failed_preparation_cannot_be_followed_by_successful_checks(tmp_path):
+    value = report(tmp_path)
+    value["preparation"] = [{"checks": [{"check": "format", "status": "failed"}]}]
+    with pytest.raises(ValueError, match="unsuccessful preparation"):
+        decode_validation_report(
+            json.dumps(value), checkout=tmp_path, checks=("format", "lint", "test")
+        )
+
+
+@pytest.mark.parametrize("checks", [("lint", "test"), ("format", "lint", "test")])
+def test_stale_plan_can_abort_before_any_checks(tmp_path, checks):
+    """@case Inputs changed after planning produces an incomplete, empty report."""
+    value = report(tmp_path)
+    value.update(
+        components=[],
+        inputsConsistent=False,
+        complete=False,
+        passed=False,
+        diagnostics=["inputs changed after planning; no checks executed"],
+    )
+    assert decode_validation_report(json.dumps(value), checkout=tmp_path, checks=checks) == value

{compforge_repokit-0.17.1 → compforge_repokit-0.17.2}/uv.lock

@@ -17,7 +17,7 @@ wheels = [
 
 [[package]]
 name = "compforge-repokit"
-version = "0.17.1"
+version = "0.17.2"
 source = { editable = "." }
 dependencies = [
     { name = "harness-common" },

compforge_repokit-0.17.1/tests/test_forge_connection.py

@@ -1,44 +0,0 @@
-import json
-from pathlib import Path
-
-import pytest
-
-from repokit.forge import ForgeConnection, detect_provider
-from repokit.forge.model import ForgeAuthError
-
-
-def test_connection_identity_and_context_are_shared_with_typescript(repo, tmp_path):
-    """@case Credentials, provider and endpoint isolate caches; targets stay explicit."""
-    fixture = Path(__file__).resolve().parents[3] / "conformance/forge-connection.json"
-    for row in json.loads(fixture.read_text()):
-        connection = ForgeConnection(
-            host=row["host"],
-            provider=row["provider"],
-            api_host=row["apiHost"],
-            token=row["token"],
-            state_dir=tmp_path,
-        )
-        assert connection.name == row["name"]
-        assert connection.identity == row["identity"]
-        assert row["token"] not in repr(connection)
-        context = connection.pull_request_context(repo, source="owner/repo")
-        assert context.source == connection.repository("owner/repo")
-        assert context.targets == (context.source,)
-        assert context.observer.store.root == tmp_path
-        assert context.observer.reader.state_dir == tmp_path / "forge-http"
-        explicit = connection.pull_request_context(
-            repo, source="owner/repo", targets=("upstream/repo",)
-        )
-        assert explicit.targets == (connection.repository("upstream/repo"),)
-        with pytest.raises(ValueError):
-            connection.pull_request_context(repo, source="owner/repo", targets=())
-
-
-def test_access_configuration_requires_credentials_and_valid_timeout():
-    assert detect_provider("github.example") == "github"
-    assert detect_provider("forge.example", "github") == "github"
-    assert detect_provider("forge.example") == "gitlab"
-    with pytest.raises(ForgeAuthError):
-        ForgeConnection("github.com", " ")
-    with pytest.raises(ValueError):
-        ForgeConnection("github.com", "fixture", timeout=0)

compforge_repokit-0.17.1/tests/test_validation_report.py

@@ -1,88 +0,0 @@
-import copy
-import json
-
-import pytest
-
-from repokit import decode_validation_report
-
-
-def report(checkout):
-    checks = [
-        {
-            "check": name,
-            "requestedComponents": ["."],
-            "status": "passed",
-            "scope": "full",
-            "command": ["make", name],
-            "files": [],
-            "reason": "fixture",
-            "reused": False,
-            "reuseReason": "no previous check",
-            "checkedAt": "2026-11-02T00:00:00Z",
-            "inputFingerprint": "sha256:inputs",
-            "environment": "test",
-            "witnesses": {},
-            "stdout": "",
-            "stderr": "",
-        }
-        for name in ("lint", "test")
-    ]
-    return {
-        "schemaVersion": 1,
-        "checkout": str(checkout),
-        "snapshot": "sha256:snapshot",
-        "inputsConsistent": True,
-        "complete": True,
-        "passed": True,
-        "components": [{"component": {"root": "."}, "checks": checks}],
-        "diagnostics": [],
-    }
-
-
-def test_failed_report_and_partial_fallback_groups_are_valid(tmp_path):
-    value = report(tmp_path)
-    lint, test = value["components"][0]["checks"]
-    lint["requestedComponents"] = test["requestedComponents"] = ["child"]
-    test["status"] = "failed"
-    value["passed"] = False
-    value["components"] = [
-        {"component": {"root": "."}, "checks": [lint]},
-        {"component": {"root": "child"}, "checks": [test]},
-    ]
-    assert (
-        decode_validation_report(
-            json.dumps(value), checkout=tmp_path, checks=("format", "lint", "test")
-        )
-        == value
-    )
-
-
-@pytest.mark.parametrize(
-    "mutation", ["checkout", "schema", "missing", "duplicate", "escape", "shape", "bool"]
-)
-def test_invalid_report_is_not_validation_evidence(tmp_path, mutation):
-    value = report(tmp_path)
-    if mutation == "checkout":
-        value["checkout"] = str(tmp_path / "other")
-    elif mutation == "schema":
-        value["schemaVersion"] = 2
-    elif mutation == "missing":
-        value["components"][0]["checks"].pop()
-    elif mutation == "duplicate":
-        value["components"] *= 2
-    elif mutation == "escape":
-        value["components"][0]["component"]["root"] = "../outside"
-    elif mutation == "shape":
-        value["components"] = [None]
-    else:
-        value["complete"] = 1
-    with pytest.raises(ValueError):
-        decode_validation_report(json.dumps(value), checkout=tmp_path)
-
-
-@pytest.mark.parametrize("sources", [[["child"]], [{"root": "."}], [1], [".", "."], []])
-def test_requested_component_identity_must_be_unique_strings(tmp_path, sources):
-    value = copy.deepcopy(report(tmp_path))
-    value["components"][0]["checks"][0]["requestedComponents"] = sources
-    with pytest.raises(ValueError, match="requestedComponents"):
-        decode_validation_report(json.dumps(value), checkout=tmp_path)