diff --git a/cmd/bd/BUILD.bazel b/cmd/bd/BUILD.bazel index 1cce122c0..c1d6dc098 100644 --- a/cmd/bd/BUILD.bazel +++ b/cmd/bd/BUILD.bazel @@ -765,6 +765,7 @@ go_test( "gc_embedded_test.go", "gc_prune_test.go", "git_repo_template_test.go", + "git_test_helpers_scope_test.go", "github_link_scope_test.go", "gitlab_integration_test.go", "gitlab_test.go", diff --git a/cmd/bd/context_identity_test.go b/cmd/bd/context_identity_test.go index 6e166d370..aa310ad18 100644 --- a/cmd/bd/context_identity_test.go +++ b/cmd/bd/context_identity_test.go @@ -11,7 +11,6 @@ import ( "github.com/steveyegge/beads/internal/beads" "github.com/steveyegge/beads/internal/configfile" - "github.com/steveyegge/beads/internal/git" "github.com/steveyegge/beads/internal/storage" "github.com/steveyegge/beads/internal/storage/backends" "github.com/steveyegge/beads/internal/storage/contextinfo" @@ -84,13 +83,7 @@ func TestContextRoutesNameOneWorkspaceTheSameWay(t *testing.T) { } t.Chdir(dir) t.Setenv("BEADS_DIR", beadsDir) - // git caches the cwd's repository context process-wide; a test - // that ran earlier from a non-repo directory would otherwise make - // this fresh repo look like "not a git repository". - git.ResetCaches() - beads.ResetCaches() - t.Cleanup(beads.ResetCaches) - t.Cleanup(git.ResetCaches) + resetRepoCachesForTest(t) provider, err := contextinfo.NewContextProvider(dir, Version).ContextUseCase().GetContextInfo(t.Context()) if err != nil { diff --git a/cmd/bd/git_test_helpers.go b/cmd/bd/git_test_helpers.go index cdada0978..774697005 100644 --- a/cmd/bd/git_test_helpers.go +++ b/cmd/bd/git_test_helpers.go @@ -8,11 +8,26 @@ import ( "github.com/steveyegge/beads/internal/git" ) -// runInDir changes into dir, resets the beads and git caches before/after, and -// executes fn. It ensures tests that mutate git repositories don't leak state -// across cases. Both caches are keyed on the working directory, so a chdir -// fixture has to clear the pair going in and coming out — clearing only one -// leaves the other answering for the previous directory. +// resetRepoCaches is the single definition of this file's fixture invariant: +// the workspace and Git discovery caches are reset together, because workspace +// discovery resolves through the Git cache and would otherwise reprime from a +// previous fixture's answer. +func resetRepoCaches() { + beads.ResetCaches() + git.ResetCaches() +} + +// resetRepoCachesForTest gives a serial fixture fresh workspace and Git +// discovery, including cached failures. Call after changing its directory. +func resetRepoCachesForTest(t *testing.T) { + t.Helper() + resetRepoCaches() + t.Cleanup(resetRepoCaches) +} + +// runInDir changes into dir, resets the repository discovery caches +// before/after, and executes fn. It ensures tests that mutate git repositories +// don't leak state across cases. func runInDir(t *testing.T, dir string, fn func()) { t.Helper() origDir, err := os.Getwd() @@ -22,14 +37,12 @@ func runInDir(t *testing.T, dir string, fn func()) { if err := os.Chdir(dir); err != nil { t.Fatalf("failed to change to temp directory: %v", err) } - beads.ResetCaches() - git.ResetCaches() + resetRepoCaches() defer func() { if err := os.Chdir(origDir); err != nil { t.Fatalf("failed to restore working directory: %v", err) } - beads.ResetCaches() - git.ResetCaches() + resetRepoCaches() }() fn() } diff --git a/cmd/bd/git_test_helpers_scope_test.go b/cmd/bd/git_test_helpers_scope_test.go new file mode 100644 index 000000000..5f97fd7d6 --- /dev/null +++ b/cmd/bd/git_test_helpers_scope_test.go @@ -0,0 +1,111 @@ +package main + +import ( + "os" + "path/filepath" + "testing" + + "github.com/steveyegge/beads/internal/beads" + "github.com/steveyegge/beads/internal/git" +) + +func TestResetRepoCachesForTestScopesDiscovery(t *testing.T) { + t.Setenv("BEADS_DIR", "") + repo := t.TempDir() + initGitRepoAt(t, repo) + beadsDir := filepath.Join(repo, ".beads") + if err := os.Mkdir(beadsDir, 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), []byte(`{"backend":"dolt"}`), 0o600); err != nil { + t.Fatal(err) + } + + t.Chdir(t.TempDir()) + resetRepoCachesForTest(t) + assertNoWorkspace := func() { + t.Helper() + if got := git.GetRepoRoot(); got != "" { + t.Fatalf("non-repository directory resolved Git root %q", got) + } + if ctx, err := beads.GetRepoContext(); err == nil || ctx != nil { + t.Fatalf("non-workspace directory resolved context %+v, err=%v", ctx, err) + } + } + // Prime both cached failures before entering a different fixture. + assertNoWorkspace() + t.Run("repository", func(t *testing.T) { + t.Chdir(repo) + resetRepoCachesForTest(t) + ctx, err := beads.GetRepoContext() + if err != nil { + t.Fatal(err) + } + for _, paths := range []struct{ got, want string }{ + {git.GetRepoRoot(), repo}, + {ctx.RepoRoot, repo}, + {ctx.BeadsDir, beadsDir}, + } { + gotInfo, err := os.Stat(paths.got) + if err != nil { + t.Fatal(err) + } + wantInfo, err := os.Stat(paths.want) + if err != nil { + t.Fatal(err) + } + if !os.SameFile(gotInfo, wantInfo) { + t.Errorf("discovered %q, want filesystem identity of %q", paths.got, paths.want) + } + } + }) + // The child primed successful answers; its cleanup must discard both. + assertNoWorkspace() +} + +// runInDir shares the invariant above, so it owes the same guarantee: workspace +// discovery must follow it into dir and must not survive the restore. +func TestRunInDirScopesWorkspaceDiscovery(t *testing.T) { + t.Setenv("BEADS_DIR", "") + repo := t.TempDir() + initGitRepoAt(t, repo) + beadsDir := filepath.Join(repo, ".beads") + if err := os.Mkdir(beadsDir, 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), []byte(`{"backend":"dolt"}`), 0o600); err != nil { + t.Fatal(err) + } + + t.Chdir(t.TempDir()) + resetRepoCachesForTest(t) + assertNoWorkspaceContext := func() { + t.Helper() + if ctx, err := beads.GetRepoContext(); err == nil || ctx != nil { + t.Fatalf("non-workspace directory resolved context %+v, err=%v", ctx, err) + } + } + // Prime the cached failure that a Git-only reset would leave in place. + assertNoWorkspaceContext() + + runInDir(t, repo, func() { + ctx, err := beads.GetRepoContext() + if err != nil { + t.Fatalf("runInDir left workspace discovery scoped to the previous directory: %v", err) + } + gotInfo, err := os.Stat(ctx.BeadsDir) + if err != nil { + t.Fatal(err) + } + wantInfo, err := os.Stat(beadsDir) + if err != nil { + t.Fatal(err) + } + if !os.SameFile(gotInfo, wantInfo) { + t.Errorf("discovered %q, want filesystem identity of %q", ctx.BeadsDir, beadsDir) + } + }) + + // runInDir primed a successful answer; its restore must discard it too. + assertNoWorkspaceContext() +} diff --git a/cmd/bd/serve_registered_backend_test.go b/cmd/bd/serve_registered_backend_test.go index c06f907f3..872532de1 100644 --- a/cmd/bd/serve_registered_backend_test.go +++ b/cmd/bd/serve_registered_backend_test.go @@ -427,12 +427,7 @@ func TestServeRefusesStrictReadonlyOnARegisteredBackend(t *testing.T) { restoreServeGlobals(t) t.Chdir(dir) t.Setenv("BEADS_DIR", beadsDir) - beads.ResetCaches() - git.ResetCaches() - t.Cleanup(func() { - beads.ResetCaches() - git.ResetCaches() - }) + resetRepoCachesForTest(t) origReadonly := readonlyMode readonlyMode = true diff --git a/cmd/bd/serve_test.go b/cmd/bd/serve_test.go index fe64500f6..a94be1241 100644 --- a/cmd/bd/serve_test.go +++ b/cmd/bd/serve_test.go @@ -16,7 +16,6 @@ import ( "github.com/spf13/pflag" - "github.com/steveyegge/beads/internal/beads" "github.com/steveyegge/beads/internal/configfile" "github.com/steveyegge/beads/internal/httpapi" "github.com/steveyegge/beads/internal/storage" @@ -484,8 +483,7 @@ func runServeUnderReadonly(t *testing.T, dir string) (string, error) { // without this a directory with no workspace would still resolve to // whichever one an earlier test in this binary left behind — and "no // workspace" is the whole premise of the ordering assertion above. - beads.ResetCaches() - t.Cleanup(beads.ResetCaches) + resetRepoCachesForTest(t) var err error stderr := captureBootstrapStderr(t, func() { err = runServe() })