Merge pull request #373 from PyAutoLabs/feature/repos-sync-config-checks

feat(repos_sync): check Heart version_skew and Hands workspaces.yaml identity (stamper deferred)

Author: Jammy2211

scripts/repos_sync.py

@@ -42,8 +42,11 @@
 
 --check (always run) verifies, against the manifest:
 
-  * PyAutoHeart/config/repos.yaml          — polled repos exist, owners match
+  * PyAutoHeart/config/repos.yaml          — polled repos exist, owners match,
+    smoke: and version_skew: name manifest repos and manifest package names
   * PyAutoHands/pre_build.sh               — run_workspace repos exist
+  * PyAutoHands/autohands/config/workspaces.yaml — run_all repos, library
+    names/packages and slow_skip_default repos exist
   * PyAutoBrain/bin/ensure_workspace_labels.sh — owner/name pairs match
   * the hygiene conductor — the repo sets it scans are derived from this
     manifest, and no repo name has been hardcoded back into an array
@@ -386,6 +389,84 @@ def check_heart(root, repos):
             problems.append(
                 f"Heart smoke import_names key '{name}' — not in the manifest"
             )
+    # version_skew: <workspace repo> -> {library, package}. Heart compares the
+    # library version a workspace pins against the library repo's own, so every
+    # field here is identity the body map owns — and none of it was checked
+    # until now, while the polled list beside it was checked from the start.
+    # A workspace or library renamed in the map, or a package renamed on PyPI,
+    # skewed Heart silently. Soft-skip when absent, like the smoke: block: a
+    # Heart checkout predating it is not drift, and Heart's own loader is what
+    # decides the block is required.
+    for name, spec in (data.get("version_skew") or {}).items():
+        spec = spec or {}
+        if name not in repos:
+            problems.append(
+                f"Heart version_skew '{name}' — not in the manifest"
+            )
+        library = spec.get("library")
+        if library not in repos:
+            problems.append(
+                f"Heart version_skew '{name}' library '{library}' — "
+                f"not in the manifest"
+            )
+            continue
+        expected = repos[library].get("package")
+        if expected is None:
+            problems.append(
+                f"Heart version_skew '{name}' names library '{library}', "
+                f"which has no 'package:' in the manifest"
+            )
+        elif spec.get("package") != expected:
+            problems.append(
+                f"Heart version_skew '{name}' package "
+                f"'{spec.get('package')}', manifest says '{expected}'"
+            )
+    return problems
+
+
+def check_hands_workspaces(root, repos):
+    """The Build run matrix names repos too.
+
+    `PyAutoHands/autohands/config/workspaces.yaml` says in its own header that
+    repo identity must match the body map and that this check flags drift. It
+    said so from the day it was extracted and no leg read it, so the claim was
+    aspirational. Policy stays Hands' — the short keys, the report directories,
+    the release matrix order are all its own; only the names are checked."""
+    path = root / "PyAutoHands/autohands/config/workspaces.yaml"
+    if not path.exists():
+        return []
+    data = yaml.safe_load(path.read_text()) or {}
+    problems = []
+    for key, spec in (data.get("run_all") or {}).items():
+        repo = (spec or {}).get("repo")
+        if repo not in repos:
+            problems.append(
+                f"Hands run_all '{key}' repo '{repo}' — not in the manifest"
+            )
+    for entry in data.get("libraries") or ():
+        entry = entry or {}
+        name = entry.get("name")
+        if name not in repos:
+            problems.append(
+                f"Hands libraries entry '{name}' — not in the manifest"
+            )
+            continue
+        expected = repos[name].get("package")
+        if expected is None:
+            problems.append(
+                f"Hands libraries entry '{name}' has no 'package:' in the "
+                f"manifest"
+            )
+        elif entry.get("package") != expected:
+            problems.append(
+                f"Hands libraries '{name}' package '{entry.get('package')}', "
+                f"manifest says '{expected}'"
+            )
+    for name in data.get("slow_skip_default") or ():
+        if name not in repos:
+            problems.append(
+                f"Hands slow_skip_default '{name}' — not in the manifest"
+            )
     return problems
 
 
