beads/cmd/bd/hooks_worktree_test.go
Bee 3571331b50
test: fixtures commit with maintenance.auto=false before every git worktree add (wy-7ocweu) (#7358)
Fixes #7349. The same race #7314 closed in internal/beads and
internal/config, in the fixtures it did not cover: a fixture's plain
`git commit` spawns the detached `git maintenance run --auto` child, whose
worktree-prune races the fixture's next `git worktree add` and deletes
.git/worktrees/<name>/locked under it (seen on PR #7312 run 37585997441,
cmd/bd Dolt-server tier shard 4/16, TestBootstrap_WorktreeFallbackDir).

One noAutoMaintenance + gitCommand(args...) helper per test package, each
in an existing untagged shared test file (cmd/bd/helpers_test.go,
doctor/git_test_helpers_test.go, doctor/fix/common_test.go,
formula/parser_test.go, git/gitdir_test.go, storage/domain/git/git_test.go;
cmd/bd/test_helpers_test.go is //go:build cgo so unusable for the pure
lane), and every inline exec.Command("git", ...) in those six packages
swapped for it. The flags ride the command line, never env config: the
routing-key scrub drops env config. No new files, so no BUILD.bazel rows.

Proof: GIT_TRACE on `go test ./cmd/bd -run TestBootstrap_WorktreeFallbackDir`
counts 3 `maintenance run --auto` spawns at d8d8bf587b and 0 with this
change.

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
2026-10-08 08:01:46 +00:00

792 lines
32 KiB
Go

package main
import (
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"testing"
"github.com/steveyegge/beads/cmd/bd/doctor"
"github.com/steveyegge/beads/internal/git"
"github.com/steveyegge/beads/internal/gitenv"
"github.com/steveyegge/beads/internal/storage/domain"
"github.com/steveyegge/beads/internal/utils"
"github.com/stretchr/testify/require"
)
func TestConfigureBeadsHooksPath_WorktreeUsesMainRepo(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "beads-hooks-worktree-test-*")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { os.RemoveAll(tmpDir) })
mainRepoDir := filepath.Join(tmpDir, "main-repo")
if err := os.MkdirAll(mainRepoDir, 0755); err != nil {
t.Fatal(err)
}
run := func(args ...string) {
cmd := gitCommand(args...)
cmd.Dir = mainRepoDir
if err := cmd.Run(); err != nil {
t.Skipf("git %v failed: %v", args, err)
}
}
run("init")
run("config", "user.email", "test@example.com")
run("config", "user.name", "Test User")
if err := os.WriteFile(filepath.Join(mainRepoDir, "README.md"), []byte("# Test\n"), 0644); err != nil {
t.Fatal(err)
}
run("add", "README.md")
run("commit", "-m", "Initial commit")
worktreeDir := filepath.Join(tmpDir, "worktree")
cmd := gitCommand("worktree", "add", worktreeDir, "HEAD")
cmd.Dir = mainRepoDir
if err := cmd.Run(); err != nil {
t.Fatalf("git worktree add failed: %v", err)
}
t.Cleanup(func() {
cmd := gitCommand("worktree", "remove", "--force", worktreeDir)
cmd.Dir = mainRepoDir
_ = cmd.Run()
})
if err := os.MkdirAll(filepath.Join(mainRepoDir, ".beads", "hooks"), 0755); err != nil {
t.Fatal(err)
}
t.Chdir(worktreeDir)
git.ResetCaches()
if !git.IsWorktree() {
t.Fatal("expected git.IsWorktree() to return true")
}
if err := configureBeadsHooksPath(); err != nil {
t.Fatalf("configureBeadsHooksPath failed: %v", err)
}
cmd = gitCommand("config", "--get", "core.hooksPath")
cmd.Dir = mainRepoDir
out, err := cmd.Output()
if err != nil {
t.Fatalf("git config --get core.hooksPath failed: %v", err)
}
hooksPath := filepath.Clean(strings.TrimSpace(string(out)))
expected := filepath.Join(mainRepoDir, ".beads", "hooks")
hooksPath, _ = filepath.EvalSymlinks(hooksPath)
expected, _ = filepath.EvalSymlinks(expected)
if hooksPath != expected {
t.Errorf("core.hooksPath = %q, want %q", hooksPath, expected)
}
}
func TestConfigureSharedHooksPath_WorktreeUsesMainRepo(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "beads-shared-hooks-worktree-test-*")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { os.RemoveAll(tmpDir) })
mainRepoDir := filepath.Join(tmpDir, "main-repo")
if err := os.MkdirAll(mainRepoDir, 0755); err != nil {
t.Fatal(err)
}
run := func(args ...string) {
cmd := gitCommand(args...)
cmd.Dir = mainRepoDir
if err := cmd.Run(); err != nil {
t.Skipf("git %v failed: %v", args, err)
}
}
run("init")
run("config", "user.email", "test@example.com")
run("config", "user.name", "Test User")
if err := os.WriteFile(filepath.Join(mainRepoDir, "README.md"), []byte("# Test\n"), 0644); err != nil {
t.Fatal(err)
}
run("add", "README.md")
run("commit", "-m", "Initial commit")
worktreeDir := filepath.Join(tmpDir, "worktree")
cmd := gitCommand("worktree", "add", worktreeDir, "HEAD")
cmd.Dir = mainRepoDir
if err := cmd.Run(); err != nil {
t.Fatalf("git worktree add failed: %v", err)
}
t.Cleanup(func() {
cmd := gitCommand("worktree", "remove", "--force", worktreeDir)
cmd.Dir = mainRepoDir
_ = cmd.Run()
})
if err := os.MkdirAll(filepath.Join(mainRepoDir, ".beads-hooks"), 0755); err != nil {
t.Fatal(err)
}
t.Chdir(worktreeDir)
git.ResetCaches()
if !git.IsWorktree() {
t.Fatal("expected git.IsWorktree() to return true")
}
if err := configureSharedHooksPath(); err != nil {
t.Fatalf("configureSharedHooksPath failed: %v", err)
}
cmd = gitCommand("config", "--get", "core.hooksPath")
cmd.Dir = mainRepoDir
out, err := cmd.Output()
if err != nil {
t.Fatalf("git config --get core.hooksPath failed: %v", err)
}
hooksPath := filepath.Clean(strings.TrimSpace(string(out)))
expected := filepath.Join(mainRepoDir, ".beads-hooks")
hooksPath, _ = filepath.EvalSymlinks(hooksPath)
expected, _ = filepath.EvalSymlinks(expected)
if hooksPath != expected {
t.Errorf("core.hooksPath = %q, want %q", hooksPath, expected)
}
}
func TestResetHooksPathIfBeadsManaged_Worktree(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "beads-reset-hooks-worktree-test-*")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { os.RemoveAll(tmpDir) })
mainRepoDir := filepath.Join(tmpDir, "main-repo")
if err := os.MkdirAll(mainRepoDir, 0755); err != nil {
t.Fatal(err)
}
run := func(args ...string) {
cmd := gitCommand(args...)
cmd.Dir = mainRepoDir
if err := cmd.Run(); err != nil {
t.Skipf("git %v failed: %v", args, err)
}
}
run("init")
run("config", "user.email", "test@example.com")
run("config", "user.name", "Test User")
if err := os.WriteFile(filepath.Join(mainRepoDir, "README.md"), []byte("# Test\n"), 0644); err != nil {
t.Fatal(err)
}
run("add", "README.md")
run("commit", "-m", "Initial commit")
worktreeDir := filepath.Join(tmpDir, "worktree")
cmd := gitCommand("worktree", "add", worktreeDir, "HEAD")
cmd.Dir = mainRepoDir
if err := cmd.Run(); err != nil {
t.Fatalf("git worktree add failed: %v", err)
}
t.Cleanup(func() {
cmd := gitCommand("worktree", "remove", "--force", worktreeDir)
cmd.Dir = mainRepoDir
_ = cmd.Run()
})
if err := os.MkdirAll(filepath.Join(mainRepoDir, ".beads", "hooks"), 0755); err != nil {
t.Fatal(err)
}
hooksPathToSet := filepath.Join(mainRepoDir, ".beads", "hooks")
evaluated, _ := filepath.EvalSymlinks(hooksPathToSet)
if evaluated != "" {
hooksPathToSet = evaluated
}
cmd = gitCommand("config", "core.hooksPath", hooksPathToSet)
cmd.Dir = mainRepoDir
if err := cmd.Run(); err != nil {
t.Fatalf("git config core.hooksPath failed: %v", err)
}
run("config", "beads.role", "primary")
run("config", "extensions.worktreeConfig", "true")
cmd = gitCommand("config", "--worktree", "beads.role", "worktree-only")
cmd.Dir = worktreeDir
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("configure worktree role: %v\n%s", err, out)
}
cmd = gitCommand("config", "--worktree", "core.hooksPath", ".beads/hooks")
cmd.Dir = worktreeDir
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("configure worktree hooksPath: %v\n%s", err, out)
}
t.Chdir(worktreeDir)
git.ResetCaches()
if !git.IsWorktree() {
t.Fatal("expected git.IsWorktree() to return true")
}
git.ResetCaches() // Exercise the actual reset with a cold context.
if err := resetHooksPathIfBeadsManaged(); err != nil {
t.Fatalf("resetHooksPathIfBeadsManaged failed: %v", err)
}
cmd = gitCommand("config", "--local", "--get", "core.hooksPath")
cmd.Dir = mainRepoDir
out, _ := cmd.Output()
if strings.TrimSpace(string(out)) != "" {
t.Errorf("core.hooksPath = %q after reset, want empty", strings.TrimSpace(string(out)))
}
cmd = gitCommand("config", "--local", "--get", "beads.role")
cmd.Dir = mainRepoDir
out, err = cmd.Output()
if exit, ok := err.(*exec.ExitError); !ok || exit.ExitCode() != 1 {
t.Errorf("main role remains after reset: %q, %v", out, err)
}
cmd = gitCommand("config", "--worktree", "--get", "beads.role")
cmd.Dir = worktreeDir
out, err = cmd.Output()
if err != nil || strings.TrimSpace(string(out)) != "worktree-only" {
t.Errorf("worktree-specific role changed: %q, %v", out, err)
}
cmd = gitCommand("config", "--worktree", "--get", "core.hooksPath")
cmd.Dir = worktreeDir
out, err = cmd.Output()
if err != nil || strings.TrimSpace(string(out)) != ".beads/hooks" {
t.Errorf("worktree-specific hooksPath changed: %q, %v", out, err)
}
t.Run("preserve_worktree_role", func(t *testing.T) {
// Seed a new common role so this reset proves removal independently of the first call.
run("config", "--local", "beads.role", "primary")
privateDir, err := git.GetGitDir()
if err != nil {
t.Fatal(err)
}
privateConfig := filepath.Join(privateDir, "config.worktree")
before, err := os.ReadFile(privateConfig)
if err != nil {
t.Fatal(err)
}
git.ResetCaches()
t.Cleanup(git.ResetCaches)
if err := resetHooksPathIfBeadsManaged(); err != nil {
t.Fatalf("reset while preserving a worktree role failed: %v", err)
}
if after, err := os.ReadFile(privateConfig); err != nil || string(after) != string(before) {
t.Fatalf("private worktree config changed: %v", err)
}
get := gitCommand("config", "--local", "--get", "beads.role")
get.Dir = mainRepoDir
out, err := get.Output()
if exit, ok := err.(*exec.ExitError); !ok || exit.ExitCode() != 1 {
t.Errorf("common role after reset = %q, %v; want absent", out, err)
}
})
}
func TestConfigureBeadsHooksPath_NormalRepoUnchanged(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "beads-hooks-normal-test-*")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { os.RemoveAll(tmpDir) })
repoDir := filepath.Join(tmpDir, "repo")
if err := os.MkdirAll(repoDir, 0755); err != nil {
t.Fatal(err)
}
run := func(args ...string) {
cmd := gitCommand(args...)
cmd.Dir = repoDir
if err := cmd.Run(); err != nil {
t.Skipf("git %v failed: %v", args, err)
}
}
run("init")
run("config", "user.email", "test@example.com")
run("config", "user.name", "Test User")
if err := os.WriteFile(filepath.Join(repoDir, "README.md"), []byte("# Test\n"), 0644); err != nil {
t.Fatal(err)
}
run("add", "README.md")
run("commit", "-m", "Initial commit")
if err := os.MkdirAll(filepath.Join(repoDir, ".beads", "hooks"), 0755); err != nil {
t.Fatal(err)
}
t.Chdir(repoDir)
git.ResetCaches()
if git.IsWorktree() {
t.Fatal("expected git.IsWorktree() to return false in normal repo")
}
if err := configureBeadsHooksPath(); err != nil {
t.Fatalf("configureBeadsHooksPath failed: %v", err)
}
cmd := gitCommand("config", "--get", "core.hooksPath")
cmd.Dir = repoDir
out, err := cmd.Output()
if err != nil {
t.Fatalf("git config --get core.hooksPath failed: %v", err)
}
hooksPath := filepath.Clean(strings.TrimSpace(string(out)))
expected := filepath.Join(repoDir, ".beads", "hooks")
hooksPath, _ = filepath.EvalSymlinks(hooksPath)
expected, _ = filepath.EvalSymlinks(expected)
if hooksPath != expected {
t.Errorf("core.hooksPath = %q, want %q", hooksPath, expected)
}
}
// newInitHooksFixture keeps the selected worktree, ambient repository and
// storage physically distinct. Git's default HOME is owned by the parent helper.
func newInitHooksFixture(t *testing.T) (selected, decoy, storage, common string) {
t.Helper()
selected, decoy, exclude, _ := newInitExcludeRepos(t)
common = filepath.Dir(filepath.Dir(exclude))
storage = filepath.Join(t.TempDir(), "separate storage")
require.NoError(t, os.Mkdir(storage, 0755))
require.NoError(t, os.WriteFile(filepath.Join(decoy, "seed"), []byte("decoy\n"), 0600))
initExcludeGit(t, decoy, "add", "seed")
initExcludeGit(t, selected, "config", "beads.role", "contributor")
t.Setenv("BEADS_DIR", filepath.Join(decoy, ".beads"))
t.Setenv("GIT_DIR", filepath.Join(decoy, ".git"))
t.Setenv("GIT_WORK_TREE", decoy)
t.Setenv("GIT_INDEX_FILE", filepath.Join(decoy, ".git", "index"))
git.ResetCaches()
t.Cleanup(git.ResetCaches)
return selected, decoy, storage, common
}
func readInitHooksFile(t *testing.T, path string) []byte {
t.Helper()
data, err := os.ReadFile(path)
require.NoError(t, err)
return data
}
func TestInitEmbeddedHooksSelectedTail(t *testing.T) {
for _, name := range []string{"missing", "skip", "nonrepo", "pure_jj", "quiet_pure_jj", "colocated", "bare", "config_lock", "quiet_config_lock"} {
t.Run(name, func(t *testing.T) {
selected, decoy, storage, common := newInitHooksFixture(t)
preserveInitRoleInputs(t, filepath.Join(decoy, ".git", "config"), filepath.Join(decoy, ".git", "index"))
if name == "nonrepo" || strings.Contains(name, "pure_jj") || name == "bare" {
selected = t.TempDir()
}
if name == "bare" {
initExcludeGit(t, selected, "init", "--bare")
}
if strings.Contains(name, "pure_jj") || name == "colocated" {
require.NoError(t, os.Mkdir(filepath.Join(selected, ".jj"), 0755))
}
if name == "colocated" {
initExcludeGit(t, selected, "config", "--local", "core.hooksPath", filepath.Join(common, "hooks"))
}
locked, quiet := strings.Contains(name, "config_lock"), strings.HasPrefix(name, "quiet")
if locked {
require.NoError(t, os.WriteFile(filepath.Join(common, "config.lock"), []byte("owned lock"), 0600))
preserveInitRoleInputs(t, filepath.Join(common, "config"))
}
run := func() { runEmbeddedInitHooks(t.Context(), selected, storage, name == "skip", quiet) }
if locked {
stderr := captureStderr(t, run)
require.Equal(t, !quiet, strings.Contains(stderr, "Failed to install git hooks"))
require.Equal(t, !quiet, strings.Contains(stderr, "bd hooks install --beads"))
} else {
stdout := captureStdout(t, func() error { run(); return nil })
require.Equal(t, name == "pure_jj", strings.Contains(stdout, "Jujutsu repository detected"))
}
destination := filepath.Join(storage, "hooks")
if name == "colocated" {
destination = filepath.Join(common, "hooks")
}
if name == "skip" || name == "nonrepo" || strings.Contains(name, "pure_jj") {
_, err := os.Stat(destination)
require.ErrorIs(t, err, os.ErrNotExist)
return
}
require.Contains(t, string(readInitHooksFile(t, filepath.Join(destination, "pre-commit"))), hookSectionBeginPrefix)
if !locked && name != "colocated" {
// A bare repository has no work tree to anchor, so it resolves
// through the work-tree-less hooks context (GH#6457) and is its own
// common directory. It installs like any other selected repository
// rather than degrading to a warning and no install at all.
configRoot := common
if name == "bare" {
configRoot = selected
}
got := initExcludeGit(t, selected, "config", "--file", filepath.Join(configRoot, "config"), "--get", "core.hooksPath")
require.Equal(t, filepath.Clean(destination), filepath.Clean(got))
}
})
}
}
func TestInitEmbeddedHooksSelectedStatus(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("hook current-status checks require POSIX executable bits")
}
for _, name := range []string{"decoy_current", "target_current", "target_outdated"} {
t.Run(name, func(t *testing.T) {
selected, decoy, storage, common := newInitHooksFixture(t)
current := filepath.Join(decoy, ".git", "hooks")
configuredRepo := decoy
if name != "decoy_current" {
current = filepath.Join(common, "hooks")
configuredRepo = selected
}
initExcludeGit(t, configuredRepo, "config", "--local", "core.hooksPath", current)
require.NoError(t, os.MkdirAll(current, 0755))
for _, hook := range managedHookNames {
content := "#!/bin/sh\n" + generateHookSection(hook)
if name == "target_outdated" {
content = "#!/bin/sh\n" + hookVersionPrefix + "0.0.0\n# bd (beads) " + hook + " hook\n"
}
require.NoError(t, os.WriteFile(filepath.Join(current, hook), []byte(content), 0755))
}
require.True(t, hooksInstalledAt(current))
require.Equal(t, name == "target_outdated", hookStatusesNeedUpdate(checkGitHooksAt(current)))
if name == "decoy_current" {
require.True(t, hooksInstalled() && !hooksNeedUpdate(), "inherited decoy hooks must be current")
}
preserveInitRoleInputs(t, filepath.Join(current, "pre-commit"), filepath.Join(decoy, ".git", "config"), filepath.Join(decoy, ".git", "index"))
stdout := captureStdout(t, func() error {
runEmbeddedInitHooks(t.Context(), selected, storage, false, false)
return nil
})
require.Equal(t, name == "target_outdated", strings.Contains(stdout, "Updating hooks to version"))
if name == "target_current" {
_, err := os.Stat(filepath.Join(storage, "hooks"))
require.ErrorIs(t, err, os.ErrNotExist)
} else {
require.Contains(t, string(readInitHooksFile(t, filepath.Join(storage, "hooks", "pre-commit"))), hookSectionBeginLine())
}
})
}
}
func preserveStandaloneHookInputs(t *testing.T, paths ...string) {
t.Helper()
beforeEnv := os.Environ()
t.Cleanup(func() { require.Equal(t, beforeEnv, os.Environ()) })
for _, path := range paths {
before := readInitHooksFile(t, path)
t.Cleanup(func() { require.Equal(t, before, readInitHooksFile(t, path), "changed %s", path) })
}
}
func setStandaloneHookMode(t *testing.T, mode string) {
t.Helper()
oldJSON := jsonOutput
jsonOutput = false // These command fixtures assert the human-readable stderr contract.
t.Cleanup(func() { jsonOutput = oldJSON })
for _, flag := range []string{"force", "shared", "chain", "beads"} {
f := hooksInstallCmd.Flags().Lookup(flag)
old, changed := f.Value.String(), f.Changed
t.Cleanup(func() {
require.NoError(t, hooksInstallCmd.Flags().Set(flag, old))
f.Changed = changed
})
value := "false"
if flag == mode {
value = "true"
}
require.NoError(t, hooksInstallCmd.Flags().Set(flag, value))
}
}
func TestStandaloneHookCommandsUseSelectedContext(t *testing.T) {
for _, name := range []string{"regular", "linked", "private", "shared", "beads", "bare_external", "inline", "config_file", "config_lock"} {
t.Run(name, func(t *testing.T) {
selected, decoy, storage, common := newInitHooksFixture(t)
require.True(t, utils.PathsEqual(decoy, git.GetRepoRoot()), "seed stale decoy cache")
cwd, mainRoot := decoy, filepath.Dir(common)
if name == "regular" {
selected = mainRoot
}
private := initExcludeGit(t, selected, "rev-parse", "--absolute-git-dir")
if name == "bare_external" {
root := t.TempDir()
common, selected = filepath.Join(root, "selected bare.git"), filepath.Join(root, "external tree")
initExcludeGit(t, root, "init", "--bare", common)
require.NoError(t, os.Mkdir(selected, 0755))
cwd, mainRoot, private = selected, selected, filepath.Join("..", "selected bare.git")
}
t.Chdir(cwd)
t.Setenv("GIT_DIR", private)
t.Setenv("GIT_WORK_TREE", selected)
t.Setenv("BEADS_DIR", storage)
require.NoError(t, os.WriteFile(filepath.Join(storage, "metadata.json"), []byte("{}\n"), 0600))
destination := filepath.Join(mainRoot, ".beads", "hooks")
initExcludeGit(t, cwd, "--git-dir", common, "config", "--local", "core.hooksPath", destination)
initExcludeGit(t, cwd, "--git-dir", common, "config", "--local", "beads.role", "contributor")
if name == "private" {
destination = t.TempDir()
initExcludeGit(t, selected, "config", "extensions.worktreeConfig", "true")
initExcludeGit(t, selected, "config", "--worktree", "core.hooksPath", destination)
preserveStandaloneHookInputs(t, filepath.Join(private, "config.worktree"))
}
if name == "shared" {
destination = filepath.Join(mainRoot, ".beads-hooks")
} else if name == "beads" {
destination = filepath.Join(storage, "hooks")
}
decoyHook := filepath.Join(decoy, ".git", "hooks", "pre-commit")
require.NoError(t, os.WriteFile(decoyHook, []byte("#!/bin/sh\n"+generateHookSection("pre-commit")), 0755))
if name == "inline" {
t.Setenv("GIT_CONFIG_COUNT", "1")
t.Setenv("GIT_CONFIG_KEY_0", "core.hooksPath")
t.Setenv("GIT_CONFIG_VALUE_0", filepath.Dir(decoyHook))
}
if name == "config_file" {
initExcludeGit(t, decoy, "config", "--local", "core.hooksPath", filepath.Dir(decoyHook))
t.Setenv("GIT_CONFIG", filepath.Join(decoy, ".git", "config"))
}
preserveStandaloneHookInputs(t, decoyHook, filepath.Join(decoy, ".git", "config"), filepath.Join(decoy, ".git", "index"))
setStandaloneHookMode(t, name)
require.NoError(t, hooksInstallCmd.RunE(hooksInstallCmd, nil))
require.Contains(t, string(readInitHooksFile(t, filepath.Join(destination, "pre-commit"))), hookSectionBeginPrefix)
if name == "shared" || name == "beads" {
got := initExcludeGit(t, cwd, "--git-dir", common, "config", "--local", "--get", "core.hooksPath")
require.True(t, utils.PathsEqual(destination, got), "selected hooks path = %q, want %q", got, destination)
}
if name == "config_lock" {
require.NoError(t, os.WriteFile(filepath.Join(common, "config.lock"), []byte("owned lock"), 0600))
var err error
stderr := captureStderr(t, func() { err = hooksUninstallCmd.RunE(hooksUninstallCmd, nil) })
require.Equal(t, &exitError{Code: 1}, err)
require.Contains(t, stderr, "failed to reset")
return
}
require.NoError(t, hooksUninstallCmd.RunE(hooksUninstallCmd, nil))
_, err := os.Stat(filepath.Join(destination, "pre-commit"))
require.ErrorIs(t, err, os.ErrNotExist)
query := gitCommand("--git-dir", common, "config", "--local", "--get", "beads.role")
query.Dir, query.Env = cwd, gitenv.ScrubRouting(os.Environ())
var exit *exec.ExitError
require.ErrorAs(t, query.Run(), &exit)
require.Equal(t, 1, exit.ExitCode(), "selected local role must be absent")
if name == "beads" {
// The value install wrote is the out-of-repo <BEADS_DIR>/hooks
// directory whose hook files uninstall just deleted. Leaving it
// configured keeps .git/hooks shadowed by an emptied directory,
// i.e. every hook silently disabled while beads-managed config is
// still installed — the GH#4440 contract this command enforces.
pathQuery := gitCommand("--git-dir", common, "config", "--local", "--get", "core.hooksPath")
pathQuery.Dir, pathQuery.Env = cwd, gitenv.ScrubRouting(os.Environ())
var pathExit *exec.ExitError
require.ErrorAs(t, pathQuery.Run(), &pathExit)
require.Equal(t, 1, pathExit.ExitCode(), "out-of-storage hooks path must be cleared, not left behind")
}
require.True(t, utils.PathsEqual(decoy, git.GetRepoRoot()), "fresh commands must leave the legacy cache untouched")
})
}
}
// TestStandaloneBeadsUninstallLeavesHooksPathWhenResolutionDrifts records an
// accepted limitation, not a desired behavior. The shared predicate recognizes the
// directory `bd hooks install --beads` would configure *right now*
// (doctor.BeadsManagedStorageHooksDir -> beads.FindBeadsDir), not the value install
// actually wrote, and every FindBeadsDir arm reads live inputs: BEADS_DIR, the
// .beads/redirect contents, storage existence plus project files, and the process
// cwd. core.hooksPath lives in the shared common dir, so an installing shell with
// BEADS_DIR set and an uninstalling shell without it see the same configured value
// and resolve different storage. Uninstall then deletes the hook files and leaves
// core.hooksPath pointing at the emptied directory — .git/hooks stays shadowed,
// which is the GH#4440 shape the clearance exists to prevent.
//
// Tracked in bd-s76jm: record what install configured (a local beads.hooksPath key)
// and match the record, with the current recomputation as the fallback. When that
// lands this expectation flips to "cleared" and this test becomes its
// counterfactual.
func TestStandaloneBeadsUninstallLeavesHooksPathWhenResolutionDrifts(t *testing.T) {
selected, decoy, storage, common := newInitHooksFixture(t)
require.True(t, utils.PathsEqual(decoy, git.GetRepoRoot()), "seed stale decoy cache")
mainRoot := filepath.Dir(common)
private := initExcludeGit(t, selected, "rev-parse", "--absolute-git-dir")
t.Chdir(decoy)
t.Setenv("GIT_DIR", private)
t.Setenv("GIT_WORK_TREE", selected)
t.Setenv("BEADS_DIR", storage)
require.NoError(t, os.WriteFile(filepath.Join(storage, "metadata.json"), []byte("{}\n"), 0600))
destination := filepath.Join(storage, "hooks")
initExcludeGit(t, decoy, "--git-dir", common, "config", "--local", "core.hooksPath",
filepath.Join(mainRoot, ".beads", "hooks"))
setStandaloneHookMode(t, "beads")
require.NoError(t, hooksInstallCmd.RunE(hooksInstallCmd, nil))
require.Contains(t, string(readInitHooksFile(t, filepath.Join(destination, "pre-commit"))), hookSectionBeginPrefix)
require.True(t, utils.PathsEqual(destination, readSelectedHooksPath(t, decoy, common)),
"install must configure the out-of-repo storage hooks directory")
// Same repository and same configured value; only the resolution inputs move.
require.NoError(t, os.Unsetenv("BEADS_DIR"))
require.NotEqual(t, destination, doctor.BeadsManagedStorageHooksDir(),
"precondition: cleanup must no longer re-derive the value install wrote")
require.NoError(t, hooksUninstallCmd.RunE(hooksUninstallCmd, nil))
_, err := os.Stat(filepath.Join(destination, "pre-commit"))
require.ErrorIs(t, err, os.ErrNotExist, "uninstall still deletes the hook files it can no longer recognize")
require.True(t, utils.PathsEqual(destination, readSelectedHooksPath(t, decoy, common)),
"known gap (bd-s76jm): the configured value survives an install/uninstall resolution drift")
}
// readSelectedHooksPath returns the selected repository's local core.hooksPath,
// read through the common dir with routing overrides dropped, exactly as
// resetHooksPathAt reads it.
func readSelectedHooksPath(t *testing.T, workDir, commonDir string) string {
t.Helper()
return initExcludeGit(t, workDir, "--git-dir", commonDir, "config", "--local", "--get", "core.hooksPath")
}
// TestStandaloneHooksWarnOnEffectivePathDivergence pins the warning that names
// both hook paths when they disagree. install/uninstall act on the selected,
// config-scrubbed directory, while every status and execution reader
// (bd hooks list, bd doctor, runChainedHook) still resolves hooks through the
// inherited context — and git itself honors the inherited core.hooksPath. A
// bare success would leave the user comparing an install that reported one
// directory against a status that reports another, with nothing saying why.
func TestStandaloneHooksWarnOnEffectivePathDivergence(t *testing.T) {
selected, decoy, _, common := newInitHooksFixture(t)
mainRoot := filepath.Dir(common)
private := initExcludeGit(t, selected, "rev-parse", "--absolute-git-dir")
t.Chdir(decoy)
t.Setenv("GIT_DIR", private)
t.Setenv("GIT_WORK_TREE", selected)
destination := filepath.Join(mainRoot, ".beads", "hooks")
initExcludeGit(t, decoy, "--git-dir", common, "config", "--local", "core.hooksPath", destination)
injected := filepath.Join(decoy, ".git", "hooks")
t.Setenv("GIT_CONFIG_COUNT", "1")
t.Setenv("GIT_CONFIG_KEY_0", "core.hooksPath")
t.Setenv("GIT_CONFIG_VALUE_0", injected)
setStandaloneHookMode(t, "")
var err error
stderr := captureStderr(t, func() { err = hooksInstallCmd.RunE(hooksInstallCmd, nil) })
require.NoError(t, err)
require.Contains(t, stderr, injected, "warning must name the effective inherited hooks directory")
require.Contains(t, stderr, destination, "warning must name the selected directory bd operated on")
require.Contains(t, string(readInitHooksFile(t, filepath.Join(destination, "pre-commit"))), hookSectionBeginPrefix)
}
func TestInitHooksPreservesManagedDirectoryAliases(t *testing.T) {
for _, managed := range []string{".beads/hooks", ".beads-hooks"} {
t.Run(managed, func(t *testing.T) {
selected, _, storage, common := newInitHooksFixture(t)
root := filepath.Dir(common)
source := filepath.Join(root, managed)
require.NoError(t, os.MkdirAll(source, 0755))
const content = "#!/bin/sh\necho existing managed-directory hook\n"
require.NoError(t, os.WriteFile(filepath.Join(source, "post-rewrite"), []byte(content), 0755))
alias := filepath.Join(t.TempDir(), "repository alias")
if err := os.Symlink(root, alias); err != nil {
if runtime.GOOS == "windows" {
t.Skipf("directory symlink capability unavailable: %v", err)
}
t.Fatal(err)
}
initExcludeGit(t, selected, "config", "--local", "core.hooksPath", filepath.Join(alias, managed))
fs, _, err := withInitHooks(nil, selected, storage)
require.NoError(t, err)
require.NoError(t, fs.InstallGitHooks(t.Context(), domain.HooksInstallParams{HookNames: managedHookNames, BeadsHooks: true}))
_, err = os.Stat(filepath.Join(storage, "hooks", "post-rewrite"))
require.ErrorIs(t, err, os.ErrNotExist, "an existing managed hooks directory must not be copied through an alias")
require.Equal(t, content, string(readInitHooksFile(t, filepath.Join(source, "post-rewrite"))))
})
}
}
func TestInitHooksRefusesSharedMode(t *testing.T) {
selected, _, storage, common := newInitHooksFixture(t)
fs, _, err := withInitHooks(nil, selected, storage)
require.NoError(t, err)
require.ErrorContains(t, fs.InstallGitHooks(t.Context(), domain.HooksInstallParams{HookNames: managedHookNames, Shared: true}), "shared hooks mode")
for _, path := range []string{filepath.Join(storage, "hooks"), filepath.Join(filepath.Dir(common), ".beads-hooks")} {
_, err := os.Stat(path)
require.ErrorIs(t, err, os.ErrNotExist)
}
}
func TestInitHooksContextPreservesSelectedPaths(t *testing.T) {
for _, name := range []string{"foreign", "global", "private", "config_lock"} {
t.Run(name, func(t *testing.T) {
selected, decoy, storage, common := newInitHooksFixture(t)
current := t.TempDir()
const foreign = "#!/bin/sh\necho selected hook\n"
for _, hook := range []string{"pre-commit", "post-rewrite"} {
require.NoError(t, os.WriteFile(filepath.Join(current, hook), []byte(foreign), 0755))
}
initExcludeGit(t, selected, "config", "--local", "core.hooksPath", current)
if name == "global" {
initExcludeGit(t, selected, "config", "--local", "--unset", "core.hooksPath")
initExcludeGit(t, selected, "config", "--global", "core.hooksPath", current)
}
preserved := map[string][]byte{}
if name == "private" {
initExcludeGit(t, selected, "config", "extensions.worktreeConfig", "true")
initExcludeGit(t, selected, "config", "--worktree", "core.hooksPath", current)
path := filepath.Join(initExcludeGit(t, selected, "rev-parse", "--absolute-git-dir"), "config.worktree")
preserved[path] = readInitHooksFile(t, path)
}
for _, path := range []string{filepath.Join(decoy, ".git", "config"), filepath.Join(decoy, ".git", "index")} {
preserved[path] = readInitHooksFile(t, path)
}
if name == "global" {
path := filepath.Join(os.Getenv("HOME"), ".gitconfig")
preserved[path] = readInitHooksFile(t, path)
}
fs, hooks, err := withInitHooks(nil, selected, storage)
require.NoError(t, err)
require.False(t, hooks.installed())
if name == "config_lock" {
require.NoError(t, os.WriteFile(filepath.Join(common, "config.lock"), []byte("owned lock"), 0600))
preserved[filepath.Join(common, "config")] = readInitHooksFile(t, filepath.Join(common, "config"))
}
// Later ambient routing must not rebind the captured hook operation.
t.Setenv("GIT_DIR", filepath.Join(t.TempDir(), "missing"))
t.Setenv("GIT_CONFIG_COUNT", "1")
t.Setenv("GIT_CONFIG_KEY_0", "core.hooksPath")
t.Setenv("GIT_CONFIG_VALUE_0", filepath.Join(decoy, "wrong hooks"))
env := os.Environ()
destination := filepath.Join(storage, "hooks")
for range 2 {
err := fs.InstallGitHooks(t.Context(), domain.HooksInstallParams{HookNames: managedHookNames, BeadsHooks: true})
if name == "config_lock" {
require.ErrorContains(t, err, "failed to configure git hooks path")
} else {
require.NoError(t, err)
got := initExcludeGit(t, selected, "config", "--file", filepath.Join(common, "config"), "--get", "core.hooksPath")
gotInfo, err := os.Stat(got)
require.NoError(t, err)
wantInfo, err := os.Stat(destination)
require.NoError(t, err)
require.True(t, os.SameFile(gotInfo, wantInfo), "common config must name the installed storage hooks")
}
installed := string(readInitHooksFile(t, filepath.Join(destination, "pre-commit")))
require.Contains(t, installed, foreign)
require.Equal(t, 1, strings.Count(installed, hookSectionBeginPrefix))
require.Equal(t, foreign, string(readInitHooksFile(t, filepath.Join(destination, "pre-commit.backup"))))
require.Equal(t, foreign, string(readInitHooksFile(t, filepath.Join(destination, "post-rewrite"))))
}
for path, before := range preserved {
require.Equal(t, before, readInitHooksFile(t, path), "changed %s", path)
}
for _, hook := range []string{"pre-commit", "post-rewrite"} {
require.Equal(t, foreign, string(readInitHooksFile(t, filepath.Join(current, hook))))
}
if name == "private" {
paths, err := git.ResolveHooksContext(selected, hooks.env)
require.NoError(t, err)
require.Equal(t, current, paths.HooksDir, "private override remains effective")
}
require.Equal(t, env, os.Environ())
})
}
}