diff --git a/cmd/bd/BUILD.bazel b/cmd/bd/BUILD.bazel index 89eeab6e3..409654492 100644 --- a/cmd/bd/BUILD.bazel +++ b/cmd/bd/BUILD.bazel @@ -1243,6 +1243,7 @@ go_test( "test_helpers_test.go", "test_repo_beads_guard_darwin_test.go", "test_repo_beads_guard_test.go", + "test_repo_git_guard_test.go", "test_wait_helper_test.go", "thread_test.go", "tips_example_test.go", diff --git a/cmd/bd/config_apply_test.go b/cmd/bd/config_apply_test.go index d2e7ba06a..84cfc27f8 100644 --- a/cmd/bd/config_apply_test.go +++ b/cmd/bd/config_apply_test.go @@ -193,32 +193,52 @@ func TestApplyServerSkipsWhenAutoStartDisabled(t *testing.T) { } } +// isolatedApplyFixture builds a throwaway git repo with a .beads dir for the +// runApply tests. runApply(false) is a live apply: it inspects AND MUTATES the +// repository that owns the process cwd (hook reinstalls, hooksPath mkdirs). +// Run bare from the package dir, that repository is this checkout — the r880 +// host .git clobber (wy-qlvlmf) — so these tests must always chdir into a +// fixture they own first. +func isolatedApplyFixture(t *testing.T) string { + t.Helper() + dir := t.TempDir() + initGitRepoAt(t, dir) + if err := os.MkdirAll(filepath.Join(dir, ".beads"), 0o755); err != nil { + t.Fatalf("create fixture .beads: %v", err) + } + return dir +} + func TestRunApplyAllOK(t *testing.T) { t.Setenv("BEADS_TEST_IGNORE_REPO_CONFIG", "1") - // In a test environment with no drift, all results should be ok or skipped - results := runApply(false) - if len(results) != 3 { - t.Errorf("expected 3 results, got %d", len(results)) - } - for _, r := range results { - if r.Status == applyStatusError { - t.Errorf("unexpected error for check %q: %s", r.Check, r.Error) + runInDir(t, isolatedApplyFixture(t), func() { + // In a test environment with no drift, all results should be ok or skipped + results := runApply(false) + if len(results) != 3 { + t.Errorf("expected 3 results, got %d", len(results)) } - } + for _, r := range results { + if r.Status == applyStatusError { + t.Errorf("unexpected error for check %q: %s", r.Check, r.Error) + } + } + }) } func TestRunApplyDryRun(t *testing.T) { t.Setenv("BEADS_TEST_IGNORE_REPO_CONFIG", "1") - results := runApply(true) - if len(results) != 3 { - t.Errorf("expected 3 results, got %d", len(results)) - } - // In dry-run, no actions should be "applied" - for _, r := range results { - if r.Status == applyStatusApplied { - t.Errorf("dry-run should not apply actions, but check %q was applied", r.Check) + runInDir(t, isolatedApplyFixture(t), func() { + results := runApply(true) + if len(results) != 3 { + t.Errorf("expected 3 results, got %d", len(results)) } - } + // In dry-run, no actions should be "applied" + for _, r := range results { + if r.Status == applyStatusApplied { + t.Errorf("dry-run should not apply actions, but check %q was applied", r.Check) + } + } + }) } func TestDriftDomainsGroupsDottedChecks(t *testing.T) { diff --git a/cmd/bd/doctor/dolt_e2e_test.go b/cmd/bd/doctor/dolt_e2e_test.go index 6402a4348..6bae08033 100644 --- a/cmd/bd/doctor/dolt_e2e_test.go +++ b/cmd/bd/doctor/dolt_e2e_test.go @@ -57,6 +57,14 @@ func TestMain(m *testing.M) { } func testMainInner(m *testing.M) int { + // A GIT_DIR/GIT_WORK_TREE leaked in from the invoking shell or a git hook + // would route the fixture `git init`/`git config` writes in this suite + // into that repository: the host checkout in the r880 clobber (wy-qlvlmf). + if err := testutil.UnsetGitRepoLocationEnv(); err != nil { + fmt.Fprintf(os.Stderr, "FATAL: %v\n", err) + return 1 + } + os.Setenv("BEADS_TEST_MODE", "1") // AD-01 (be-c5p): doctor e2e tests connect to a per-package test server. // The dolt.New database-name firewall requires this opt-in to allow diff --git a/cmd/bd/doctor/fix/git_repo_template_test.go b/cmd/bd/doctor/fix/git_repo_template_test.go index 869520510..04e9854cf 100644 --- a/cmd/bd/doctor/fix/git_repo_template_test.go +++ b/cmd/bd/doctor/fix/git_repo_template_test.go @@ -30,8 +30,13 @@ func initGitTemplate() { } gitTemplateDir = dir + // The template is built once, inside whichever test asks first. Its + // writes must land in dir even if that test set GIT_DIR/GIT_WORK_TREE, + // or they hit that repository (the r880 clobber class, wy-qlvlmf). + env := testutil.WithoutGitRepoLocationEnv(os.Environ()) cmd := gitCommand("init", "--initial-branch=main") cmd.Dir = dir + cmd.Env = env if err := cmd.Run(); err != nil { gitTemplateErr = fmt.Errorf("git init failed: %w", err) return @@ -43,6 +48,7 @@ func initGitTemplate() { } { cmd = gitCommand(args...) cmd.Dir = dir + cmd.Env = env if err := cmd.Run(); err != nil { gitTemplateErr = fmt.Errorf("git %v failed: %w", args, err) return diff --git a/cmd/bd/doctor/fix/metadata_test.go b/cmd/bd/doctor/fix/metadata_test.go index fa77c2d40..957abada5 100644 --- a/cmd/bd/doctor/fix/metadata_test.go +++ b/cmd/bd/doctor/fix/metadata_test.go @@ -12,6 +12,7 @@ import ( mysql "github.com/go-sql-driver/mysql" "github.com/steveyegge/beads/internal/configfile" + "github.com/steveyegge/beads/internal/testutil" ) // TestFixMissingMetadata_NotBeadsWorkspace verifies that FixMissingMetadata @@ -199,8 +200,21 @@ func TestFixMissingMetadataJSON_NotBeadsWorkspace(t *testing.T) { } // setupGitRepoInDir initializes a git repo in the given directory with a remote. +// +// Every step is fatal on failure, the dir must exist, and the child env is +// scrubbed of the git vars that name a repository (GIT_DIR, GIT_WORK_TREE, +// ...). An empty dir, a swallowed config failure, or a leaked GIT_DIR each make +// these writes land in whatever repository git resolves from the process +// environment — the host checkout's own .git/config in the r880 clobber +// (wy-qlvlmf), where this helper's remote.origin.url overwrote the real origin. func setupGitRepoInDir(t *testing.T, dir string) { t.Helper() + if dir == "" { + t.Fatal("setupGitRepoInDir: empty dir would run git against the host checkout") + } + if info, err := os.Stat(dir); err != nil || !info.IsDir() { + t.Fatalf("setupGitRepoInDir: %q is not an existing directory (err=%v)", dir, err) + } cmds := [][]string{ {"git", "init"}, {"git", "config", "user.email", "test@test.com"}, @@ -211,11 +225,9 @@ func setupGitRepoInDir(t *testing.T, dir string) { for _, args := range cmds { cmd := exec.Command(args[0], args[1:]...) cmd.Dir = dir - if err := cmd.Run(); err != nil { - // git init must succeed; config failures are non-fatal - if args[1] == "init" { - t.Fatalf("git init failed: %v", err) - } + cmd.Env = testutil.WithoutGitRepoLocationEnv(os.Environ()) + if out, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("%v failed: %v\n%s", args, err, out) } } } diff --git a/cmd/bd/doctor/fix/testmain_cgo_test.go b/cmd/bd/doctor/fix/testmain_cgo_test.go index 19929519e..8157653f8 100644 --- a/cmd/bd/doctor/fix/testmain_cgo_test.go +++ b/cmd/bd/doctor/fix/testmain_cgo_test.go @@ -21,6 +21,14 @@ func TestMain(m *testing.M) { // exits — os.Exit skips deferred calls, so TestMain itself must never defer // anything (be-5kkk6). func testMainInner(m *testing.M) int { + // A GIT_DIR/GIT_WORK_TREE leaked in from the invoking shell or a git hook + // would route the fixture `git init`/`git config` writes in this suite + // into that repository: the host checkout in the r880 clobber (wy-qlvlmf). + if err := testutil.UnsetGitRepoLocationEnv(); err != nil { + fmt.Fprintf(os.Stderr, "FATAL: %v\n", err) + return 1 + } + os.Setenv("BEADS_TEST_MODE", "1") // AD-01 (be-c5p): allow doctor/fix tests through the dolt.New // database-name firewall when they connect to the spawned test server. diff --git a/cmd/bd/doctor/fix/testmain_nocgo_test.go b/cmd/bd/doctor/fix/testmain_nocgo_test.go index 2329d310e..62126ea8e 100644 --- a/cmd/bd/doctor/fix/testmain_nocgo_test.go +++ b/cmd/bd/doctor/fix/testmain_nocgo_test.go @@ -19,6 +19,14 @@ func TestMain(m *testing.M) { } func testMainInner(m *testing.M) int { + // A GIT_DIR/GIT_WORK_TREE leaked in from the invoking shell or a git hook + // would route the fixture `git init`/`git config` writes in this suite + // into that repository: the host checkout in the r880 clobber (wy-qlvlmf). + if err := testutil.UnsetGitRepoLocationEnv(); err != nil { + fmt.Fprintf(os.Stderr, "FATAL: %v\n", err) + return 1 + } + // Clear out the roots of earlier runs of this suite whose process is // gone, before claiming one of our own. A `go test -timeout` panic skips // every defer here AND the post-run sweep, so the servers such a run diff --git a/cmd/bd/doctor/git_repo_template_test.go b/cmd/bd/doctor/git_repo_template_test.go index 241d6f57d..d6533587e 100644 --- a/cmd/bd/doctor/git_repo_template_test.go +++ b/cmd/bd/doctor/git_repo_template_test.go @@ -30,8 +30,13 @@ func initGitTemplate() { } gitTemplateDir = dir + // The template is built once, inside whichever test asks first. Its + // writes must land in dir even if that test set GIT_DIR/GIT_WORK_TREE, + // or they hit that repository (the r880 clobber class, wy-qlvlmf). + env := testutil.WithoutGitRepoLocationEnv(os.Environ()) cmd := gitCommand("init", "--initial-branch=main") cmd.Dir = dir + cmd.Env = env if err := cmd.Run(); err != nil { gitTemplateErr = fmt.Errorf("git init failed: %w", err) return @@ -43,6 +48,7 @@ func initGitTemplate() { } { cmd = gitCommand(args...) cmd.Dir = dir + cmd.Env = env if err := cmd.Run(); err != nil { gitTemplateErr = fmt.Errorf("git %v failed: %w", args, err) return diff --git a/cmd/bd/doctor/git_test.go b/cmd/bd/doctor/git_test.go index 45b9214ef..fb5bd1eee 100644 --- a/cmd/bd/doctor/git_test.go +++ b/cmd/bd/doctor/git_test.go @@ -5,6 +5,8 @@ import ( "path/filepath" "strings" "testing" + + "github.com/steveyegge/beads/internal/testutil" ) // setupGitRepo creates a temporary git repository for testing @@ -51,6 +53,15 @@ func TestCheckGitHooks(t *testing.T) { // setupGitRepoInDir initializes a git repo in the given directory with .beads func setupGitRepoInDir(t *testing.T, dir string) { t.Helper() + if dir == "" { + // cmd.Dir = "" inherits the test process cwd — this checkout's own + // package dir — so the config write below would hit the host .git + // (the r880 clobber class, wy-qlvlmf). + t.Fatal("setupGitRepoInDir: empty dir would run git against the host checkout") + } + if info, err := os.Stat(dir); err != nil || !info.IsDir() { + t.Fatalf("setupGitRepoInDir: %q is not an existing directory (err=%v)", dir, err) + } // Create .beads directory beadsDir := filepath.Join(dir, ".beads") @@ -68,11 +79,14 @@ func setupGitRepoInDir(t *testing.T, dir string) { } // Force repo-local hooks path for test isolation. This prevents global - // core.hooksPath from affecting hook detection behavior in tests. + // core.hooksPath from affecting hook detection behavior in tests. The env + // scrub keeps a leaked GIT_DIR/GIT_WORK_TREE from routing the write at + // some other repository. cmd := gitCommand("config", "core.hooksPath", ".git/hooks") cmd.Dir = dir - if err := cmd.Run(); err != nil { - t.Fatalf("failed to set core.hooksPath for test repo: %v", err) + cmd.Env = testutil.WithoutGitRepoLocationEnv(os.Environ()) + if out, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("failed to set core.hooksPath for test repo: %v\n%s", err, out) } } diff --git a/cmd/bd/doctor/testmain_nocgo_test.go b/cmd/bd/doctor/testmain_nocgo_test.go index 108dd6ed6..b549611b2 100644 --- a/cmd/bd/doctor/testmain_nocgo_test.go +++ b/cmd/bd/doctor/testmain_nocgo_test.go @@ -19,6 +19,14 @@ func TestMain(m *testing.M) { } func testMainInner(m *testing.M) int { + // A GIT_DIR/GIT_WORK_TREE leaked in from the invoking shell or a git hook + // would route the fixture `git init`/`git config` writes in this suite + // into that repository: the host checkout in the r880 clobber (wy-qlvlmf). + if err := testutil.UnsetGitRepoLocationEnv(); err != nil { + fmt.Fprintf(os.Stderr, "FATAL: %v\n", err) + return 1 + } + // Clear out the roots of earlier runs of this suite whose process is // gone, before claiming one of our own. A `go test -timeout` panic skips // every defer here AND the post-run sweep, so the servers such a run diff --git a/cmd/bd/git_repo_template_test.go b/cmd/bd/git_repo_template_test.go index 5fdb0978b..9468f6d92 100644 --- a/cmd/bd/git_repo_template_test.go +++ b/cmd/bd/git_repo_template_test.go @@ -33,8 +33,13 @@ func initGitTemplate() { } gitTemplateDir = dir + // The template is built once, inside whichever test asks first. Its + // writes must land in dir even if that test set GIT_DIR/GIT_WORK_TREE, + // or they hit that repository (the r880 clobber class, wy-qlvlmf). + env := testutil.WithoutGitRepoLocationEnv(os.Environ()) cmd := gitCommand("init", "--initial-branch=main") cmd.Dir = dir + cmd.Env = env if err := cmd.Run(); err != nil { gitTemplateErr = fmt.Errorf("git init failed: %w", err) return @@ -46,6 +51,7 @@ func initGitTemplate() { } { cmd = gitCommand(args...) cmd.Dir = dir + cmd.Env = env if err := cmd.Run(); err != nil { gitTemplateErr = fmt.Errorf("git %v failed: %w", args, err) return diff --git a/cmd/bd/test_helpers_pure_test.go b/cmd/bd/test_helpers_pure_test.go index 6a0fae163..9e1e07654 100644 --- a/cmd/bd/test_helpers_pure_test.go +++ b/cmd/bd/test_helpers_pure_test.go @@ -29,6 +29,7 @@ import ( "github.com/steveyegge/beads/internal/config" "github.com/steveyegge/beads/internal/storage" + "github.com/steveyegge/beads/internal/testutil" "github.com/steveyegge/beads/internal/testutil/bazeltest" ) @@ -440,12 +441,21 @@ func buildBDForInitTests(t *testing.T) string { // runGitForBootstrapTest runs a git subcommand in the given directory and // fails the test on error. Used by bootstrap and init-safety subprocess tests. +// +// An empty dir never inherits the test process cwd: that cwd is this package's +// directory inside this checkout, so a cwd-resolved git write (config, init) +// lands in the checkout's own .git — the r880 host .git/config clobber +// (wy-qlvlmf). Callers that pass "" operate on absolute paths in args and get +// a neutral scratch cwd instead. The env scrub keeps a leaked GIT_DIR / +// GIT_WORK_TREE from routing the command at some other repository. func runGitForBootstrapTest(t *testing.T, dir string, args ...string) { t.Helper() cmd := gitCommand(args...) - if dir != "" { - cmd.Dir = dir + if dir == "" { + dir = t.TempDir() } + cmd.Dir = dir + cmd.Env = testutil.WithoutGitRepoLocationEnv(os.Environ()) output, err := cmd.CombinedOutput() if err != nil { t.Fatalf("git %v failed: %v\n%s", args, err, string(output)) @@ -459,9 +469,15 @@ func runGitForBootstrapTest(t *testing.T, dir string, args ...string) { // This lives in the pure-Go helper file, not alongside the embedded-Dolt // helpers: cmd/bd/where_test.go carries no build tag, so it compiles under // CGO_ENABLED=0 where every `//go:build cgo` file is excluded. Keep this -// helper stdlib-only and keep it here. +// helper free of cgo-only dependencies and keep it here. func initGitRepoAt(t *testing.T, dir string) { t.Helper() + if dir == "" { + // cmd.Dir = "" inherits the test process cwd — this checkout's own + // package dir — so the init and configs would hit the host .git + // (the r880 clobber class, wy-qlvlmf). + t.Fatal("initGitRepoAt: empty dir would run git against the host checkout") + } for _, args := range [][]string{ {"init"}, {"config", "user.email", "test@test.com"}, @@ -471,6 +487,7 @@ func initGitRepoAt(t *testing.T, dir string) { } { cmd := gitCommand(args...) cmd.Dir = dir + cmd.Env = testutil.WithoutGitRepoLocationEnv(os.Environ()) if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("git %s failed: %v\n%s", args[0], err, out) } diff --git a/cmd/bd/test_repo_beads_guard_test.go b/cmd/bd/test_repo_beads_guard_test.go index e1c9616dd..e5876e5b5 100644 --- a/cmd/bd/test_repo_beads_guard_test.go +++ b/cmd/bd/test_repo_beads_guard_test.go @@ -1,10 +1,12 @@ package main import ( + "errors" "fmt" "os" "os/exec" "path/filepath" + "slices" "strings" "testing" @@ -130,6 +132,21 @@ func testMainInner(m *testing.M) int { } beads.ResetCaches() + // Drop inherited git repository-location vars (GIT_DIR, GIT_WORK_TREE, + // GIT_COMMON_DIR, GIT_INDEX_FILE, GIT_CONFIG, ...) for the whole test + // process. Fixture helpers in this package run `git config`/`git init` + // with only cmd.Dir set; a location var leaked in from the invoking shell + // or a hook overrides that Dir and points every such write at a + // repository the suite does not own — one of the vectors behind the r880 + // host .git/config clobber (wy-qlvlmf). GIT_CEILING_DIRECTORIES, + // GIT_CONFIG_GLOBAL and GIT_CONFIG_NOSYSTEM stay: tools/bazel/test_env.sh + // sets them on purpose. Tests that need a location var set it per-test + // with t.Setenv. + if err := testutil.UnsetGitRepoLocationEnv(); err != nil { + fmt.Fprintf(os.Stderr, "FATAL: %v\n", err) + return 1 + } + // Separately bound any literal ancestor-directory walk that starts // at (or under) this checkout: the pin above only defeats the // git-context-cache vector, not a plain upward walk from a worktree @@ -356,7 +373,26 @@ func testMainInner(m *testing.M) int { guardDirs = append(guardDirs, fallbackBeadsDir) } } - if len(guardDirs) == 0 { + + // The checkout's own git state is guarded alongside its .beads state: on + // 2026-10-16 a `go test ./cmd/bd` run from a linked worktree rewrote the + // host rig's shared .git/config (core.bare=true, extensions.worktreeConfig, + // a test remote.origin.url over the real origin) and its hooks, breaking + // every worktree of that clone (wy-qlvlmf, r880). The common config and + // hooks are shared by every worktree of the clone, so the keys other + // worktrees rewrite routinely (branch tracking, a remote other than origin + // added or removed whole) only draw a note; any other change means a test + // most likely ran git against this checkout instead of a fixture it owns. + gitDirs, err := locateRepoGitDirs(repoRoot) + if err != nil { + fmt.Fprintf(os.Stderr, "Warning: this checkout's own git state is not guarded in this run: %v\n", err) + } + var gitStateBefore repoGitState + if gitDirs.common != "" { + gitStateBefore = readRepoGitState(gitDirs) + } + + if len(guardDirs) == 0 && gitDirs.common == "" { return runTestsAndSweep(m) } @@ -417,9 +453,360 @@ func testMainInner(m *testing.M) int { } } + if gitDirs.common != "" { + changes := diffRepoGitState(gitStateBefore, readRepoGitState(gitDirs)) + // PinSuiteTempRoot pointed TMPDIR at the suite root, which the + // deferred cleanup deletes; keep the pre-run copies beside it. + report, failed := reportGitStateChanges(changes, gitStateBefore, filepath.Dir(testTempRoot)) + fmt.Fprint(os.Stderr, report) + if failed && code == 0 { + code = 1 + } + } + return code } +// repoGitDirs names a checkout's git directories: gitDir is its own (a linked +// worktree's .git/worktrees/), common is the one every worktree of the +// clone shares. They are the same directory for a main checkout. +type repoGitDirs struct { + gitDir, common string +} + +func (d repoGitDirs) commonConfig() string { return filepath.Join(d.common, "config") } + +// worktreeConfig is the checkout's own config.worktree. A main checkout's sits +// in the common dir beside the shared config. With extensions.worktreeConfig +// set, git reads it after the shared config, so its keys win, and +// `git config --worktree` writes there. +func (d repoGitDirs) worktreeConfig() string { + if d.gitDir == "" { + return "" + } + return filepath.Join(d.gitDir, "config.worktree") +} + +// locateRepoGitDirs resolves repoRoot's git directories once, before the run, +// so the post-run read looks at the same files even if a test rewrote the +// checkout's .git pointer. A repoRoot outside any checkout (Bazel runfiles, a +// source tarball) has nothing to guard and is not an error. +func locateRepoGitDirs(repoRoot string) (repoGitDirs, error) { + if repoRoot == "" { + return repoGitDirs{}, nil + } + cmd := gitCommand("-C", repoRoot, "rev-parse", "--git-dir", "--git-common-dir") + var stderr strings.Builder + cmd.Stderr = &stderr + out, err := cmd.Output() + if err != nil { + if _, statErr := os.Lstat(filepath.Join(repoRoot, ".git")); errors.Is(statErr, os.ErrNotExist) { + return repoGitDirs{}, nil + } + return repoGitDirs{}, fmt.Errorf("git rev-parse in %s: %w: %s", repoRoot, err, strings.TrimSpace(stderr.String())) + } + lines := strings.Split(strings.TrimSpace(string(out)), "\n") + if len(lines) < 2 { + return repoGitDirs{}, fmt.Errorf("git rev-parse in %s: unexpected output %q", repoRoot, out) + } + dirs := repoGitDirs{ + gitDir: resolveGitPath(repoRoot, strings.TrimSpace(lines[0])), + common: resolveGitPath(repoRoot, strings.TrimSpace(lines[1])), + } + if dirs.common == "" { + return repoGitDirs{}, fmt.Errorf("git rev-parse in %s: no common git dir in %q", repoRoot, out) + } + return dirs, nil +} + +// repoGitState captures the parts of a checkout's own git state that the r880 +// incident showed a test escape mutates: the common (shared) config, the +// checkout's own config.worktree, and every file under the common hooks dir. +// Files are keyed by absolute path, and a missing one is recorded as missing, +// so a deletion and a re-creation both show up. +type repoGitState struct { + dirs repoGitDirs + files map[string]gitFileSnap +} + +type gitFileSnap struct { + present bool + data string +} + +func readRepoGitState(dirs repoGitDirs) repoGitState { + state := repoGitState{dirs: dirs, files: map[string]gitFileSnap{}} + snapFile := func(p string) { + data, err := os.ReadFile(p) + state.files[p] = gitFileSnap{present: err == nil, data: string(data)} + } + snapFile(dirs.commonConfig()) + if p := dirs.worktreeConfig(); p != "" { + snapFile(p) + } + _ = filepath.Walk(filepath.Join(dirs.common, "hooks"), func(path string, info os.FileInfo, err error) error { + if err != nil || info == nil || info.IsDir() { + return nil //nolint:nilerr // best-effort snapshot; a walk error just narrows what gets watched + } + snapFile(path) + return nil + }) + return state +} + +// gitStateChange is one watched git-state file that differs across the run. +// detail names what changed (config keys, or a file-level summary) and never +// echoes a value: configs carry remote URLs and can carry credentials. +type gitStateChange struct { + path string + detail string + routine bool +} + +// diffRepoGitState compares two readRepoGitState results. A common-config +// change is routine when every changed key is one that other worktrees of a +// shared clone rewrite as a matter of course (routineSharedConfigKey). Any +// other change (a hook file, config.worktree, core.*, user.*, extensions.*, an +// existing remote's url, origin added or removed) is the clobber class. +func diffRepoGitState(before, after repoGitState) []gitStateChange { + paths := make([]string, 0, len(before.files)) + for p := range before.files { + paths = append(paths, p) + } + for p := range after.files { + if _, ok := before.files[p]; !ok { + paths = append(paths, p) + } + } + slices.Sort(paths) + + var changes []gitStateChange + for _, p := range paths { + b, a := before.files[p], after.files[p] + switch { + case b == a: + continue + case !b.present: + changes = append(changes, gitStateChange{path: p, detail: fmt.Sprintf("new file (%d bytes)", len(a.data))}) + case !a.present: + changes = append(changes, gitStateChange{path: p, detail: fmt.Sprintf("deleted (was %d bytes)", len(b.data))}) + case p == before.dirs.commonConfig(): + changes = append(changes, diffGitConfig(p, b.data, a.data, true)) + case p == before.dirs.worktreeConfig(): + changes = append(changes, diffGitConfig(p, b.data, a.data, false)) + default: + changes = append(changes, gitStateChange{path: p, detail: fmt.Sprintf("changed (%d → %d bytes)", len(b.data), len(a.data))}) + } + } + return changes +} + +// diffGitConfig names the keys that differ between two versions of a git +// config file. shared marks the clone's common config, the only file where +// routine shared-clone keys do not count as a clobber. +func diffGitConfig(path, before, after string, shared bool) gitStateChange { + change := gitStateChange{path: path} + b, errBefore := gitConfigEntries(before) + a, errAfter := gitConfigEntries(after) + if err := errors.Join(errBefore, errAfter); err != nil { + change.detail = fmt.Sprintf("changed (%d → %d bytes), not parseable as git config: %v", len(before), len(after), err) + return change + } + var clobbered, routine []string + for _, key := range changedConfigKeys(b, a) { + if shared && routineSharedConfigKey(key, b, a) { + routine = append(routine, describeConfigKey(key, b, a)) + } else { + clobbered = append(clobbered, describeConfigKey(key, b, a)) + } + } + switch { + case len(clobbered) > 0: + change.detail = summarizeConfigKeys(clobbered) + if len(routine) > 0 { + change.detail += fmt.Sprintf("; also %d branch/remote key change(s)", len(routine)) + } + case len(routine) > 0: + change.routine = true + change.detail = summarizeConfigKeys(routine) + default: + // Same keys and values in different bytes: an empty section left + // behind by a removal, or reformatting. Nothing git reads changed. + change.routine = true + change.detail = "rewritten with no key or value change" + } + return change +} + +// gitConfigEntries parses git config file contents with git itself. `git +// config --file -` reads only stdin (no includes, no -c or env config), and +// each key maps to its raw records in file order, so a multi-valued key +// compares as a list. +func gitConfigEntries(data string) (map[string][]string, error) { + cmd := gitCommand("config", "--file", "-", "--list", "-z") + cmd.Dir = os.TempDir() + cmd.Stdin = strings.NewReader(data) + var stderr strings.Builder + cmd.Stderr = &stderr + out, err := cmd.Output() + if err != nil { + return nil, fmt.Errorf("%w: %s", err, strings.TrimSpace(stderr.String())) + } + entries := map[string][]string{} + for _, record := range strings.Split(string(out), "\x00") { + if record == "" { + continue + } + key, _, _ := strings.Cut(record, "\n") + entries[key] = append(entries[key], record) + } + return entries, nil +} + +func changedConfigKeys(before, after map[string][]string) []string { + var keys []string + for key, values := range before { + if !slices.Equal(values, after[key]) { + keys = append(keys, key) + } + } + for key := range after { + if _, ok := before[key]; !ok { + keys = append(keys, key) + } + } + slices.Sort(keys) + return keys +} + +// routineSharedConfigKey reports whether a change to key in a clone's common +// config is one that other worktrees of the clone make as a matter of course: +// branch tracking (branch..*, from checkout -b, push -u or branch -d in +// any worktree) and a remote other than origin added or removed whole +// (remote..* where that remote exists on only one side). A changed key +// of a remote that exists both before and after, such as remote.origin.url, +// is the r880 clobber. So is origin itself appearing or disappearing: the +// clone's worktrees do not add or remove it, while `git remote add origin` and +// `git remote remove origin` are common fixture steps. +func routineSharedConfigKey(key string, before, after map[string][]string) bool { + section, subsection, _ := splitConfigKey(key) + switch { + case subsection == "": + return false + case section == "branch": + return true + case section == "remote" && subsection != "origin": + return !hasConfigSubsection(before, section, subsection) || !hasConfigSubsection(after, section, subsection) + } + return false +} + +// splitConfigKey splits a `git config --list` key into section, subsection and +// variable name. A subsection may contain dots; section and name cannot. +func splitConfigKey(key string) (section, subsection, name string) { + first, last := strings.IndexByte(key, '.'), strings.LastIndexByte(key, '.') + if first < 0 || first == last { + section, name, _ = strings.Cut(key, ".") + return section, "", name + } + return key[:first], key[first+1 : last], key[last+1:] +} + +func hasConfigSubsection(entries map[string][]string, section, subsection string) bool { + for key := range entries { + if s, sub, _ := splitConfigKey(key); s == section && sub == subsection { + return true + } + } + return false +} + +func describeConfigKey(key string, before, after map[string][]string) string { + _, had := before[key] + _, has := after[key] + switch { + case !had: + return key + " added" + case !has: + return key + " removed" + } + return key + " changed" +} + +// summarizeConfigKeys joins key descriptions, capped so a sibling deleting a +// few hundred branches cannot flood the test log. +func summarizeConfigKeys(descriptions []string) string { + const limit = 12 + if len(descriptions) <= limit { + return strings.Join(descriptions, ", ") + } + return fmt.Sprintf("%s, and %d more", strings.Join(descriptions[:limit], ", "), len(descriptions)-limit) +} + +// reportGitStateChanges renders the guard's verdict on changes. Routine +// shared-clone changes get a NOTE and leave the run green: this suite and any +// other process using the clone could have made them. Anything else is an +// ERROR that fails the run, and the pre-run copies of the affected files are +// saved under saveDir so a clobbered config can be restored by hand. +func reportGitStateChanges(changes []gitStateChange, before repoGitState, saveDir string) (report string, failed bool) { + var routine, clobbered []gitStateChange + for _, c := range changes { + if c.routine { + routine = append(routine, c) + } else { + clobbered = append(clobbered, c) + } + } + var out strings.Builder + if len(routine) > 0 { + fmt.Fprintf(&out, "NOTE: this clone's shared git config changed during the run, by this suite or another "+ + "process using the clone; branch tracking and whole-remote changes are routine for a shared clone "+ + "(values not shown):\n%s\n", formatGitStateChanges(routine)) + } + if len(clobbered) > 0 { + saved := "pre-run copies of the changed files: " + if dir, err := saveGitStateBefore(saveDir, before, clobbered); err != nil { + saved = fmt.Sprintf("could not save pre-run copies of the changed files: %v", err) + } else { + saved += dir + } + fmt.Fprintf(&out, "ERROR: test suite modified this checkout's own git state "+ + "(the wy-qlvlmf host-clobber class — a test ran git against the checkout instead of a fixture, "+ + "unless another process rewrote the clone during the run; values not shown):\n%s\n%s\n", + formatGitStateChanges(clobbered), saved) + } + return out.String(), len(clobbered) > 0 +} + +func formatGitStateChanges(changes []gitStateChange) string { + lines := make([]string, 0, len(changes)) + for _, c := range changes { + lines = append(lines, fmt.Sprintf("- %s: %s", c.path, c.detail)) + } + return strings.Join(lines, "\n") +} + +// saveGitStateBefore copies the pre-run contents of each changed file that +// existed before the run into a new private directory under dir and returns +// that directory. Each copy is named after its original absolute path. +func saveGitStateBefore(dir string, before repoGitState, changes []gitStateChange) (string, error) { + out, err := os.MkdirTemp(dir, "bd-test-git-state-before-*") + if err != nil { + return "", err + } + flatten := strings.NewReplacer("/", "_", `\`, "_", ":", "_") + for _, c := range changes { + f := before.files[c.path] + if !f.present { + continue + } + if err := os.WriteFile(filepath.Join(out, flatten.Replace(c.path)), []byte(f.data), 0o600); err != nil { + return out, err + } + } + return out, nil +} + // worktreeFallbackBeadsDirDirect resolves the shared .beads directory a // linked worktree at repoRoot would fall back to, via a direct git shell-out // independent of internal/git's process-wide cache (which diff --git a/cmd/bd/test_repo_git_guard_test.go b/cmd/bd/test_repo_git_guard_test.go new file mode 100644 index 000000000..38d4e67e4 --- /dev/null +++ b/cmd/bd/test_repo_git_guard_test.go @@ -0,0 +1,508 @@ +package main + +import ( + "fmt" + "os" + "path/filepath" + "runtime" + "strings" + "testing" +) + +// These tests drive the TestMain git-state guard in +// test_repo_beads_guard_test.go against throwaway clones, never this checkout. +// Each fixture is a main checkout plus one linked worktree, the layout the +// r880 clobber broke (wy-qlvlmf): the guard reads the clone's shared common +// dir through the linked worktree, as it does when the suite runs from one. + +// guardFixtureHost appears in every remote URL the fixtures write. No guard +// report may contain it: configs carry remote URLs and can carry credentials. +const guardFixtureHost = "guard-fixture.invalid" + +// newGitGuardFixture returns a main checkout with an origin remote and an +// origin/main tracking ref, and a detached linked worktree of it. +func newGitGuardFixture(t *testing.T) (mainDir, linkedDir string) { + t.Helper() + root := t.TempDir() + mainDir = filepath.Join(root, "main") + if err := os.Mkdir(mainDir, 0o755); err != nil { + t.Fatal(err) + } + initGitRepoAt(t, mainDir) + runGitForBootstrapTest(t, mainDir, "commit", "--allow-empty", "-m", "init") + runGitForBootstrapTest(t, mainDir, "remote", "add", "origin", "https://"+guardFixtureHost+"/upstream.git") + runGitForBootstrapTest(t, mainDir, "update-ref", "refs/remotes/origin/main", "HEAD") + linkedDir = filepath.Join(root, "linked") + runGitForBootstrapTest(t, mainDir, "worktree", "add", "--detach", linkedDir) + return mainDir, linkedDir +} + +func locateGitGuardFixture(t *testing.T, dir string) repoGitDirs { + t.Helper() + dirs, err := locateRepoGitDirs(dir) + if err != nil { + t.Fatalf("locateRepoGitDirs(%s): %v", dir, err) + } + if dirs.common == "" { + t.Fatalf("locateRepoGitDirs(%s) found no common git dir", dir) + } + return dirs +} + +func evalRealPath(t *testing.T, p string) string { + t.Helper() + real, err := filepath.EvalSymlinks(p) + if err != nil { + t.Fatalf("EvalSymlinks(%s): %v", p, err) + } + return real +} + +func TestLocateRepoGitDirs(t *testing.T) { + mainDir, linkedDir := newGitGuardFixture(t) + wantCommon := evalRealPath(t, filepath.Join(mainDir, ".git")) + + t.Run("main checkout", func(t *testing.T) { + dirs := locateGitGuardFixture(t, mainDir) + if got := evalRealPath(t, dirs.common); got != wantCommon { + t.Errorf("common = %s, want %s", got, wantCommon) + } + if got := evalRealPath(t, dirs.gitDir); got != wantCommon { + t.Errorf("gitDir = %s, want the common dir %s", got, wantCommon) + } + // A main checkout has a config.worktree too, beside the shared config. + if got, want := dirs.worktreeConfig(), filepath.Join(dirs.gitDir, "config.worktree"); got != want { + t.Errorf("worktreeConfig() = %q, want %q", got, want) + } + }) + + t.Run("linked worktree", func(t *testing.T) { + dirs := locateGitGuardFixture(t, linkedDir) + if got := evalRealPath(t, dirs.common); got != wantCommon { + t.Errorf("common = %s, want %s", got, wantCommon) + } + if got, want := evalRealPath(t, dirs.gitDir), filepath.Join(wantCommon, "worktrees", "linked"); got != want { + t.Errorf("gitDir = %s, want %s", got, want) + } + if got, want := dirs.worktreeConfig(), filepath.Join(dirs.gitDir, "config.worktree"); got != want { + t.Errorf("worktreeConfig() = %q, want %q", got, want) + } + }) + + t.Run("not a checkout", func(t *testing.T) { + dir := t.TempDir() + // Keep git from walking up to a repository above the temp dir. + t.Setenv("GIT_CEILING_DIRECTORIES", filepath.Dir(dir)) + dirs, err := locateRepoGitDirs(dir) + if err != nil || dirs != (repoGitDirs{}) { + t.Fatalf("got (%+v, %v); a tree with no .git (Bazel runfiles, a tarball) has nothing to guard and is not an error", dirs, err) + } + }) + + t.Run("broken checkout", func(t *testing.T) { + dir := t.TempDir() + gitFile := "gitdir: " + filepath.Join(dir, "missing") + "\n" + if err := os.WriteFile(filepath.Join(dir, ".git"), []byte(gitFile), 0o644); err != nil { + t.Fatal(err) + } + if _, err := locateRepoGitDirs(dir); err == nil { + t.Fatal("no error for a .git that points nowhere; the guard would drop its git check without a warning") + } + }) +} + +// TestDiffRepoGitStateClassifiesGitWrites runs the git commands that other +// worktrees of a shared clone run routinely, and the writes the r880 clobber +// made, and checks which ones the guard lets through. +func TestDiffRepoGitStateClassifiesGitWrites(t *testing.T) { + type fixture struct { + mainDir, linkedDir string + dirs repoGitDirs + } + git := func(dir func(fixture) string, args ...string) func(*testing.T, fixture) { + return func(t *testing.T, f fixture) { + t.Helper() + runGitForBootstrapTest(t, dir(f), args...) + } + } + inMain := func(f fixture) string { return f.mainDir } + inLinked := func(f fixture) string { return f.linkedDir } + writeHook := func(name, content string) func(*testing.T, fixture) { + return func(t *testing.T, f fixture) { + t.Helper() + if err := os.WriteFile(filepath.Join(f.dirs.common, "hooks", name), []byte(content), 0o755); err != nil { + t.Fatal(err) + } + } + } + both := func(steps ...func(*testing.T, fixture)) func(*testing.T, fixture) { + return func(t *testing.T, f fixture) { + t.Helper() + for _, step := range steps { + step(t, f) + } + } + } + forkURL := "https://" + guardFixtureHost + "/fork.git" + + tests := []struct { + name string + guardMain bool // guard the main checkout instead of the linked worktree + setup func(*testing.T, fixture) // before the first snapshot + act func(*testing.T, fixture) // between the snapshots + routine bool + want []string // fragments of the one change's detail; nil means no change at all + }{ + { + name: "read-only git commands", + act: both(git(inMain, "rev-parse", "HEAD"), git(inLinked, "config", "--get", "user.email")), + }, + { + name: "branch tracking set up by another worktree", + act: git(inMain, "branch", "--track", "feature", "origin/main"), + routine: true, + want: []string{"branch.feature.remote added", "branch.feature.merge added"}, + }, + { + name: "tracked branch with a dotted name deleted", + setup: git(inMain, "branch", "--track", "release/v1.2", "origin/main"), + act: git(inMain, "branch", "-D", "release/v1.2"), + routine: true, + want: []string{"branch.release/v1.2.remote removed", "branch.release/v1.2.merge removed"}, + }, + { + name: "remote added", + act: git(inMain, "remote", "add", "fork", forkURL), + routine: true, + want: []string{"remote.fork.url added", "remote.fork.fetch added"}, + }, + { + name: "remote removed", + setup: git(inMain, "remote", "add", "fork", forkURL), + act: git(inMain, "remote", "remove", "fork"), + routine: true, + want: []string{"remote.fork.url removed", "remote.fork.fetch removed"}, + }, + { + name: "existing remote repointed", + act: git(inLinked, "remote", "set-url", "origin", "https://"+guardFixtureHost+"/test-fixture.git"), + want: []string{"remote.origin.url changed"}, + }, + { + // Unlike other remotes, the clone's origin is not added or + // removed whole by its worktrees. + name: "origin removed", + act: git(inLinked, "remote", "remove", "origin"), + want: []string{"remote.origin.url removed", "remote.origin.fetch removed"}, + }, + { + name: "origin added", + setup: git(inMain, "remote", "remove", "origin"), + act: git(inLinked, "remote", "add", "origin", "https://"+guardFixtureHost+"/test-fixture.git"), + want: []string{"remote.origin.url added", "remote.origin.fetch added"}, + }, + { + name: "core.bare flipped", + act: git(inLinked, "config", "core.bare", "true"), + want: []string{"core.bare changed"}, + }, + { + name: "worktree config extension enabled", + act: git(inLinked, "config", "extensions.worktreeConfig", "true"), + want: []string{"extensions.worktreeconfig added"}, + }, + { + name: "identity rewritten", + act: git(inLinked, "config", "user.email", "fixture@"+guardFixtureHost), + want: []string{"user.email changed"}, + }, + { + name: "hooks path rewritten", + act: git(inLinked, "config", "core.hooksPath", "/dev/null"), + want: []string{"core.hookspath changed"}, + }, + { + name: "clobber next to routine branch tracking", + act: both( + git(inMain, "branch", "--track", "feature", "origin/main"), + git(inLinked, "config", "core.bare", "true"), + ), + want: []string{"core.bare changed", "also 2 branch/remote key change(s)"}, + }, + { + name: "hook written", + act: writeHook("pre-commit", "#!/bin/sh\nexit 0\n"), + want: []string{"new file (17 bytes)"}, + }, + { + name: "hook rewritten", + setup: writeHook("pre-push", "#!/bin/sh\n"), + act: writeHook("pre-push", "#!/bin/sh\nexit 1\n"), + want: []string{"changed (10 → 17 bytes)"}, + }, + { + name: "hook deleted", + setup: writeHook("pre-push", "#!/bin/sh\n"), + act: func(t *testing.T, f fixture) { + if err := os.Remove(filepath.Join(f.dirs.common, "hooks", "pre-push")); err != nil { + t.Fatal(err) + } + }, + want: []string{"deleted (was 10 bytes)"}, + }, + { + // Only the common config gets the shared-clone allowance: nothing + // but this worktree writes its config.worktree. + name: "branch key written to config.worktree", + setup: both( + git(inMain, "config", "extensions.worktreeConfig", "true"), + git(inLinked, "config", "--worktree", "core.sparseCheckout", "false"), + ), + act: git(inLinked, "config", "--worktree", "branch.feature.remote", "origin"), + want: []string{"branch.feature.remote added"}, + }, + { + // A main checkout's config.worktree lives in the common dir, and + // with the extension on its keys override the shared config. + name: "main checkout's config.worktree written", + guardMain: true, + setup: both( + git(inMain, "config", "extensions.worktreeConfig", "true"), + git(inMain, "config", "--worktree", "core.sparseCheckout", "false"), + ), + act: git(inMain, "config", "--worktree", "core.hooksPath", "/dev/null"), + want: []string{"core.hookspath added"}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mainDir, linkedDir := newGitGuardFixture(t) + guarded := linkedDir + if tt.guardMain { + guarded = mainDir + } + f := fixture{mainDir: mainDir, linkedDir: linkedDir, dirs: locateGitGuardFixture(t, guarded)} + if tt.setup != nil { + tt.setup(t, f) + } + before := readRepoGitState(f.dirs) + tt.act(t, f) + changes := diffRepoGitState(before, readRepoGitState(f.dirs)) + + if tt.want == nil { + if len(changes) != 0 { + t.Fatalf("got changes %+v, want none", changes) + } + return + } + if len(changes) != 1 { + t.Fatalf("got %d changes %+v, want 1", len(changes), changes) + } + c := changes[0] + if c.routine != tt.routine { + t.Errorf("routine = %v, want %v (detail %q)", c.routine, tt.routine, c.detail) + } + for _, w := range tt.want { + if !strings.Contains(c.detail, w) { + t.Errorf("detail %q does not mention %q", c.detail, w) + } + } + if strings.Contains(c.detail, guardFixtureHost) { + t.Errorf("detail %q echoes a config value", c.detail) + } + }) + } +} + +func TestDiffGitConfigText(t *testing.T) { + const base = "[core]\n\tbare = false\n" + + "[remote \"origin\"]\n\turl = https://" + guardFixtureHost + "/upstream.git\n" + + "\tfetch = +refs/heads/*:refs/remotes/origin/*\n" + + tests := []struct { + name string + after string + shared bool + routine bool + want string + }{ + { + name: "comments and layout only", + after: "# reformatted\n[core]\nbare=false\n[remote \"origin\"]\n" + + "url = https://" + guardFixtureHost + "/upstream.git\nfetch = +refs/heads/*:refs/remotes/origin/*\n", + shared: true, + routine: true, + want: "rewritten with no key or value change", + }, + { + name: "empty section left behind by a removal", + after: base + "[branch \"gone\"]\n", + shared: true, + routine: true, + want: "rewritten with no key or value change", + }, + { + name: "not parseable", + after: "[core\n\tbare = true\n", + shared: true, + want: "not parseable as git config", + }, + { + name: "existing remote gains a fetch refspec", + after: base + "[remote \"origin\"]\n\tfetch = +refs/pull/*/head:refs/remotes/origin/pr/*\n", + shared: true, + want: "remote.origin.fetch changed", + }, + { + name: "remote with a dotted name added", + after: base + "[remote \"my.fork\"]\n\turl = https://" + guardFixtureHost + "/fork.git\n", + shared: true, + routine: true, + want: "remote.my.fork.url added", + }, + { + name: "branch key outside the shared config", + after: base + "[branch \"feature\"]\n\tremote = origin\n", + shared: false, + want: "branch.feature.remote added", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := diffGitConfig("config", base, tt.after, tt.shared) + if c.routine != tt.routine { + t.Errorf("routine = %v, want %v (detail %q)", c.routine, tt.routine, c.detail) + } + if !strings.Contains(c.detail, tt.want) { + t.Errorf("detail %q does not mention %q", c.detail, tt.want) + } + if strings.Contains(c.detail, guardFixtureHost) { + t.Errorf("detail %q echoes a config value", c.detail) + } + }) + } + + t.Run("long key lists are capped", func(t *testing.T) { + var after strings.Builder + after.WriteString(base) + for i := range 20 { + fmt.Fprintf(&after, "[branch \"b%02d\"]\n\tremote = origin\n", i) + } + c := diffGitConfig("config", base, after.String(), true) + if !c.routine || !strings.HasSuffix(c.detail, ", and 8 more") { + t.Errorf("got routine=%v detail %q, want a routine change listing 12 keys and 8 more", c.routine, c.detail) + } + }) +} + +func TestSplitConfigKey(t *testing.T) { + for _, tt := range []struct{ key, section, subsection, name string }{ + {"core.bare", "core", "", "bare"}, + {"remote.origin.url", "remote", "origin", "url"}, + {"branch.release/v1.2.merge", "branch", "release/v1.2", "merge"}, + {"remote.my.fork.gh-resolved", "remote", "my.fork", "gh-resolved"}, + } { + section, subsection, name := splitConfigKey(tt.key) + if section != tt.section || subsection != tt.subsection || name != tt.name { + t.Errorf("splitConfigKey(%q) = (%q, %q, %q), want (%q, %q, %q)", + tt.key, section, subsection, name, tt.section, tt.subsection, tt.name) + } + } +} + +func TestReportGitStateChanges(t *testing.T) { + common := t.TempDir() + configPath := filepath.Join(common, "config") + hookPath := filepath.Join(common, "hooks", "pre-commit") + const configBefore = "[core]\n\tbare = false\n" + before := repoGitState{ + dirs: repoGitDirs{gitDir: common, common: common}, + files: map[string]gitFileSnap{ + configPath: {present: true, data: configBefore}, + hookPath: {present: false}, + }, + } + routine := gitStateChange{path: configPath, detail: "branch.feature.remote added", routine: true} + clobber := gitStateChange{path: configPath, detail: "core.bare changed"} + newHook := gitStateChange{path: hookPath, detail: "new file (17 bytes)"} + const savedPrefix = "pre-run copies of the changed files: " + + t.Run("no changes", func(t *testing.T) { + if report, failed := reportGitStateChanges(nil, before, t.TempDir()); report != "" || failed { + t.Errorf("got (%q, %v), want an empty passing report", report, failed) + } + }) + + t.Run("routine changes only draw a note", func(t *testing.T) { + saveDir := t.TempDir() + report, failed := reportGitStateChanges([]gitStateChange{routine}, before, saveDir) + if failed { + t.Error("a routine shared-clone change failed the run") + } + if !strings.HasPrefix(report, "NOTE: ") || !strings.Contains(report, routine.detail) || strings.Contains(report, "ERROR") { + t.Errorf("report %q, want a NOTE naming %q and no ERROR", report, routine.detail) + } + if entries, err := os.ReadDir(saveDir); err != nil || len(entries) != 0 { + t.Errorf("save dir holds %v (err %v), want nothing saved for routine changes", entries, err) + } + }) + + t.Run("clobber fails and saves the pre-run copies", func(t *testing.T) { + saveDir := t.TempDir() + report, failed := reportGitStateChanges([]gitStateChange{clobber, newHook}, before, saveDir) + if !failed { + t.Error("a clobber did not fail the run") + } + for _, want := range []string{"ERROR: ", "wy-qlvlmf", clobber.detail, newHook.detail} { + if !strings.Contains(report, want) { + t.Errorf("report %q does not mention %q", report, want) + } + } + var savedDir string + for _, line := range strings.Split(report, "\n") { + if dir, ok := strings.CutPrefix(line, savedPrefix); ok { + savedDir = dir + } + } + if filepath.Dir(savedDir) != saveDir { + t.Fatalf("report %q names no save dir under %s", report, saveDir) + } + entries, err := os.ReadDir(savedDir) + if err != nil { + t.Fatal(err) + } + // The hook did not exist before the run, so only the config is saved. + if len(entries) != 1 { + t.Fatalf("saved %v, want exactly the pre-run config", entries) + } + saved := filepath.Join(savedDir, entries[0].Name()) + if data, err := os.ReadFile(saved); err != nil || string(data) != configBefore { + t.Errorf("saved copy = %q (err %v), want %q", data, err, configBefore) + } + if runtime.GOOS != "windows" { + for path, want := range map[string]os.FileMode{savedDir: 0o700, saved: 0o600} { + info, err := os.Stat(path) + if err != nil { + t.Error(err) + } else if got := info.Mode().Perm(); got != want { + t.Errorf("%s: mode %v, want %v: a config copy can hold credentials", path, got, want) + } + } + } + }) + + t.Run("notes and errors together", func(t *testing.T) { + report, failed := reportGitStateChanges([]gitStateChange{routine, newHook}, before, t.TempDir()) + note, errPart, found := strings.Cut(report, "ERROR: ") + if !failed || !found || !strings.Contains(note, routine.detail) || !strings.Contains(errPart, newHook.detail) { + t.Errorf("got (%q, %v), want the routine change under NOTE, the hook under ERROR, and a failed run", report, failed) + } + }) + + t.Run("a failed save is reported and still fails", func(t *testing.T) { + report, failed := reportGitStateChanges([]gitStateChange{clobber}, before, filepath.Join(t.TempDir(), "missing")) + if !failed || !strings.Contains(report, "could not save pre-run copies") { + t.Errorf("got (%q, %v), want a failed run that says the copies were not saved", report, failed) + } + }) +} diff --git a/internal/testutil/BUILD.bazel b/internal/testutil/BUILD.bazel index 82a658d83..28367d0eb 100644 --- a/internal/testutil/BUILD.bazel +++ b/internal/testutil/BUILD.bazel @@ -7,6 +7,7 @@ go_library( "container_provider.go", "container_provider_windows.go", "dockercontext.go", + "git_env.go", "git_test_hooks.go", "localdoltserver.go", "localdoltserver_linux.go", @@ -22,6 +23,7 @@ go_library( importpath = "github.com/steveyegge/beads/internal/testutil", visibility = ["//:__subpackages__"], deps = [ + "//internal/execenv", "//internal/storage/doltutil", "//internal/testutil/bazeltest", "@com_github_go_sql_driver_mysql//:mysql", @@ -109,6 +111,7 @@ go_test( name = "testutil_test", srcs = [ "dockercontext_test.go", + "git_env_test.go", "gm2g3g5r_failopen_test.go", "gm2g3g5r_failopen_unix_test.go", "gm2g3g5r_failopen_windows_test.go", diff --git a/internal/testutil/git_env.go b/internal/testutil/git_env.go new file mode 100644 index 000000000..5823f0b8c --- /dev/null +++ b/internal/testutil/git_env.go @@ -0,0 +1,52 @@ +package testutil + +import ( + "fmt" + "os" + + "github.com/steveyegge/beads/internal/execenv" +) + +// gitRepoLocationKeys are the git environment variables that name a +// repository, work tree, index, object store, ref namespace or config file +// outright. Each one overrides what git would find from cmd.Dir or -C, so a +// value leaked in from the invoking shell or a git hook (git exports GIT_DIR to +// every hook it runs) points a fixture's `git init`/`git config` at a +// repository or file the test does not own: the r880 host .git/config clobber +// (wy-qlvlmf). GIT_CONFIG is the legacy single-file override: `git config` +// reads and writes the file it names instead of the repository's config. +// +// The set is deliberately narrower than internal/gitenv's routing keys. It +// leaves GIT_CEILING_DIRECTORIES, GIT_CONFIG_GLOBAL and GIT_CONFIG_NOSYSTEM +// alone because the Bazel and CI test wrappers set those on purpose: a +// discovery fence, and a hermetic global config that carries the test +// identity. Keys match exactly, so dropping GIT_CONFIG keeps all three. +var gitRepoLocationKeys = []string{ + "GIT_ALTERNATE_OBJECT_DIRECTORIES", + "GIT_COMMON_DIR", + "GIT_CONFIG", + "GIT_DIR", + "GIT_INDEX_FILE", + "GIT_NAMESPACE", + "GIT_OBJECT_DIRECTORY", + "GIT_WORK_TREE", +} + +// WithoutGitRepoLocationEnv returns a copy of env without the variables that +// name a git repository location, for a fixture command's cmd.Env: the command +// then operates on the repository its cmd.Dir resolves to and nothing else. +func WithoutGitRepoLocationEnv(env []string) []string { + return execenv.Without(env, gitRepoLocationKeys...) +} + +// UnsetGitRepoLocationEnv removes the same variables from the current process. +// Suites call it first in TestMain so no fixture git command inherits a leaked +// location; a test that needs one sets it with t.Setenv. +func UnsetGitRepoLocationEnv() error { + for _, key := range gitRepoLocationKeys { + if err := os.Unsetenv(key); err != nil { + return fmt.Errorf("unset %s: %w", key, err) + } + } + return nil +} diff --git a/internal/testutil/git_env_test.go b/internal/testutil/git_env_test.go new file mode 100644 index 000000000..48c2a846e --- /dev/null +++ b/internal/testutil/git_env_test.go @@ -0,0 +1,114 @@ +package testutil + +import ( + "os" + "os/exec" + "path/filepath" + "slices" + "strings" + "testing" +) + +// wrapperGitEnv is what tools/bazel/test_env.sh and scripts/ci/lib/test-env.sh +// export for every test. The location scrub must leave all of it in place. +var wrapperGitEnv = []string{ + "GIT_CEILING_DIRECTORIES=/sandbox/srcdir:/sandbox/tmp", + "GIT_CONFIG_GLOBAL=/sandbox/gitconfig", + "GIT_CONFIG_NOSYSTEM=1", +} + +func TestWithoutGitRepoLocationEnvKeepsWrapperGitControls(t *testing.T) { + env := append([]string{ + "GIT_DIR=/host/.git/worktrees/wt", + "GIT_WORK_TREE=/host", + "GIT_COMMON_DIR=/host/.git", + "GIT_INDEX_FILE=/host/.git/worktrees/wt/index", + "GIT_OBJECT_DIRECTORY=/host/.git/objects", + "GIT_ALTERNATE_OBJECT_DIRECTORIES=/host/.git/objects", + "GIT_NAMESPACE=host", + "GIT_CONFIG=/host/.git/config", + "HOME=/sandbox/home", + }, wrapperGitEnv...) + + got := WithoutGitRepoLocationEnv(env) + want := append([]string{"HOME=/sandbox/home"}, wrapperGitEnv...) + if !slices.Equal(got, want) { + t.Fatalf("WithoutGitRepoLocationEnv:\n got %q\nwant %q", got, want) + } +} + +func TestUnsetGitRepoLocationEnvKeepsWrapperGitControls(t *testing.T) { + for _, key := range gitRepoLocationKeys { + t.Setenv(key, "/host/"+key) + } + for _, entry := range wrapperGitEnv { + key, value, _ := strings.Cut(entry, "=") + t.Setenv(key, value) + } + + if err := UnsetGitRepoLocationEnv(); err != nil { + t.Fatal(err) + } + for _, key := range gitRepoLocationKeys { + if value, ok := os.LookupEnv(key); ok { + t.Errorf("%s=%q survived UnsetGitRepoLocationEnv", key, value) + } + } + for _, entry := range wrapperGitEnv { + key, want, _ := strings.Cut(entry, "=") + if got := os.Getenv(key); got != want { + t.Errorf("%s=%q after UnsetGitRepoLocationEnv, want %q kept", key, got, want) + } + } +} + +// TestForceRepoLocalHooksPathIgnoresLeakedGitDir pins the write target: with +// GIT_DIR and GIT_WORK_TREE naming another repository, or GIT_CONFIG naming +// another config file, the hooksPath write must still land in repoDir and leave +// the other config untouched. +func TestForceRepoLocalHooksPathIgnoresLeakedGitDir(t *testing.T) { + decoy, target := t.TempDir(), t.TempDir() + for _, dir := range []string{decoy, target} { + cmd := exec.Command("git", "init", "--quiet", dir) + cmd.Env = WithoutGitRepoLocationEnv(os.Environ()) + if out, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("git init %s: %v\n%s", dir, err, out) + } + } + decoyConfig := filepath.Join(decoy, ".git", "config") + before, err := os.ReadFile(decoyConfig) + if err != nil { + t.Fatal(err) + } + decoyFile := filepath.Join(t.TempDir(), "leaked.gitconfig") + const decoyFileBefore = "[user]\n\tname = decoy\n" + if err := os.WriteFile(decoyFile, []byte(decoyFileBefore), 0o600); err != nil { + t.Fatal(err) + } + + t.Setenv("GIT_DIR", filepath.Join(decoy, ".git")) + t.Setenv("GIT_WORK_TREE", decoy) + t.Setenv("GIT_CONFIG", decoyFile) + if err := ForceRepoLocalHooksPath(target); err != nil { + t.Fatal(err) + } + + after, err := os.ReadFile(decoyConfig) + if err != nil { + t.Fatal(err) + } + if string(after) != string(before) { + t.Fatalf("leaked GIT_DIR routed the hooksPath write into %s:\n%s", decoyConfig, after) + } + if got, err := os.ReadFile(decoyFile); err != nil || string(got) != decoyFileBefore { + t.Fatalf("leaked GIT_CONFIG routed the hooksPath write into %s (err %v):\n%s", decoyFile, err, got) + } + get := exec.Command("git", "config", "--file", filepath.Join(target, ".git", "config"), "--get", "core.hooksPath") + out, err := get.CombinedOutput() + if err != nil { + t.Fatalf("read target core.hooksPath: %v\n%s", err, out) + } + if got := strings.TrimSpace(string(out)); got != ".git/hooks" { + t.Fatalf("target core.hooksPath=%q, want %q", got, ".git/hooks") + } +} diff --git a/internal/testutil/git_test_hooks.go b/internal/testutil/git_test_hooks.go index 84f12d983..4e6c17475 100644 --- a/internal/testutil/git_test_hooks.go +++ b/internal/testutil/git_test_hooks.go @@ -2,15 +2,18 @@ package testutil import ( "fmt" + "os" "os/exec" "strings" ) // ForceRepoLocalHooksPath configures a git test repository to use .git/hooks -// regardless of any global core.hooksPath configuration. +// regardless of any global core.hooksPath configuration. The write goes to +// repoDir even when a GIT_DIR or GIT_WORK_TREE leaked into the process. func ForceRepoLocalHooksPath(repoDir string) error { cmd := exec.Command("git", "config", "core.hooksPath", ".git/hooks") cmd.Dir = repoDir + cmd.Env = WithoutGitRepoLocationEnv(os.Environ()) if out, err := cmd.CombinedOutput(); err != nil { trimmed := strings.TrimSpace(string(out)) if trimmed != "" {