@@ -1257,6 +1338,8 @@ def main():
     checks = {
         "PyAutoHeart/config/repos.yaml": lambda: check_heart(root, repos),
         "PyAutoHands/pre_build.sh": lambda: check_pre_build(root, repos),
+        "PyAutoHands/autohands/config/workspaces.yaml":
+            lambda: check_hands_workspaces(root, repos),
         "ensure_workspace_labels.sh": lambda: check_labels(root, repos),
         "hygiene conductor coverage":
             lambda: check_hygiene_coverage(root, repos, mind_root),

tests/test_repos_sync_config_checks.py

@@ -0,0 +1,246 @@
+"""The organ *config* surfaces must not drift from the body map.
+
+Two mirrors sat unchecked while the file headers claimed otherwise:
+
+1. **Heart `version_skew:`** — `<workspace repo>: {library, package}`. Every
+   field is identity the body map owns, and `check_heart` read the polled-repo
+   list, the owners and (since PyAutoMind#198) the `smoke:` block, but never
+   this one. A workspace renamed in the map, or a library whose package name
+   changed, would have skewed Heart silently.
+2. **Hands `autohands/config/workspaces.yaml`** — its own header says "Repo
+   IDENTITY must match PyAutoMind/repos.yaml (the body map); repos_sync.py
+   --check flags drift". No leg read the file. The claim was aspirational from
+   the day it was written.
+
+Same two rules as the hygiene-coverage tests next door:
+
+1. **Fictional fixtures only.** `tests/**` is KEEP-copied verbatim into the
+   public template (see `test_spawn_privacy.py`), so nothing here names a real
+   repository, and the tests assert the checks' logic rather than the state of
+   whatever happens to be checked out.
+2. **Prove each leg FAILS.** A drift check that cannot fail is decoration.
+   Every leg below is driven with input that must trip it.
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+import yaml
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
+
+import repos_sync  # noqa: E402
+
+HEART_REL = "PyAutoHeart/config/repos.yaml"
+HANDS_REL = "PyAutoHands/autohands/config/workspaces.yaml"
+
+# A fictional organism: two packaged libraries, one packaged organ, one library
+# the map declares without a package, plus a workspace and a howto.
+MANIFEST = {
+    "OrganOne": {
+        "github": "FictionalOrg/OrganOne",
+        "category": "organ",
+        "package": "organone",
+    },
+    "LibTwo": {
+        "github": "FictionalOrg/LibTwo",
+        "category": "library",
+        "package": "libtwo",
+    },
+    "LibThree": {
+        "github": "FictionalOrg/LibThree",
+        "category": "library",
+        "package": "libthree",
+    },
+    # Declared without a `package:` — the body map carries one only for the
+    # libraries/organs that ship as a distribution.
+    "LibFour": {"github": "FictionalOrg/LibFour", "category": "library"},
+    "libtwo_workspace": {
+        "github": "FictionalOrg/libtwo_workspace",
+        "category": "workspace",
+    },
+    "HowToTwo": {"github": "FictionalOrg/HowToTwo", "category": "howto"},
+}
+
+HEART_REPOS = {
+    "libraries": [
+        {"name": "LibTwo", "owner": "FictionalOrg"},
+        {"name": "LibThree", "owner": "FictionalOrg"},
+    ],
+    "workspaces": [{"name": "libtwo_workspace", "owner": "FictionalOrg"}],
+}
+
+VERSION_SKEW_OK = {
+    "libtwo_workspace": {"library": "LibTwo", "package": "libtwo"},
+    "HowToTwo": {"library": "LibThree", "package": "libthree"},
+}
+
+WORKSPACES_OK = {
+    "run_all": {
+        "libtwo": {"repo": "libtwo_workspace", "report": "libtwo"},
+        "howtotwo": {"repo": "HowToTwo", "report": "howtotwo"},
+    },
+    "libraries": [
+        {"name": "LibTwo", "package": "libtwo"},
+        {"name": "LibThree", "package": "libthree"},
+    ],
+    "slow_skip_default": ["libtwo_workspace"],
+}
+
+
+def _heart(tmp_path, *, version_skew=..., repos=None):
+    """Write a Heart config; `version_skew=None` omits the block entirely."""
+    data = {"repos": HEART_REPOS if repos is None else repos}
+    skew = VERSION_SKEW_OK if version_skew is ... else version_skew
+    if skew is not None:
+        data["version_skew"] = skew
+    path = tmp_path / HEART_REL
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(yaml.safe_dump(data))
+    return repos_sync.check_heart(tmp_path, MANIFEST)
+
+
+def _hands(tmp_path, data=None):
+    path = tmp_path / HANDS_REL
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(yaml.safe_dump(WORKSPACES_OK if data is None else data))
+    return repos_sync.check_hands_workspaces(tmp_path, MANIFEST)
+
+
+# --------------------------------------------------------------------------
+# Heart: version_skew
+# --------------------------------------------------------------------------
+
+def test_a_version_skew_block_matching_the_map_is_clean(tmp_path):
+    assert _heart(tmp_path) == []
+
+
+def test_a_version_skew_key_the_map_does_not_declare_is_drift(tmp_path):
+    skew = {**VERSION_SKEW_OK, "ghost_workspace": {"library": "LibTwo",
+                                                   "package": "libtwo"}}
+
+    problems = _heart(tmp_path, version_skew=skew)
+
+    assert any("ghost_workspace" in p and "not in the manifest" in p
+               for p in problems)
+
+
+def test_a_version_skew_library_the_map_does_not_declare_is_drift(tmp_path):
+    # A library renamed in the body map leaves Heart comparing against nothing.
+    skew = {"libtwo_workspace": {"library": "LibGhost", "package": "libtwo"}}
+
+    problems = _heart(tmp_path, version_skew=skew)
+
+    assert any("LibGhost" in p and "not in the manifest" in p
+               for p in problems)
+
+
+def test_a_version_skew_package_that_is_not_the_maps_package_is_drift(tmp_path):
+    # The exact skew the check exists for: right library, stale import name.
+    skew = {"libtwo_workspace": {"library": "LibTwo", "package": "libtwo_old"}}
+
+    problems = _heart(tmp_path, version_skew=skew)
+
+    assert any("libtwo_old" in p and "libtwo" in p for p in problems)
+
+
+def test_a_version_skew_library_with_no_package_in_the_map_is_drift(tmp_path):
+    # Nothing to compare against — the map does not claim this repo ships a
+    # package, so Heart must not be asserting one.
+    skew = {"libtwo_workspace": {"library": "LibFour", "package": "libfour"}}
+
+    problems = _heart(tmp_path, version_skew=skew)
+
+    assert any("LibFour" in p and "package" in p for p in problems)
+
+
+def test_a_heart_config_without_a_version_skew_block_is_tolerated(tmp_path):
+    # A Heart checkout predating the block is not drift; only Heart's own
+    # loader decides whether it is required.
+    assert _heart(tmp_path, version_skew=None) == []
+
+
+def test_the_heart_leg_skips_when_heart_is_not_checked_out(tmp_path):
+    # Partial/web checkouts are normal; a missing organ is skipped, not failed.
+    assert repos_sync.check_heart(tmp_path, MANIFEST) == []
+
+
+# --------------------------------------------------------------------------
+# Hands: workspaces.yaml
+# --------------------------------------------------------------------------
+
+def test_a_workspaces_yaml_matching_the_map_is_clean(tmp_path):
+    assert _hands(tmp_path) == []
+
+
+def test_a_run_all_repo_the_map_does_not_declare_is_drift(tmp_path):
+    data = {**WORKSPACES_OK, "run_all": {
+        **WORKSPACES_OK["run_all"],
+        "ghost": {"repo": "ghost_workspace", "report": "ghost"},
+    }}
+
+    problems = _hands(tmp_path, data)
+
+    assert any("ghost_workspace" in p and "not in the manifest" in p
+               for p in problems)
+
+
+def test_a_libraries_name_the_map_does_not_declare_is_drift(tmp_path):
+    data = {**WORKSPACES_OK,
+            "libraries": [{"name": "LibGhost", "package": "libghost"}]}
+
+    problems = _hands(tmp_path, data)
+
+    assert any("LibGhost" in p and "not in the manifest" in p for p in problems)
+
+
+def test_a_libraries_package_that_is_not_the_maps_package_is_drift(tmp_path):
+    # The release board renders versions from this package name; a stale one
+    # reads as "not on PyPI" rather than as drift.
+    data = {**WORKSPACES_OK,
+            "libraries": [{"name": "LibTwo", "package": "libtwo_old"}]}
+
+    problems = _hands(tmp_path, data)
+
+    assert any("libtwo_old" in p and "libtwo" in p for p in problems)
+
+
+def test_a_slow_skip_default_repo_the_map_does_not_declare_is_drift(tmp_path):
+    data = {**WORKSPACES_OK, "slow_skip_default": ["ghost_workspace"]}
+
+    problems = _hands(tmp_path, data)
+
+    assert any("ghost_workspace" in p for p in problems)
+
+
+def test_the_hands_leg_skips_when_hands_is_not_checked_out(tmp_path):
+    assert repos_sync.check_hands_workspaces(tmp_path, MANIFEST) == []
+
+
+def test_the_hands_leg_is_registered_so_only_can_select_it(tmp_path):
+    # --only selects by the printed label, and an unregistered leg never runs
+    # however good the function is. `--only <unknown>` lists every registered
+    # label, so it is the cheapest proof the leg is wired in.
+    proc = subprocess.run(
+        [sys.executable, str(Path(repos_sync.__file__)), "--check",
+         "--root", str(tmp_path), "--only", "no-such-check"],
+        capture_output=True, text=True,
+    )
+
+    assert proc.returncode != 0
+    assert f"'{HANDS_REL}'" in proc.stderr
+
+
+# --------------------------------------------------------------------------
+# The live tree
+# --------------------------------------------------------------------------
+
+def test_the_real_organ_configs_match_the_real_body_map():
+    """The live workspace, if it is checked out here."""
+    mind_root = Path(__file__).resolve().parents[1]
+    root = mind_root.parent
+    _, repos = repos_sync.load_manifest(mind_root)
+
+    assert repos_sync.check_heart(root, repos) == []
+    assert repos_sync.check_hands_workspaces(root, repos) == []