From 0fb03015fe60fba2aaa5cb5d88665d4e2d75ef6c Mon Sep 17 00:00:00 2001 From: Julian Knutsen Date: Sun, 2 Aug 2026 07:09:07 -0700 Subject: [PATCH] test: reuse pristine embedded Dolt fixtures (bd-7q32v) (#5274) --- .../storage/embeddeddolt/conformance_test.go | 170 +---------- .../storage/embeddeddolt/create_issue_test.go | 22 +- .../storage/embeddeddolt/test_fixture_test.go | 282 ++++++++++++++++++ 3 files changed, 290 insertions(+), 184 deletions(-) create mode 100644 internal/storage/embeddeddolt/test_fixture_test.go diff --git a/internal/storage/embeddeddolt/conformance_test.go b/internal/storage/embeddeddolt/conformance_test.go index 65360f754..1c4784864 100644 --- a/internal/storage/embeddeddolt/conformance_test.go +++ b/internal/storage/embeddeddolt/conformance_test.go @@ -3,24 +3,13 @@ package embeddeddolt_test import ( - "crypto/sha256" - "errors" - "fmt" - "io" "os" - "path/filepath" "testing" "github.com/steveyegge/beads/internal/storage" "github.com/steveyegge/beads/internal/storage/conformance" - "github.com/steveyegge/beads/internal/storage/embeddeddolt" - "github.com/steveyegge/beads/internal/types" ) -type pristineConformanceTemplate struct { - beadsDir string -} - func requireEmbeddedDolt(t *testing.T) { t.Helper() if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" { @@ -28,168 +17,15 @@ func requireEmbeddedDolt(t *testing.T) { } } -func newPristineConformanceTemplate(t *testing.T) pristineConformanceTemplate { - t.Helper() - ctx := t.Context() - beadsDir := filepath.Join(t.TempDir(), ".beads") - store, err := embeddeddolt.Open(ctx, beadsDir, "test", "main") - if err != nil { - t.Fatalf("open pristine conformance template: %v", err) - } - if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil { - t.Fatalf("configure pristine conformance template: %v", err) - } - if err := store.Commit(ctx, "bd init"); err != nil { - t.Fatalf("commit pristine conformance template: %v", err) - } - closeEmbeddedDoltStore(t, store) - return pristineConformanceTemplate{beadsDir: beadsDir} -} - -func clonePristineConformanceTemplate(template pristineConformanceTemplate, destination string) error { - if err := os.Mkdir(destination, 0o700); err != nil { - return fmt.Errorf("reserve clone destination %q: %w", destination, err) - } - if err := os.CopyFS(destination, os.DirFS(template.beadsDir)); err != nil { - return fmt.Errorf("copy pristine conformance template to %q: %w", destination, err) - } - return nil -} - -func openPristineConformanceClone(t *testing.T, beadsDir string) *embeddeddolt.EmbeddedDoltStore { - t.Helper() - store, err := embeddeddolt.Open(t.Context(), beadsDir, "test", "main") - if err != nil { - t.Fatalf("open pristine conformance clone %q: %v", beadsDir, err) - } - return store -} - -func closeEmbeddedDoltStore(t *testing.T, store *embeddeddolt.EmbeddedDoltStore) { - t.Helper() - if err := store.Close(); err != nil { - t.Fatalf("close embedded Dolt store: %v", err) - } -} - -func directoryDigest(t *testing.T, root string) string { - t.Helper() - digest := sha256.New() - err := filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error { - if err != nil { - return err - } - relative, err := filepath.Rel(root, path) - if err != nil { - return err - } - if _, err := io.WriteString(digest, relative+"\\x00"); err != nil { - return err - } - if entry.IsDir() { - return nil - } - contents, err := os.ReadFile(path) - if err != nil { - return err - } - if _, err := digest.Write(contents); err != nil { - return err - } - return nil - }) - if err != nil { - t.Fatalf("digest %q: %v", root, err) - } - return fmt.Sprintf("%x", digest.Sum(nil)) -} - -func TestPristineConformanceTemplateClonesAreIndependent(t *testing.T) { - requireEmbeddedDolt(t) - - template := newPristineConformanceTemplate(t) - before := directoryDigest(t, template.beadsDir) - - cloneAPath := filepath.Join(t.TempDir(), ".beads") - if err := clonePristineConformanceTemplate(template, cloneAPath); err != nil { - t.Fatalf("clone A: %v", err) - } - cloneBPath := filepath.Join(t.TempDir(), ".beads") - if err := clonePristineConformanceTemplate(template, cloneBPath); err != nil { - t.Fatalf("clone B: %v", err) - } - if err := clonePristineConformanceTemplate(template, cloneAPath); err == nil { - t.Fatal("clone into an existing destination succeeded") - } - - cloneA := openPristineConformanceClone(t, cloneAPath) - if err := cloneA.CreateIssue(t.Context(), &types.Issue{ - ID: "test-1", - Title: "only clone A has this issue", - Status: types.StatusOpen, - IssueType: types.TypeTask, - }, "test"); err != nil { - t.Fatalf("create in clone A: %v", err) - } - if err := cloneA.Commit(t.Context(), "mutate clone A"); err != nil { - t.Fatalf("commit clone A: %v", err) - } - closeEmbeddedDoltStore(t, cloneA) - - if got := directoryDigest(t, template.beadsDir); got != before { - t.Fatalf("template digest changed after clone A mutation: got %s, want %s", got, before) - } - - cloneB := openPristineConformanceClone(t, cloneBPath) - assertEmptyPristineConformanceStore(t, cloneB, "clone B") - closeEmbeddedDoltStore(t, cloneB) - - templateStore := openPristineConformanceClone(t, template.beadsDir) - assertEmptyPristineConformanceStore(t, templateStore, "template") - closeEmbeddedDoltStore(t, templateStore) - if got := directoryDigest(t, template.beadsDir); got != before { - t.Fatalf("template digest changed after reopen: got %s, want %s", got, before) - } - - cloneA = openPristineConformanceClone(t, cloneAPath) - if _, err := cloneA.GetIssue(t.Context(), "test-1"); err != nil { - t.Fatalf("reopened clone A GetIssue(test-1): %v", err) - } - closeEmbeddedDoltStore(t, cloneA) - - cloneB = openPristineConformanceClone(t, cloneBPath) - if _, err := cloneB.GetIssue(t.Context(), "test-1"); !errors.Is(err, storage.ErrNotFound) { - t.Fatalf("reopened clone B GetIssue(test-1) error = %v, want ErrNotFound", err) - } - closeEmbeddedDoltStore(t, cloneB) -} - -func assertEmptyPristineConformanceStore(t *testing.T, store storage.DoltStorage, name string) { - t.Helper() - count, err := store.CountIssues(t.Context(), "", types.IssueFilter{}) - if err != nil { - t.Fatalf("count issues in %s: %v", name, err) - } - if count != 0 { - t.Fatalf("%s has %d issues, want empty store", name, count) - } -} - // TestConformance runs the backend-agnostic storage conformance suite // (internal/storage/conformance) against the embedded Dolt backend, so the // storage contract is enforced against a real implementation rather than only // asserted. The factory returns a fresh, empty in-process store per sub-test. func TestConformance(t *testing.T) { requireEmbeddedDolt(t) - template := newPristineConformanceTemplate(t) - conformance.RunAll(t, func(t *testing.T) storage.DoltStorage { - beadsDir := filepath.Join(t.TempDir(), ".beads") - if err := clonePristineConformanceTemplate(template, beadsDir); err != nil { - t.Fatalf("clone pristine conformance template: %v", err) - } - store := openPristineConformanceClone(t, beadsDir) - t.Cleanup(func() { closeEmbeddedDoltStore(t, store) }) - return store + fixture := newPristineEmbeddedDoltFixture(t, pristineEmbeddedDoltDatabase) + t.Cleanup(func() { closeEmbeddedDoltStore(t, fixture.store) }) + return fixture.store }) } diff --git a/internal/storage/embeddeddolt/create_issue_test.go b/internal/storage/embeddeddolt/create_issue_test.go index bcc4ff272..0385f277a 100644 --- a/internal/storage/embeddeddolt/create_issue_test.go +++ b/internal/storage/embeddeddolt/create_issue_test.go @@ -31,24 +31,12 @@ type testEnv struct { // sets the issue_prefix config, and returns a testEnv with raw SQL access. func newTestEnv(t *testing.T, prefix string) *testEnv { t.Helper() - ctx := t.Context() - beadsDir := filepath.Join(t.TempDir(), ".beads") - store, err := embeddeddolt.Open(ctx, beadsDir, prefix, "main") - if err != nil { - t.Fatalf("Open: %v", err) - } - t.Cleanup(func() { store.Close() }) - - if err := store.SetConfig(ctx, "issue_prefix", prefix); err != nil { - t.Fatalf("SetConfig(issue_prefix): %v", err) - } - if err := store.Commit(ctx, "bd init"); err != nil { - t.Fatalf("Commit: %v", err) - } + fixture := newPristineEmbeddedDoltFixture(t, prefix) + t.Cleanup(func() { closeEmbeddedDoltStore(t, fixture.store) }) return &testEnv{ - store: store, - dataDir: filepath.Join(beadsDir, "embeddeddolt"), - database: prefix, + store: fixture.store, + dataDir: fixture.dataDir, + database: fixture.database, } } diff --git a/internal/storage/embeddeddolt/test_fixture_test.go b/internal/storage/embeddeddolt/test_fixture_test.go new file mode 100644 index 000000000..78b71e1a5 --- /dev/null +++ b/internal/storage/embeddeddolt/test_fixture_test.go @@ -0,0 +1,282 @@ +//go:build cgo + +package embeddeddolt_test + +import ( + "context" + "crypto/sha256" + "errors" + "fmt" + "io" + "os" + "path/filepath" + "strings" + "sync" + "testing" + + "github.com/steveyegge/beads/internal/storage" + "github.com/steveyegge/beads/internal/storage/embeddeddolt" + "github.com/steveyegge/beads/internal/types" +) + +var embeddedDoltFixtureRoot string + +const pristineEmbeddedDoltDatabase = "test" + +var ( + pristineEmbeddedDoltTemplateOnce sync.Once + pristineEmbeddedDoltTemplateValue pristineEmbeddedDoltTemplate + pristineEmbeddedDoltTemplateErr error +) + +type pristineEmbeddedDoltTemplate struct { + beadsDir string + dataDir string +} + +type pristineEmbeddedDoltFixture struct { + store *embeddeddolt.EmbeddedDoltStore + beadsDir string + dataDir string + database string +} + +func TestMain(m *testing.M) { + root, err := os.MkdirTemp("", "embeddeddolt-test-fixtures-") + if err != nil { + fmt.Fprintln(os.Stderr, "create embedded Dolt test fixture root:", err) + os.Exit(1) + } + embeddedDoltFixtureRoot = root + + code := m.Run() + if err := os.RemoveAll(root); err != nil && code == 0 { + fmt.Fprintln(os.Stderr, "remove embedded Dolt test fixture root:", err) + code = 1 + } + os.Exit(code) +} + +func pristineEmbeddedDoltTemplateForTest(t *testing.T) pristineEmbeddedDoltTemplate { + t.Helper() + pristineEmbeddedDoltTemplateOnce.Do(func() { + beadsDir := filepath.Join(embeddedDoltFixtureRoot, ".beads") + store, err := embeddeddolt.Open(context.Background(), beadsDir, pristineEmbeddedDoltDatabase, "main") + if err != nil { + pristineEmbeddedDoltTemplateErr = fmt.Errorf("open pristine embedded Dolt template: %w", err) + return + } + if err := store.SetConfig(context.Background(), "issue_prefix", pristineEmbeddedDoltDatabase); err != nil { + if closeErr := store.Close(); closeErr != nil { + pristineEmbeddedDoltTemplateErr = fmt.Errorf("configure pristine embedded Dolt template: %w", errors.Join(err, closeErr)) + return + } + pristineEmbeddedDoltTemplateErr = fmt.Errorf("configure pristine embedded Dolt template: %w", err) + return + } + if err := store.Commit(context.Background(), "bd init"); err != nil { + if closeErr := store.Close(); closeErr != nil { + pristineEmbeddedDoltTemplateErr = fmt.Errorf("commit pristine embedded Dolt template: %w", errors.Join(err, closeErr)) + return + } + pristineEmbeddedDoltTemplateErr = fmt.Errorf("commit pristine embedded Dolt template: %w", err) + return + } + if err := store.Close(); err != nil { + pristineEmbeddedDoltTemplateErr = fmt.Errorf("close pristine embedded Dolt template: %w", err) + return + } + pristineEmbeddedDoltTemplateValue = pristineEmbeddedDoltTemplate{ + beadsDir: beadsDir, + dataDir: filepath.Join(beadsDir, "embeddeddolt"), + } + }) + if pristineEmbeddedDoltTemplateErr != nil { + t.Fatal(pristineEmbeddedDoltTemplateErr) + } + return pristineEmbeddedDoltTemplateValue +} + +func clonePristineEmbeddedDoltTemplate(template pristineEmbeddedDoltTemplate, destination string) error { + if err := os.Mkdir(destination, 0o700); err != nil { + return fmt.Errorf("reserve clone destination %q: %w", destination, err) + } + if err := os.CopyFS(destination, os.DirFS(template.beadsDir)); err != nil { + return fmt.Errorf("copy pristine embedded Dolt template to %q: %w", destination, err) + } + return nil +} + +func newPristineEmbeddedDoltFixture(t *testing.T, database string) *pristineEmbeddedDoltFixture { + t.Helper() + template := pristineEmbeddedDoltTemplateForTest(t) + beadsDir := filepath.Join(t.TempDir(), ".beads") + if err := clonePristineEmbeddedDoltTemplate(template, beadsDir); err != nil { + t.Fatalf("clone pristine embedded Dolt template: %v", err) + } + fixture := &pristineEmbeddedDoltFixture{ + beadsDir: beadsDir, + dataDir: filepath.Join(beadsDir, "embeddeddolt"), + database: database, + } + if database != pristineEmbeddedDoltDatabase { + if err := relocatePristineEmbeddedDoltDatabase(fixture.dataDir, database); err != nil { + t.Fatalf("relocate pristine embedded Dolt database to %q: %v", database, err) + } + } + store, err := embeddeddolt.Open(t.Context(), fixture.beadsDir, database, "main") + if err != nil { + t.Fatalf("open pristine embedded Dolt clone: %v", err) + } + fixture.store = store + if database != pristineEmbeddedDoltDatabase { + if err := store.SetConfig(t.Context(), "issue_prefix", database); err != nil { + if closeErr := store.Close(); closeErr != nil { + t.Fatalf("configure relocated embedded Dolt clone: %v; close: %v", err, closeErr) + } + t.Fatalf("configure relocated embedded Dolt clone: %v", err) + } + if err := store.Commit(t.Context(), "bd init"); err != nil { + if closeErr := store.Close(); closeErr != nil { + t.Fatalf("commit relocated embedded Dolt clone: %v; close: %v", err, closeErr) + } + t.Fatalf("commit relocated embedded Dolt clone: %v", err) + } + } + return fixture +} + +func relocatePristineEmbeddedDoltDatabase(dataDir, database string) error { + if filepath.Base(database) != database || database == "." || database == ".." { + return fmt.Errorf("database name %q is not a single path element", database) + } + source := filepath.Join(dataDir, pristineEmbeddedDoltDatabase) + destination := filepath.Join(dataDir, database) + if err := os.Rename(source, destination); err != nil { + return fmt.Errorf("rename %q to %q: %w", source, destination, err) + } + return nil +} + +func closeEmbeddedDoltStore(t *testing.T, store *embeddeddolt.EmbeddedDoltStore) { + t.Helper() + if err := store.Close(); err != nil { + t.Fatalf("close embedded Dolt store: %v", err) + } +} + +func directoryDigest(t *testing.T, root string) string { + t.Helper() + digest := sha256.New() + err := filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error { + if err != nil { + return err + } + relative, err := filepath.Rel(root, path) + if err != nil { + return err + } + if _, err := io.WriteString(digest, relative+"\\x00"); err != nil { + return err + } + if entry.IsDir() { + return nil + } + contents, err := os.ReadFile(path) + if err != nil { + return err + } + if _, err := digest.Write(contents); err != nil { + return err + } + return nil + }) + if err != nil { + t.Fatalf("digest %q: %v", root, err) + } + return fmt.Sprintf("%x", digest.Sum(nil)) +} + +func TestPristineEmbeddedDoltFixtureRelocatesPrefixes(t *testing.T) { + template := pristineEmbeddedDoltTemplateForTest(t) + templateDigest := directoryDigest(t, template.beadsDir) + + fast := newPristineEmbeddedDoltFixture(t, "test") + if got := directoryDigest(t, fast.beadsDir); got != templateDigest { + t.Fatalf("test-prefix clone digest = %s, want pristine template %s", got, templateDigest) + } + closeEmbeddedDoltStore(t, fast.store) + + alpha := newPristineEmbeddedDoltFixture(t, "alpha") + beta := newPristineEmbeddedDoltFixture(t, "beta") + for _, fixture := range []*pristineEmbeddedDoltFixture{alpha, beta} { + if _, err := os.Stat(filepath.Join(fixture.dataDir, fixture.database)); err != nil { + t.Fatalf("%s physical database directory: %v", fixture.database, err) + } + if _, err := os.Stat(filepath.Join(fixture.dataDir, pristineEmbeddedDoltDatabase)); !errors.Is(err, os.ErrNotExist) { + t.Fatalf("%s clone still contains baseline database directory: %v", fixture.database, err) + } + prefix, err := fixture.store.GetConfig(t.Context(), "issue_prefix") + if err != nil || prefix != fixture.database { + t.Fatalf("%s issue_prefix = %q, %v; want %q", fixture.database, prefix, err, fixture.database) + } + db, cleanup, err := embeddeddolt.OpenSQL(t.Context(), fixture.dataDir, fixture.database, "main") + if err != nil { + t.Fatalf("open raw SQL for %s: %v", fixture.database, err) + } + var rawPrefix string + err = db.QueryRowContext(t.Context(), "SELECT value FROM config WHERE `key` = ?", "issue_prefix").Scan(&rawPrefix) + if cleanupErr := cleanup(); cleanupErr != nil && err == nil { + err = cleanupErr + } + if err != nil || rawPrefix != fixture.database { + t.Fatalf("raw issue_prefix for %s = %q, %v; want %q", fixture.database, rawPrefix, err, fixture.database) + } + } + + issue := &types.Issue{Title: "only alpha has this", Status: types.StatusOpen, IssueType: types.TypeTask} + if err := alpha.store.CreateIssue(t.Context(), issue, "test"); err != nil { + t.Fatalf("create alpha issue: %v", err) + } + if !strings.HasPrefix(issue.ID, "alpha-") { + t.Fatalf("generated alpha issue ID = %q, want alpha prefix", issue.ID) + } + if err := alpha.store.Commit(t.Context(), "commit alpha issue"); err != nil { + t.Fatalf("commit alpha issue: %v", err) + } + if _, err := beta.store.GetIssue(t.Context(), issue.ID); !errors.Is(err, storage.ErrNotFound) { + t.Fatalf("beta GetIssue(%q) error = %v, want ErrNotFound", issue.ID, err) + } + closeEmbeddedDoltStore(t, alpha.store) + closeEmbeddedDoltStore(t, beta.store) + + alphaReopened, err := embeddeddolt.Open(context.Background(), alpha.beadsDir, "alpha", "main") + if err != nil { + t.Fatalf("reopen alpha: %v", err) + } + if _, err := alphaReopened.GetIssue(t.Context(), issue.ID); err != nil { + t.Fatalf("reopened alpha GetIssue(%q): %v", issue.ID, err) + } + closeEmbeddedDoltStore(t, alphaReopened) + + betaReopened, err := embeddeddolt.Open(context.Background(), beta.beadsDir, "beta", "main") + if err != nil { + t.Fatalf("reopen beta: %v", err) + } + if _, err := betaReopened.GetIssue(t.Context(), issue.ID); !errors.Is(err, storage.ErrNotFound) { + t.Fatalf("reopened beta GetIssue(%q) error = %v, want ErrNotFound", issue.ID, err) + } + closeEmbeddedDoltStore(t, betaReopened) + + if got := directoryDigest(t, template.beadsDir); got != templateDigest { + t.Fatalf("template digest changed after relocated clone mutations: got %s, want %s", got, templateDigest) + } + + reusedDestination := filepath.Join(t.TempDir(), ".beads") + if err := clonePristineEmbeddedDoltTemplate(template, reusedDestination); err != nil { + t.Fatalf("first clone into reusable destination: %v", err) + } + if err := clonePristineEmbeddedDoltTemplate(template, reusedDestination); err == nil { + t.Fatal("clone into an existing destination succeeded") + } +}