File size: 5,109 Bytes
674d56a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 | """Regression for #40998: installer fails on an interrupted prior clone.
A previous clone that died before its first commit leaves ``$INSTALL_DIR/.git``
present but with no resolvable ``HEAD``. ``git rev-parse --is-inside-work-tree``
and ``git status`` both still succeed there, so the installer treated it as a
valid checkout and tried to *update* it -- but ``git stash``/``git checkout``
abort with "You do not have the initial commit yet", failing the install at the
"Cloning Hermes repository" stage.
Both installers must instead treat a commit-less checkout as broken and
re-clone fresh.
"""
from __future__ import annotations
import re
import shlex
import shutil
import subprocess
from pathlib import Path
import pytest
REPO_ROOT = Path(__file__).resolve().parent.parent.parent.parent
INSTALL_SH = REPO_ROOT / "scripts" / "install.sh"
INSTALL_PS1 = REPO_ROOT / "scripts" / "install.ps1"
pytestmark = pytest.mark.skipif(
shutil.which("git") is None or shutil.which("bash") is None,
reason="needs git and bash",
)
def _git(cwd: Path, *args: str) -> None:
subprocess.run(
["git", "-c", "user.email=t@t", "-c", "user.name=t", *args],
cwd=cwd,
check=True,
capture_output=True,
)
def _extract_no_commit_guard() -> str:
"""Pull the clone_repo() guard that drops a commit-less checkout."""
text = INSTALL_SH.read_text()
m = re.search(
r'if \[ -d "\$INSTALL_DIR/\.git" \] && ! git -C "\$INSTALL_DIR" '
r"rev-parse --verify HEAD.*?\n fi",
text,
re.DOTALL,
)
assert m is not None, "no-commit guard not found in install.sh clone_repo()"
return m.group(0)
def _run_guard(install_dir: Path) -> None:
block = _extract_no_commit_guard()
script = (
"log_warn() { echo \"WARN: $*\"; }\n"
f"INSTALL_DIR={shlex.quote(str(install_dir))}\n"
f"{block}\n"
)
res = subprocess.run(["bash", "-c", script], capture_output=True, text=True)
assert res.returncode == 0, res.stderr
def test_install_sh_guard_moves_commitless_checkout_aside(tmp_path: Path) -> None:
install_dir = tmp_path / "hermes-agent"
install_dir.mkdir()
_git(install_dir, "init")
(install_dir / "leftover.txt").write_text("partial download") # untracked
# Sanity: this is exactly the state that breaks `git stash`.
head = subprocess.run(
["git", "-C", str(install_dir), "rev-parse", "--verify", "HEAD"],
capture_output=True,
)
assert head.returncode != 0
_run_guard(install_dir)
# The original path is cleared so a fresh clone can proceed, but the
# content is preserved in a backup (never deleted -- review feedback).
assert not install_dir.exists(), "commit-less checkout should be moved aside"
backups = list(install_dir.parent.glob(install_dir.name + ".broken-*"))
assert len(backups) == 1, "broken checkout should be moved to one backup dir"
assert (backups[0] / "leftover.txt").read_text() == "partial download"
def test_install_sh_guard_keeps_repo_with_commits(tmp_path: Path) -> None:
install_dir = tmp_path / "hermes-agent"
install_dir.mkdir()
_git(install_dir, "init")
(install_dir / "f.txt").write_text("real content")
_git(install_dir, "add", "f.txt")
_git(install_dir, "commit", "-m", "init")
_run_guard(install_dir)
assert install_dir.exists()
assert (install_dir / "f.txt").exists(), "a real checkout must be left intact"
assert not list(install_dir.parent.glob(install_dir.name + ".broken-*")), (
"a healthy checkout must not be moved aside"
)
def test_install_sh_guard_ignores_non_repo_dir(tmp_path: Path) -> None:
install_dir = tmp_path / "hermes-agent"
install_dir.mkdir()
(install_dir / "f.txt").write_text("not a repo")
_run_guard(install_dir)
# No .git → not our concern; the existing "not a git repository" branch
# still handles it. The guard must leave it untouched.
assert install_dir.exists()
assert (install_dir / "f.txt").exists()
def test_install_ps1_validity_requires_initial_commit() -> None:
"""The PowerShell repo-validity gate must also require a resolvable HEAD."""
text = INSTALL_PS1.read_text()
assert "rev-parse --verify HEAD" in text, (
"install.ps1 must probe for an initial commit (#40998)"
)
# Contract: $repoValid is only set when the HEAD probe succeeded too.
assert re.search(
r"if \(\$revParseOk -and \$statusOk -and \$hasCommit\) \{",
text,
), "repo validity must be gated on $hasCommit, not just rev-parse + status"
# Cleanup must be non-destructive: move the broken checkout aside, never
# `Remove-Item -Recurse -Force` it (review feedback on #40998).
assert "Move-Item -LiteralPath $InstallDir" in text, (
"install.ps1 must move an invalid checkout aside, not delete it"
)
assert "Remove-Item -Recurse -Force $InstallDir -ErrorAction Stop" not in text, (
"the destructive wipe of an existing install dir must be gone "
"(transient cleanup of a just-failed clone is fine)"
)
|