test: distinguish real git binary from pythongit shim in interop tests

CI installs the package, which adds a 'git' console script that shadows
the real git on PATH. Interop tests doing subprocess.run(['git', ...])
were therefore invoking pythongit-against-itself, not pythongit-against-
real-git.

Fix: tests now call conftest.real_git() which walks PATH and known
absolute paths, identifying real git by its '--version' output starting
with 'git version ' (pythongit's prints 'pygit version '). Skips
interop assertions when no real git is found.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: blhsing

tests/conftest.py

@@ -2,6 +2,8 @@
 from __future__ import annotations
 
 import os
+import shutil
+import subprocess
 import sys
 import tempfile
 from pathlib import Path
@@ -12,6 +14,50 @@
 sys.path.insert(0, str(ROOT))
 
 
+def _is_real_git(path: str) -> bool:
+    """A real git binary identifies itself as 'git version X.Y.Z'. Pythongit's
+    `git` shim prints 'pygit version ...' for --version. Use this to
+    distinguish them when pythongit is installed into the same venv."""
+    try:
+        r = subprocess.run([path, "--version"], capture_output=True, text=True, timeout=5)
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+    if r.returncode != 0:
+        return False
+    out = (r.stdout or "") + (r.stderr or "")
+    # Real git prints 'git version 2.x.y'. Reject pythongit's 'pygit version ...'.
+    return out.startswith("git version ") and "pygit" not in out
+
+
+def real_git() -> str | None:
+    """Return path of a real git binary, or None if not available.
+
+    Walks PATH and tries every `git` it finds (in order), returning the first
+    that identifies as real git. Falls back to known absolute paths.
+    """
+    seen: set[str] = set()
+    for d in os.environ.get("PATH", "").split(os.pathsep):
+        if not d:
+            continue
+        for name in ("git", "git.exe"):
+            cand = os.path.join(d, name)
+            if cand in seen:
+                continue
+            seen.add(cand)
+            if os.path.isfile(cand) and _is_real_git(cand):
+                return cand
+    # Fallbacks
+    for cand in (
+        "/usr/bin/git", "/usr/local/bin/git",
+        "/opt/homebrew/bin/git", "/Library/Developer/CommandLineTools/usr/bin/git",
+        r"C:\Program Files\Git\bin\git.exe",
+        r"C:\Program Files\Git\cmd\git.exe",
+    ):
+        if cand not in seen and os.path.isfile(cand) and _is_real_git(cand):
+            return cand
+    return None
+
+
 @pytest.fixture
 def tmprepo(tmp_path: Path):
     """Initialize a fresh repository and chdir into it. Yields (Repository, Path)."""

tests/test_phase2.py

@@ -14,6 +14,15 @@
 from pythongit import cli  # noqa: E402
 
 
+def _git():
+    from conftest import real_git
+    return real_git()
+
+
+def git_available() -> bool:
+    return _git() is not None
+
+
 def run(*args: str) -> int:
     return cli.main(list(args))
 
@@ -73,16 +82,16 @@ def check(cond, label):
         run("branch", "cp")
         run("checkout", "cp")
         # reset cp to C3
-        c3 = subprocess.run(["git", "rev-parse", "HEAD^1"], cwd=tmp, capture_output=True, text=True).stdout.strip() if shutil.which("git") else None
+        c3 = subprocess.run([_git(), "rev-parse", "HEAD^1"], cwd=tmp, capture_output=True, text=True).stdout.strip() if git_available() else None
         if c3:
             run("reset", "--hard", c3)
-            feat_tip = subprocess.run(["git", "rev-parse", "feat"], cwd=tmp, capture_output=True, text=True).stdout.strip()
+            feat_tip = subprocess.run([_git(), "rev-parse", "feat"], cwd=tmp, capture_output=True, text=True).stdout.strip()
             rc = run("cherry-pick", feat_tip)
             check(rc == 0, "cherry-pick clean")
 
         # revert
         rc = run("log", "--oneline", "-n", "1")
-        head = subprocess.run(["git", "rev-parse", "HEAD"], cwd=tmp, capture_output=True, text=True).stdout.strip() if shutil.which("git") else None
+        head = subprocess.run([_git(), "rev-parse", "HEAD"], cwd=tmp, capture_output=True, text=True).stdout.strip() if git_available() else None
         if head:
             rc = run("revert", head)
             check(rc == 0, "revert HEAD succeeds")

tests/test_phase4.py

@@ -16,6 +16,15 @@
 from pythongit import cli  # noqa: E402
 
 
+def _git():
+    from conftest import real_git
+    return real_git()
+
+
+def git_available() -> bool:
+    return _git() is not None
+
+
 def run(*args: str) -> int:
     return cli.main(list(args))
 
@@ -55,8 +64,8 @@ def check(cond, label):
         check(rc == 0, "verify-pack")
 
         # real git can read our pack
-        if shutil.which("git"):
-            r = subprocess.run(["git", "verify-pack", "-v", str(packs[0])], cwd=tmp,
+        if git_available():
+            r = subprocess.run([_git(), "verify-pack", "-v", str(packs[0])], cwd=tmp,
                                capture_output=True, text=True)
             check(r.returncode == 0, f"real git verify-pack passes (stderr={r.stderr.strip()[:120]})")
 

tests/test_smoke.py

@@ -25,7 +25,13 @@ def run(*args: str) -> int:
 
 
 def git_available() -> bool:
-    return shutil.which("git") is not None
+    from conftest import real_git
+    return real_git() is not None
+
+
+def _git():
+    from conftest import real_git
+    return real_git()
 
 
 def main() -> int:
@@ -65,13 +71,13 @@ def check(cond: bool, label: str) -> None:
 
         # write-tree round-trip via real git, if available
         if git_available():
-            r = subprocess.run(["git", "log", "--oneline"], cwd=tmp, capture_output=True, text=True)
+            r = subprocess.run([_git(), "log", "--oneline"], cwd=tmp, capture_output=True, text=True)
             check(r.returncode == 0 and r.stdout.strip() != "", f"git log reads our commit: {r.stdout.strip()!r}")
 
-            r = subprocess.run(["git", "fsck", "--no-dangling"], cwd=tmp, capture_output=True, text=True)
+            r = subprocess.run([_git(), "fsck", "--no-dangling"], cwd=tmp, capture_output=True, text=True)
             check(r.returncode == 0, f"git fsck passes (stderr={r.stderr.strip()!r})")
 
-            r = subprocess.run(["git", "cat-file", "-p", "HEAD^{tree}"], cwd=tmp, capture_output=True, text=True)
+            r = subprocess.run([_git(), "cat-file", "-p", "HEAD^{tree}"], cwd=tmp, capture_output=True, text=True)
             ok = r.returncode == 0 and "hello.txt" in r.stdout
             check(ok, f"git can read tree (rc={r.returncode} stdout={r.stdout!r} stderr={r.stderr!r})")
 
@@ -90,7 +96,7 @@ def check(cond: bool, label: str) -> None:
         run("commit", "-m", "feature commit")
 
         if git_available():
-            r = subprocess.run(["git", "log", "--all", "--oneline"], cwd=tmp, capture_output=True, text=True)
+            r = subprocess.run([_git(), "log", "--all", "--oneline"], cwd=tmp, capture_output=True, text=True)
             lines = [l for l in r.stdout.splitlines() if l.strip()]
             check(len(lines) == 3,
                   f"git sees 3 commits across branches (got {len(lines)}; rc={r.returncode} stdout={r.stdout!r} stderr={r.stderr!r})")

tests/unit_index.py

@@ -84,16 +84,18 @@ def test_upsert_replaces_same_path_same_stage():
 
 def test_real_git_reads_our_index_file(tmprepo):
     """Real git ls-files should read pythongit's index correctly."""
-    import shutil, subprocess
-    if not shutil.which("git"):
-        return  # skip silently if git not installed
+    import subprocess
+    from conftest import real_git
+    gitbin = real_git()
+    if not gitbin:
+        return  # skip silently if real git not installed
     repo, _ = tmprepo
     from pythongit import objects as objs
     blob_sha = objs.write_object(repo, "blob", b"hi\n")
     idx = Index()
     idx.entries.append(IndexEntry(mode=REG_MODE, sha=blob_sha, path="hi.txt"))
     write_index(repo, idx)
-    r = subprocess.run(["git", "ls-files", "--stage"], cwd=repo.path,
+    r = subprocess.run([gitbin, "ls-files", "--stage"], cwd=repo.path,
                        capture_output=True, text=True)
     assert r.returncode == 0
     assert "hi.txt" in r.stdout

tests/unit_integration.py

@@ -182,15 +182,17 @@ def test_pack_objects_and_unpack(tmprepo):
 
 
 def test_commit_graph_binary_passes_real_git(tmprepo):
-    import shutil, subprocess
-    if not shutil.which("git"):
+    import subprocess
+    from conftest import real_git
+    gitbin = real_git()
+    if not gitbin:
         return
     from tests.conftest import commit_one
     repo, _ = tmprepo
     for i in range(5):
         commit_one(repo, "a", f"v{i}\n", f"c{i}")
     assert cli_run("commit-graph", "write") == 0
-    r = subprocess.run(["git", "commit-graph", "verify"], cwd=repo.path,
+    r = subprocess.run([gitbin, "commit-graph", "verify"], cwd=repo.path,
                        capture_output=True, text=True)
     assert r.returncode == 0, r.stderr
 

tests/unit_pack.py

@@ -71,8 +71,10 @@ def test_build_pack_then_read_back(tmprepo):
 
 
 def test_real_git_verifies_our_pack(tmprepo):
-    import shutil, subprocess, hashlib
-    if not shutil.which("git"):
+    import subprocess, hashlib
+    from conftest import real_git
+    gitbin = real_git()
+    if not gitbin:
         return
     repo, _ = tmprepo
     from pythongit import objects as objs
@@ -93,7 +95,7 @@ def test_real_git_verifies_our_pack(tmprepo):
     i.write_bytes(idx_bytes)
     # Git verify-pack must succeed — output format varies across git versions
     # so we only assert on the exit code, not on the summary text.
-    r = subprocess.run(["git", "verify-pack", "-v", str(p)], capture_output=True, text=True)
+    r = subprocess.run([gitbin, "verify-pack", "-v", str(p)], capture_output=True, text=True)
     assert r.returncode == 0, f"stderr={r.stderr!r} stdout={r.stdout!r}"
     # Every blob sha we wrote must appear in the verify output.
     for sha in blobs: