Publish curated ITWorx-ModelForge source from 990401737f96c8d46a9f7b0d84994516cadcb6a0

backend/tests/test_rc_readiness_program.py

@@ -0,0 +1,138 @@
+"""The RC ledger gate must fail closed on ambiguous plans or incomplete evidence."""
+
+import importlib.util
+import json
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SPEC = importlib.util.spec_from_file_location("rc_readiness", ROOT / "scripts/rc_readiness.py")
+assert SPEC is not None and SPEC.loader is not None
+readiness = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(readiness)
+
+
+@pytest.fixture
+def repository(tmp_path: Path) -> Path:
+    for relative in (readiness.CONFIG, readiness.LEDGER, readiness.ROADMAP):
+        target = tmp_path / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text((ROOT / relative).read_text(encoding="utf-8"), encoding="utf-8")
+    return tmp_path
+
+
+def mutate_plan(repository: Path, change) -> None:
+    path = repository / readiness.CONFIG
+    plan = json.loads(path.read_text(encoding="utf-8"))
+    change(plan)
+    path.write_text(json.dumps(plan), encoding="utf-8")
+
+
+def test_actual_repository_is_valid_but_incomplete() -> None:
+    result = readiness.validate(ROOT)
+    plan = json.loads((ROOT / readiness.CONFIG).read_text(encoding="utf-8"))
+    assert result["packet_count"] == len(plan["packets"])
+    assert result["required_gap_count"] > result["verified_count"] > 0
+    assert result["outstanding_ids"]
+    assert result["all_required_rows_verified"] is False
+    assert result["topological_order"].index("P06") < result["topological_order"].index("P03")
+    assert "release_ready" not in result
+
+
+def test_repository_path_guard_rejects_escape_before_read(repository: Path) -> None:
+    with pytest.raises(readiness.InvalidPlan, match="escapes root"):
+        readiness._read(repository, "../outside.md")
+
+
+def test_status_documentation_is_not_parsed_as_issue_rows(repository: Path) -> None:
+    before = readiness.validate(repository)
+    path = repository / readiness.LEDGER
+    with path.open("a", encoding="utf-8") as output:
+        output.write("\n| Classification | UNKNOWN |\nProse RC-FAKE-01 is not an issue row.\n")
+    assert readiness.validate(repository) == before
+
+
+@pytest.mark.parametrize("change", [
+    lambda p: p.update(schema_version=True),
+    lambda p: p.update(schema_version=2),
+    lambda p: p.update(extra=True),
+    lambda p: p.pop("ledger"),
+    lambda p: p.update(target_version="stable"),
+    lambda p: p.update(baseline_commit="main"),
+    lambda p: p.update(ledger="../../outside.md"),
+    lambda p: p.update(roadmap="C:/outside.md"),
+    lambda p: p.update(packets=[]),
+    lambda p: p["packets"].append(p["packets"][0]),
+    lambda p: p["packets"][0].update(id="bad"),
+    lambda p: p["packets"][0]["depends_on"].append("P99"),
+    lambda p: p["packets"][0]["depends_on"].append("P15"),
+    lambda p: p["packets"][0]["depends_on"].extend(["P01", "P01"]),
+    lambda p: p["packets"][0]["gaps"].pop(),
+    lambda p: p["packets"][0]["gaps"].append("RC-UNKNOWN-01"),
+    lambda p: p["packets"][0]["gaps"].append(p["packets"][1]["gaps"][0]),
+    lambda p: p["deferred_gaps"].append(p["deferred_gaps"][0]),
+    lambda p: p["deferred_gaps"].append(p["packets"][0]["gaps"].pop()),
+    lambda p: p["packets"][0]["gaps"].append(p["deferred_gaps"].pop()),
+])
+def test_invalid_plans_are_rejected(repository: Path, change) -> None:
+    mutate_plan(repository, change)
+    with pytest.raises(readiness.InvalidPlan):
+        readiness.validate(repository)
+
+
+@pytest.mark.parametrize("text", ["{", '{"schema_version":1,"schema_version":1}',
+                                   '{"packets":[{"id":"P00","id":"P01"}]}'])
+def test_malformed_and_duplicate_json_fields(repository: Path, text: str) -> None:
+    (repository / readiness.CONFIG).write_text(text, encoding="utf-8")
+    with pytest.raises(ValueError):
+        readiness.validate(repository)
+
+
+@pytest.mark.parametrize("relative", [readiness.CONFIG, readiness.LEDGER, readiness.ROADMAP])
+def test_missing_inputs_fail(repository: Path, relative: str) -> None:
+    (repository / relative).unlink()
+    with pytest.raises(OSError):
+        readiness.validate(repository)
+
+
+@pytest.mark.parametrize("mode", ["duplicate", "empty", "unknown_status", "false_verified",
+                                  "deferral", "classification", "malformed"])
+def test_invalid_ledger_rows_fail(repository: Path, mode: str) -> None:
+    path = repository / readiness.LEDGER
+    text = path.read_text(encoding="utf-8")
+    row = next(line for line in text.splitlines() if line.startswith("| RC-"))
+    changed = {
+        "duplicate": text + "\n" + row,
+        "empty": "# No rows",
+        "unknown_status": text.replace("| VERIFIED |", "| APPROVED |", 1),
+        "false_verified": text.replace("| VERIFIED |", "| VERIFIED — pending |", 1),
+        "deferral": text.replace("| VERIFIED |", "| DEFERRED |", 1),
+        "classification": text.replace(row, row.replace(row.split("|")[4], " UNKNOWN ", 1)),
+        "malformed": text.replace(row, row.rstrip("|"), 1),
+    }[mode]
+    path.write_text(changed, encoding="utf-8")
+    with pytest.raises(readiness.InvalidPlan):
+        readiness.validate(repository)
+
+
+def test_cli_exit_codes_and_full_verification(repository: Path, monkeypatch, capsys) -> None:
+    original = readiness.validate
+    monkeypatch.setattr(readiness, "validate", lambda: original(repository))
+    assert readiness.main([]) == 0
+    assert readiness.main(["--require-verified"]) == 1
+    path = repository / readiness.LEDGER
+    lines = path.read_text(encoding="utf-8").splitlines()
+    path.write_text("\n".join(
+        line.rsplit("|", 2)[0] + "| VERIFIED |"
+        if line.startswith("| RC-") and "| POST-RC |" not in line else line
+        for line in lines
+    ), encoding="utf-8")
+    assert readiness.main(["--require-verified"]) == 0
+    result = json.loads(capsys.readouterr().out.splitlines()[-1])
+    assert result["all_required_rows_verified"] is True
+    assert result["outstanding_ids"] == []
+    assert result["verified_count"] == result["required_gap_count"]
+    path.unlink()
+    assert readiness.main([]) == 2
+    assert json.loads(capsys.readouterr().out)["all_required_rows_verified"] is False