hermes-agent/tests/hermes_cli/test_shallow_graft_prune.py
liuhao1024 6b51b0fd4e fix(update): expire fetch reflogs that pin stale shallow grafts
prune_stale_shallow_grafts dropped grafts no live ref points at, but the
remote-tracking reflog still naming a dropped fetch tip made the --reflog
fail-safe walk fail (its parent was never fetched), rolling the prune back
on every run — grafts kept accumulating and the next update fell into
orphan divergence (#124645). Expire exactly the fetch reflogs that pin a
dropped graft before writing the trimmed file; user reflogs (HEAD, local
branches) are never touched, so the fail-safe rollback still guards them.

Fixes #124645
2026-09-28 03:08:56 -07:00

196 lines
8.2 KiB
Python

"""Stale shallow-graft pruning after depth-1 update checks (#105951).
Every ``git fetch --depth 1`` appends the fetched tip to ``.git/shallow`` as a
new graft and never removes the previous one, so a long-lived shallow installer
checkout accumulates one line per update check (57 observed in the wild). The
stale grafts break ``merge-base`` and push ``hermes update`` into the
orphan-divergence reset path. ``prune_stale_shallow_grafts()`` drops grafts no
live ref points at; ``hermes update --check`` calls it after its successful
depth-1 fetch, clearing the grafts accumulated by past checks (the passive
banner check no longer git-fetches since #107648).
"""
from __future__ import annotations
import subprocess
from pathlib import Path
from hermes_cli.gitlock import prune_stale_shallow_grafts
def _git(repo: Path, *args: str) -> str:
result = subprocess.run(
["git", *args], cwd=str(repo), capture_output=True, text=True
)
assert result.returncode == 0, result.stderr
return result.stdout.strip()
def _shallow_lines(repo: Path) -> list:
return [
line for line in (repo / ".git" / "shallow").read_text().splitlines() if line
]
def _mk_sparse_shallow_scenario(tmp_path: Path) -> Path:
"""Depth-1 clone whose origin advances two commits per fetch (#124645).
Unlike :func:`_mk_shallow_scenario` the dropped graft's parent is never
fetched, so the only thing pinning it is the remote-tracking reflog the
fetch writes — the shape real installs hit when upstream moves several
commits between checks.
"""
origin = tmp_path / "origin"
origin.mkdir()
_git(origin, "init", "-q", "-b", "main")
_git(origin, "config", "user.email", "[email protected]")
_git(origin, "config", "user.name", "t")
for i in range(3):
_git(origin, "commit", "--allow-empty", "-q", "-m", f"c{i}")
clone = tmp_path / "clone"
subprocess.run(
["git", "clone", "-q", "--depth", "1", f"file://{origin}", str(clone)],
check=True,
capture_output=True,
text=True,
)
for i in (3, 5):
_git(origin, "commit", "--allow-empty", "-q", "-m", f"c{i}")
_git(origin, "commit", "--allow-empty", "-q", "-m", f"c{i + 1}")
_git(clone, "fetch", "-q", "--depth", "1", "origin", "main")
return clone
def _mk_shallow_scenario(tmp_path: Path) -> Path:
"""Depth-1 clone whose origin advanced twice: shallow carries 3 grafts."""
origin = tmp_path / "origin"
origin.mkdir()
_git(origin, "init", "-q", "-b", "main")
_git(origin, "config", "user.email", "[email protected]")
_git(origin, "config", "user.name", "t")
for i in range(3):
_git(origin, "commit", "--allow-empty", "-q", "-m", f"c{i}")
clone = tmp_path / "clone"
subprocess.run(
["git", "clone", "-q", "--depth", "1", f"file://{origin}", str(clone)],
check=True,
capture_output=True,
text=True,
)
for i in range(3, 5):
_git(origin, "commit", "--allow-empty", "-q", "-m", f"c{i}")
_git(clone, "fetch", "-q", "--depth", "1", "origin", "main")
return clone
def test_prunes_orphaned_grafts_keeps_referenced_boundaries(tmp_path):
clone = _mk_shallow_scenario(tmp_path)
assert len(_shallow_lines(clone)) == 3 # HEAD graft + two fetched tips
head_sha = _git(clone, "rev-parse", "HEAD")
tip_sha = _git(clone, "rev-parse", "origin/main")
removed = prune_stale_shallow_grafts(clone)
assert removed == 1 # the middle, now-unreferenced tip
assert set(_shallow_lines(clone)) == {head_sha, tip_sha}
# Boundaries that survive must still walk cleanly.
assert _git(clone, "rev-list", "--count", "HEAD") == "1"
assert _git(clone, "rev-list", "--count", "origin/main") == "1"
def test_prune_is_idempotent_and_noop_without_grafts(tmp_path):
clone = _mk_shallow_scenario(tmp_path)
assert prune_stale_shallow_grafts(clone) == 1
assert prune_stale_shallow_grafts(clone) == 0 # nothing left to drop
empty_dir = tmp_path / "not-a-repo"
empty_dir.mkdir()
assert prune_stale_shallow_grafts(empty_dir) == 0 # not a git repo: no-op
git_no_shallow = tmp_path / "full-clone"
git_no_shallow.mkdir()
(git_no_shallow / ".git").mkdir()
assert prune_stale_shallow_grafts(git_no_shallow) == 0 # no shallow file: no-op
def test_update_check_prunes_and_reports_count(tmp_path, monkeypatch, capsys):
"""`hermes update --check` prunes grafts after its depth-1 fetch and reports the prune."""
import hermes_cli.update_cmd as update_cmd
clone = _mk_shallow_scenario(tmp_path)
assert len(_shallow_lines(clone)) == 3
head_sha = _git(clone, "rev-parse", "HEAD")
previous_tip = _git(clone, "rev-parse", "origin/main")
origin = tmp_path / "origin"
_git(origin, "commit", "--allow-empty", "-q", "-m", "c5")
tip_sha = _git(origin, "rev-parse", "HEAD")
# The check runs git directly, reading main.PROJECT_ROOT through _m().
monkeypatch.setattr(update_cmd._m(), "PROJECT_ROOT", clone)
monkeypatch.setattr(
"hermes_cli.update_contract.evaluate_update_admission", lambda root: None
)
# Local fixture commits have no GitHub compare result; keep the check offline.
monkeypatch.setattr(
"hermes_cli.source_check._github_compare_behind", lambda *a, **k: None
)
update_cmd._cmd_update_check("main")
out = capsys.readouterr().out
assert _git(clone, "rev-parse", "HEAD") == head_sha
assert _git(clone, "rev-parse", "origin/main") == tip_sha != previous_tip
assert _git(clone, "rev-parse", "FETCH_HEAD") == tip_sha
assert set(_shallow_lines(clone)) == {head_sha, tip_sha}
assert _git(clone, "rev-list", "--count", "HEAD") == "1"
assert _git(clone, "rev-list", "--count", "origin/main") == "1"
assert "pruned 2 stale shallow graft(s)" in out
assert "Update available (behind origin/main)." in out
def test_prune_expires_fetch_reflogs_that_pin_dropped_grafts(tmp_path):
"""The fetch reflog must not pin a dropped graft forever (#124645).
The dropped graft's parent was never fetched, so the ``--reflog`` fail-safe
walk starts at the reflog's old fetch tips and fails, rolling the prune back
on every run — grafts keep accumulating and the next update falls into
orphan divergence. Expiring the pinning fetch reflog lets the prune stick.
"""
clone = _mk_sparse_shallow_scenario(tmp_path)
assert len(_shallow_lines(clone)) == 3 # HEAD graft + two fetch tips
head_sha = _git(clone, "rev-parse", "HEAD")
tip_sha = _git(clone, "rev-parse", "origin/main")
middle_sha = (set(_shallow_lines(clone)) - {head_sha, tip_sha}).pop()
assert middle_sha in _git(clone, "reflog", "show", "--format=%H", "origin/main").split()
removed = prune_stale_shallow_grafts(clone)
assert removed == 1
assert set(_shallow_lines(clone)) == {head_sha, tip_sha}
# The fetch reflog no longer pins the dropped graft, while HEAD's own
# reflog survives untouched and every walk the fail-safe runs stays healthy.
assert middle_sha not in _git(clone, "reflog", "show", "--format=%H", "origin/main").split()
assert _git(clone, "reflog", "show", "--format=%H", "HEAD").split()
assert _git(clone, "rev-list", "--count", "HEAD") == "1"
assert _git(clone, "rev-list", "--count", "origin/main") == "1"
assert _git(clone, "rev-list", "--count", "--all", "--reflog") == "2"
def test_prune_still_rolls_back_when_user_reflogs_pin_the_graft(tmp_path):
"""A graft pinned by HEAD's reflog stays: user reflogs are never expired."""
clone = _mk_sparse_shallow_scenario(tmp_path)
head_sha = _git(clone, "rev-parse", "HEAD")
tip_sha = _git(clone, "rev-parse", "origin/main")
middle_sha = (set(_shallow_lines(clone)) - {head_sha, tip_sha}).pop()
_git(clone, "checkout", "-q", middle_sha) # a user checkout records it in HEAD's reflog
_git(clone, "checkout", "-q", "main")
head_reflog = _git(clone, "reflog", "show", "--format=%H", "HEAD").split()
assert middle_sha in head_reflog
removed = prune_stale_shallow_grafts(clone)
assert removed == 0 # the fail-safe still rolls the prune back
assert len(_shallow_lines(clone)) == 3
assert _git(clone, "reflog", "show", "--format=%H", "HEAD").split() == head_reflog