Files
hermes-agent/tests/ci/test_clean_worktree_check.py
Maciej Lisiewski 4bacf837d1 ci(lint): run the four Python lint checks as steps of one job
ruff + ty diff, ruff enforcement, the code-health ratchet and the Windows
footgun guards were four jobs on the same runner, each repeating the
checkout, setup-pm and the pinned ruff install for 10-60s of work.

One job now runs them in order: the footgun-family guards on the setup-pm
interpreter, then one pinned-tool install (ty only for the PR diff), then
blocking ruff, the ratchet and the advisory diff. Every check keeps its
lane gate and runs whatever an earlier one did (`!cancelled()`); the
advisory steps stay continue-on-error. The base-branch worktree for the
diff moves under $RUNNER_TEMP.
2026-11-06 02:15:55 +01:00

173 lines
7.0 KiB
Python

"""Every job of the main CI lanes ends by checking that it left the checkout clean.
The step (.github/actions/check-clean-worktree) runs ``git status --porcelain=v1
--untracked-files=normal`` and reports tracked changes and untracked, non-ignored
files. Stray test output reached main more than once (log.txt, default.tar.gz,
MagicMock/<name>/<id> SQLite stores, a ``%SystemDrive%`` tree); .gitignore hides
the rest. Its mode is set in ONE place, the action's ``mode`` input default.
"""
from __future__ import annotations
import os
import shutil
import subprocess
from pathlib import Path
import pytest
from ruamel.yaml import YAML
from tests.ci.workflow_steps import is_checkout
ROOT = Path(__file__).resolve().parents[2]
ACTION_DIR = ".github/actions/check-clean-worktree"
ACTION = ROOT / ACTION_DIR / "action.yml"
USES = f"./{ACTION_DIR}"
WORKFLOWS = ("tests.yml", "tests-os.yml", "lint.yml", "js-tests.yml")
MODES = ("blocking", "warning", "off")
def _load(path: Path):
return YAML(typ="base").load(path.read_text(encoding="utf-8"))
def _checkout_jobs():
for filename in WORKFLOWS:
for name, job in (_load(ROOT / ".github/workflows" / filename)["jobs"] or {}).items():
steps = job.get("steps") or [] # reusable-workflow calls have none
if any(is_checkout(step) for step in steps):
yield f"{filename}:{name}", job, steps
def test_every_checkout_job_ends_with_the_clean_worktree_step():
jobs = list(_checkout_jobs())
assert len(jobs) >= 7, [label for label, *_ in jobs] # tests 4, tests-os 2, lint 1, js 1
problems = []
for label, job, steps in jobs:
last = steps[-1]
if last.get("uses") != USES:
problems.append(f"{label}: last step is {last.get('name') or last.get('uses')!r}")
continue
if "if" in last:
# Default success(): after a failed step the job is red already, and that step may
# have left temp files its own later cleanup would remove (false positives).
problems.append(f"{label}: runs with `if: {last['if']}`; leave `if:` off")
if "mode" in (last.get("with") or {}):
problems.append(f"{label}: passes `mode`; the action's default is the only switch")
checkout = next(s for s in steps if is_checkout(s))
sparse = str((checkout.get("with") or {}).get("sparse-checkout", ""))
if sparse and ACTION_DIR not in sparse.split():
problems.append(f"{label}: sparse checkout omits {ACTION_DIR}, so the step cannot load")
assert not problems, "\n".join(problems)
def test_no_workflow_overrides_the_master_switch():
offenders = []
for path in sorted((ROOT / ".github/workflows").glob("*.y*ml")):
for name, job in (_load(path).get("jobs") or {}).items():
for step in job.get("steps") or []:
if step.get("uses") == USES and "mode" in (step.get("with") or {}):
offenders.append(f"{path.name}:{name}")
assert not offenders, offenders
def test_master_switch_is_a_known_mode():
assert _load(ACTION)["inputs"]["mode"]["default"] in MODES
# ── behaviour: run the action's script against a real repository ──────────────────────
@pytest.fixture
def repo(tmp_path):
git = shutil.which("git")
if git is None:
pytest.skip("git not installed")
work = tmp_path / "repo"
work.mkdir()
env = {**os.environ, "GIT_CONFIG_GLOBAL": os.devnull, "GIT_CONFIG_NOSYSTEM": "1"}
for args in (["init", "-q"], ["config", "user.email", "t@example.invalid"], ["config", "user.name", "t"]):
subprocess.run([git, *args], cwd=work, env=env, check=True)
(work / ".gitignore").write_text("ignored/\n", encoding="utf-8")
(work / "tracked.txt").write_text("one\n", encoding="utf-8")
subprocess.run([git, "add", "."], cwd=work, env=env, check=True)
subprocess.run([git, "commit", "-qm", "init"], cwd=work, env=env, check=True)
return work, env
def _run(cwd: Path, env: dict, mode: str, tmp_path: Path):
bash = shutil.which("bash")
if bash is None:
pytest.skip("bash not installed")
script = _load(ACTION)["runs"]["steps"][0]["run"]
summary = tmp_path / "summary.md"
result = subprocess.run(
[bash, "--noprofile", "--norc", "-eo", "pipefail", "-c", script],
cwd=cwd, env={**env, "_MODE": mode, "GITHUB_STEP_SUMMARY": str(summary)},
capture_output=True, text=True, encoding="utf-8", timeout=60, check=False,
)
return result.returncode, result.stdout, summary
@pytest.mark.platforms("posix")
def test_clean_checkout_passes_and_ignored_files_do_not_count(repo, tmp_path):
work, env = repo
(work / "ignored").mkdir()
(work / "ignored" / "out.db").write_text("x", encoding="utf-8")
code, out, _ = _run(work, env, "blocking", tmp_path)
assert code == 0, out
assert "clean" in out and "::error" not in out
@pytest.mark.platforms("posix")
def test_blocking_fails_and_names_untracked_and_modified_files(repo, tmp_path):
work, env = repo
(work / "log.txt").write_text("stray", encoding="utf-8")
(work / "tracked.txt").write_text("two\n", encoding="utf-8")
code, out, summary = _run(work, env, "blocking", tmp_path)
assert code == 1, out
assert "::error title=Dirty checkout::log.txt: untracked file left in the checkout" in out
assert "::error title=Dirty checkout::tracked.txt: tracked file changed" in out
assert "tracked.txt | 2 +-" in out # git diff --stat
assert "log.txt" in summary.read_text(encoding="utf-8")
@pytest.mark.platforms("posix")
def test_warning_mode_reports_without_failing(repo, tmp_path):
work, env = repo
(work / "default.tar.gz.part").write_text("stray", encoding="utf-8")
code, out, _ = _run(work, env, "warning", tmp_path)
assert code == 0, out
assert "::warning title=Dirty checkout::default.tar.gz.part" in out
assert "::error" not in out
@pytest.mark.platforms("posix")
def test_off_skips_and_unknown_mode_fails_closed(repo, tmp_path):
work, env = repo
(work / "stray").write_text("x", encoding="utf-8")
assert _run(work, env, "off", tmp_path)[0] == 0
code, out, _ = _run(work, env, "blockng", tmp_path)
assert code == 1 and "::error" in out
@pytest.mark.platforms("posix")
def test_annotations_cap_at_ten_with_the_full_list_in_the_log(repo, tmp_path):
work, env = repo
for i in range(25):
(work / f"stray{i:02}").write_text("x", encoding="utf-8")
code, out, _ = _run(work, env, "blocking", tmp_path)
assert code == 1
assert out.count("::error ") == 10 # GitHub keeps 10 per step: 9 files + the summary line
assert "left 25 changed or untracked path(s)" in out
assert all(f"?? stray{i:02}" in out for i in range(25))
@pytest.mark.platforms("posix")
def test_missing_checkout_is_reported(tmp_path):
bare = tmp_path / "nogit"
bare.mkdir()
env = {**os.environ, "GIT_CEILING_DIRECTORIES": str(tmp_path)}
code, out, _ = _run(bare, env, "blocking", tmp_path)
assert code == 1 and "no git checkout" in out
assert _run(bare, env, "warning", tmp_path)[0] == 0