beads/cmd/bd/store_selection_removed_backend_test.go
Julian Knutsen b13fab0151
fix(storage): truthful legacy-backend tombstone rejection — detect present Dolt data, give the exact heal (D-8) (#6044)
* fix(configfile): detect present Dolt data and give the exact metadata heal (D-8)

A workspace whose metadata.json names sqlite/postgres/mysql stays fail-closed,
but the rejection text was not truthful for the common case. bd v1.2.x opened
those workspaces as Dolt regardless of the "backend" value, so for them the
stale field is the only problem — and the old remedy sent the user to export
and reinitialize, destroying a database that is one JSON edit from healthy.

ExistingDoltDataDir stats the embedded (.beads/embeddeddolt) and server-mode
(.beads/dolt, dolt_data_dir, BEADS_DOLT_DATA_DIR) layouts for a .dolt directory,
either at the root or one level down. Detection is stat/readdir only — every
caller is on a path that has promised not to touch storage. The detection
approach is ported from the obsolete PR #4740.

The removed- and unknown-backend messages now branch on it: with Dolt data
present they name metadata.json and the exact edit ("backend": "dolt", or drop
the field); without it they keep today's export/reinitialize path, so the
substrings existing tests pin are unchanged. GetDoltDataDir becomes nil-safe
like GetBackend, since rejection paths resolve it for configs that may be nil.

Co-authored-by: Steve Yegge <steve.yegge@gmail.com>

* fix(storage): thread beadsDir into every legacy-backend rejection (D-8)

All three rejection surfaces now branch on whether the workspace actually holds
a Dolt database: cmd/bd's validateConfiguredBackend (12 call sites, every one
already had beadsDir in scope), internal/storage/dolt's requireDoltBackend, and
the public beads.OpenBestAvailable path. Widening the signatures rather than
adding parallel *At helpers is deliberate — it makes each site state which
workspace it is rejecting, so none can silently keep the generic message.

Behavior is unchanged for workspaces with no Dolt data; test call sites take the
new argument but no assertion changes.

* test(storage): cover the tombstone heal branch and its round-trip (D-8)

The headline test is the round-trip: init a real Dolt workspace, hand-edit
metadata.json to backend:"sqlite", watch bd list exit 1 with the heal message,
apply exactly the edit that message prescribes, and confirm bd list opens the
workspace with its issue intact. The message's stated alternative — deleting the
"backend" field — is exercised too, so both remedies it offers are proven rather
than asserted.

The same test pins the fail-closed guarantee at a level a stat loop could not:
metadata.json stays byte-identical and the whole embedded Dolt tree is unchanged
in paths and sizes after the refusal.

Around it: the ExistingDoltDataDir layout matrix (embedded and server layouts at
both depths, relative and absolute dolt_data_dir, BEADS_DOLT_DATA_DIR, decoys, no
workspace dir), string-level branch coverage in internal/configfile, a public
OpenBestAvailable case proving beadsDir reaches the library refusal, and an
explicit assertion that the no-Dolt-data branch still refuses to suggest a heal
that would open an empty store.

---------

Co-authored-by: Steve Yegge <steve.yegge@gmail.com>
2026-08-28 23:27:39 -07:00

423 lines
15 KiB
Go

package main
import (
"context"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"github.com/steveyegge/beads/internal/configfile"
)
func TestCommandStartupRejectsRemovedBackendsBeforeLocalWrites(t *testing.T) {
bd := buildBDForInitTests(t)
for _, backend := range []string{configfile.BackendPostgres, configfile.BackendMySQL, configfile.BackendSQLite} {
t.Run(backend, func(t *testing.T) {
root := t.TempDir()
beadsDir := filepath.Join(root, ".beads")
if err := os.MkdirAll(beadsDir, 0o755); err != nil {
t.Fatalf("create beads dir: %v", err)
}
if err := (&configfile.Config{Backend: backend}).Save(beadsDir); err != nil {
t.Fatalf("save config: %v", err)
}
cmd := exec.Command(bd, "list", "--json")
cmd.Dir = root
cmd.Env = append(removedBackendTestEnv(beadsDir), "BD_DISABLE_METRICS=1")
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatalf("removed backend %s unexpectedly opened", backend)
}
message := strings.ToLower(string(out))
for _, want := range removedBackendWantSubstrings(backend) {
if !strings.Contains(message, want) {
t.Errorf("startup error for %s missing %q: %s", backend, want, message)
}
}
for _, name := range []string{"embeddeddolt", "dolt", "beads.db", ".local_version"} {
path := filepath.Join(beadsDir, name)
if _, statErr := os.Stat(path); !os.IsNotExist(statErr) {
t.Fatalf("removed backend %s created local state at %s (stat error: %v)", backend, path, statErr)
}
}
})
}
}
func TestCommandStartupRejectsUnknownBackendBeforeLocalWrites(t *testing.T) {
bd := buildBDForInitTests(t)
root := t.TempDir()
beadsDir := filepath.Join(root, ".beads")
if err := os.MkdirAll(beadsDir, 0o700); err != nil {
t.Fatalf("create .beads: %v", err)
}
if err := (&configfile.Config{Backend: "mystery"}).Save(beadsDir); err != nil {
t.Fatalf("save unknown-backend metadata: %v", err)
}
cmd := exec.Command(bd, "list", "--json")
cmd.Dir = root
cmd.Env = append(removedBackendTestEnv(beadsDir), "BD_DISABLE_METRICS=1")
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatalf("unknown backend unexpectedly opened:\n%s", out)
}
message := string(out)
if strings.Contains(message, "no beads database found") {
t.Fatalf("unknown backend stopped at generic discovery instead of metadata guidance:\n%s", out)
}
for _, want := range []string{"not recognized", "opened or modified", "dolt"} {
if !strings.Contains(message, want) {
t.Errorf("unknown-backend error missing %q:\n%s", want, out)
}
}
for _, name := range []string{"embeddeddolt", "dolt", "beads.db", ".local_version"} {
if _, statErr := os.Stat(filepath.Join(beadsDir, name)); !os.IsNotExist(statErr) {
t.Fatalf("unknown backend created %s (stat error: %v)", name, statErr)
}
}
}
func TestInitGuardRejectsCorruptMetadataBeforeWorkspaceWrites(t *testing.T) {
beadsDir := filepath.Join(t.TempDir(), ".beads")
if err := os.MkdirAll(beadsDir, 0o700); err != nil {
t.Fatalf("create .beads: %v", err)
}
metadataPath := filepath.Join(beadsDir, configfile.ConfigFileName)
metadata := []byte("{\n")
if err := os.WriteFile(metadataPath, metadata, 0o600); err != nil {
t.Fatalf("write corrupt metadata.json: %v", err)
}
err := checkExistingBeadsDataAt(beadsDir, "guard")
if err == nil || !strings.Contains(err.Error(), "metadata.json") {
t.Fatalf("init guard error = %v, want corrupt metadata refusal", err)
}
after, readErr := os.ReadFile(metadataPath)
if readErr != nil {
t.Fatalf("read metadata after refusal: %v", readErr)
}
if string(after) != string(metadata) {
t.Fatalf("init guard rewrote corrupt metadata: before %q, after %q", metadata, after)
}
for _, name := range []string{"embeddeddolt", "dolt", "beads.db", ".local_version"} {
if _, statErr := os.Stat(filepath.Join(beadsDir, name)); !os.IsNotExist(statErr) {
t.Fatalf("init guard created %s (stat error: %v)", name, statErr)
}
}
}
func TestDoctorRejectsUnknownBackendBeforeDoltChecks(t *testing.T) {
bd := buildBDForInitTests(t)
root := t.TempDir()
beadsDir := filepath.Join(root, ".beads")
if err := os.MkdirAll(beadsDir, 0o700); err != nil {
t.Fatalf("create .beads: %v", err)
}
cfg := &configfile.Config{
Backend: "mystery",
DoltMode: configfile.DoltModeServer,
DoltServerHost: "127.0.0.1",
DoltServerPort: 1,
}
if err := cfg.Save(beadsDir); err != nil {
t.Fatalf("save unknown-backend metadata: %v", err)
}
cmd := exec.Command(bd, "doctor", "--server", "--json")
cmd.Dir = root
cmd.Env = append(removedBackendTestEnv(beadsDir), "BEADS_DOLT_AUTO_START=0", "BD_DISABLE_METRICS=1")
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatalf("doctor unexpectedly ran Dolt checks for unknown backend:\n%s", out)
}
for _, want := range []string{"not recognized", "no storage database was opened or modified", "dolt"} {
if !strings.Contains(string(out), want) {
t.Errorf("doctor unknown-backend error missing %q:\n%s", want, out)
}
}
for _, name := range []string{"embeddeddolt", "dolt", "beads.db", "dolt-server.pid", "dolt-server.port"} {
if _, statErr := os.Stat(filepath.Join(beadsDir, name)); !os.IsNotExist(statErr) {
t.Fatalf("doctor created %s for unknown backend (stat error: %v)", name, statErr)
}
}
}
func TestLegacyInitFlagsReachRemovedBackendGuidance(t *testing.T) {
bd := buildBDForInitTests(t)
tests := []struct {
backend string
args []string
wants []string
}{
{
backend: configfile.BackendPostgres,
args: []string{
"init", "--backend=postgres",
"--pg-url=postgres://beads@127.0.0.1:5432/beads",
"--pg-schema=legacy_workspace",
},
wants: []string{"no longer supported", "general-purpose server databases", "simple and resource-light", "dolt"},
},
{
backend: configfile.BackendMySQL,
args: []string{
"init", "--backend=mysql",
"--mysql-url=beads@tcp(127.0.0.1:3306)/",
"--mysql-database=legacy_workspace",
},
wants: []string{"no longer supported", "general-purpose server databases", "simple and resource-light", "dolt"},
},
{
backend: configfile.BackendSQLite,
args: []string{
"init", "--backend=sqlite",
"--sqlite-path=beads.db",
},
wants: []string{"no longer supported", "single engine", "dolt"},
},
}
for _, tt := range tests {
t.Run(tt.backend, func(t *testing.T) {
root := t.TempDir()
beadsDir := filepath.Join(root, ".beads")
cmd := exec.Command(bd, tt.args...)
cmd.Dir = root
cmd.Env = append(removedBackendTestEnv(beadsDir), "BD_DISABLE_METRICS=1")
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatalf("legacy %s init unexpectedly succeeded: %s", tt.backend, out)
}
message := string(out)
if strings.Contains(message, "unknown flag") {
t.Errorf("legacy %s init stopped at argument parsing instead of rollback guidance: %s", tt.backend, message)
}
for _, want := range tt.wants {
if !strings.Contains(message, want) {
t.Errorf("legacy %s init error missing %q: %s", tt.backend, want, message)
}
}
if _, statErr := os.Stat(beadsDir); !os.IsNotExist(statErr) {
t.Fatalf("rejected legacy %s init created workspace state (stat error: %v)", tt.backend, statErr)
}
})
}
}
func TestDoltAdministrativeCommandsRejectRemovedBackends(t *testing.T) {
bd := buildBDForInitTests(t)
commands := []struct {
name string
args []string
}{
{name: "show", args: []string{"dolt", "show"}},
{name: "status", args: []string{"dolt", "status"}},
{name: "set", args: []string{"dolt", "set", "host", "127.0.0.1"}},
{name: "test", args: []string{"dolt", "test"}},
{name: "start", args: []string{"dolt", "start"}},
{name: "stop", args: []string{"dolt", "stop"}},
{name: "killall", args: []string{"dolt", "killall"}},
{name: "clean-databases", args: []string{"dolt", "clean-databases", "--dry-run"}},
}
root := t.TempDir()
beadsDir := filepath.Join(root, ".beads")
if err := os.MkdirAll(beadsDir, 0o755); err != nil {
t.Fatalf("create beads dir: %v", err)
}
if err := (&configfile.Config{Backend: configfile.BackendSQLite}).Save(beadsDir); err != nil {
t.Fatalf("save config: %v", err)
}
for _, command := range commands {
t.Run(command.name, func(t *testing.T) {
cmd := exec.Command(bd, command.args...)
cmd.Dir = root
cmd.Env = append(removedBackendTestEnv(beadsDir), "BD_DISABLE_METRICS=1")
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatalf("%q unexpectedly succeeded for removed backend %s: %s", strings.Join(command.args, " "), configfile.BackendSQLite, out)
}
message := strings.ToLower(string(out))
for _, want := range removedBackendWantSubstrings(configfile.BackendSQLite) {
if !strings.Contains(message, want) {
t.Errorf("%q error for %s missing %q: %s", strings.Join(command.args, " "), configfile.BackendSQLite, want, message)
}
}
for _, name := range []string{"embeddeddolt", "dolt", "beads.db", ".local_version"} {
path := filepath.Join(beadsDir, name)
if _, statErr := os.Stat(path); !os.IsNotExist(statErr) {
t.Fatalf("%q created local state for removed backend %s at %s (stat error: %v)", strings.Join(command.args, " "), configfile.BackendSQLite, path, statErr)
}
}
})
}
}
func TestDoltReadOnlyCommandsRejectUnknownBackend(t *testing.T) {
bd := buildBDForInitTests(t)
root := t.TempDir()
beadsDir := filepath.Join(root, ".beads")
if err := os.MkdirAll(beadsDir, 0o700); err != nil {
t.Fatalf("create .beads: %v", err)
}
if err := (&configfile.Config{Backend: "mystery", DoltMode: configfile.DoltModeServer, DoltServerPort: 1}).Save(beadsDir); err != nil {
t.Fatalf("save unknown-backend metadata: %v", err)
}
for _, args := range [][]string{{"dolt", "show"}, {"dolt", "status"}, {"dolt", "killall"}} {
cmd := exec.Command(bd, args...)
cmd.Dir = root
cmd.Env = append(removedBackendTestEnv(beadsDir), "BEADS_DOLT_AUTO_START=0", "BD_DISABLE_METRICS=1")
out, err := cmd.CombinedOutput()
if err == nil {
t.Errorf("bd %s unexpectedly treated unknown metadata as Dolt:\n%s", strings.Join(args, " "), out)
continue
}
if !strings.Contains(string(out), "not recognized") || !strings.Contains(string(out), "opened or modified") {
t.Errorf("bd %s error lacks fail-closed guidance:\n%s", strings.Join(args, " "), out)
}
}
}
func TestDoltKillallRejectsCorruptMetadataBeforeServerCleanup(t *testing.T) {
bd := buildBDForInitTests(t)
root := t.TempDir()
beadsDir := filepath.Join(root, ".beads")
if err := os.MkdirAll(beadsDir, 0o700); err != nil {
t.Fatalf("create .beads: %v", err)
}
metadata := []byte("{\n")
metadataPath := filepath.Join(beadsDir, configfile.ConfigFileName)
if err := os.WriteFile(metadataPath, metadata, 0o600); err != nil {
t.Fatalf("write corrupt metadata: %v", err)
}
cmd := exec.Command(bd, "dolt", "killall")
cmd.Dir = root
cmd.Env = append(removedBackendTestEnv(beadsDir),
"BEADS_DOLT_SHARED_SERVER=1",
"BEADS_DOLT_AUTO_START=0",
"BEADS_SHARED_SERVER_DIR="+filepath.Join(root, "shared-server"),
"BD_DISABLE_METRICS=1",
)
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatalf("bd dolt killall unexpectedly ignored corrupt metadata:\n%s", out)
}
message := strings.ToLower(string(out))
for _, want := range []string{"loading config", "parsing config"} {
if !strings.Contains(message, want) {
t.Errorf("bd dolt killall corrupt-metadata error missing %q:\n%s", want, out)
}
}
after, readErr := os.ReadFile(metadataPath)
if readErr != nil {
t.Fatalf("read metadata after refusal: %v", readErr)
}
if string(after) != string(metadata) {
t.Fatalf("bd dolt killall rewrote corrupt metadata: before %q, after %q", metadata, after)
}
for _, name := range []string{"embeddeddolt", "dolt", "beads.db", ".local_version", "dolt-server.pid", "dolt-server.port"} {
if _, statErr := os.Stat(filepath.Join(beadsDir, name)); !os.IsNotExist(statErr) {
t.Fatalf("bd dolt killall created %s before rejecting corrupt metadata (stat error: %v)", name, statErr)
}
}
}
func removedBackendTestEnv(beadsDir string) []string {
var env []string
for _, entry := range os.Environ() {
if strings.HasPrefix(entry, "BEADS_") || strings.HasPrefix(entry, "BD_") {
continue
}
env = append(env, entry)
}
return append(env, "BEADS_DIR="+beadsDir)
}
func TestStoreFactoriesRemovedBackendsFailLoud(t *testing.T) {
for _, backend := range []string{configfile.BackendPostgres, configfile.BackendMySQL, configfile.BackendSQLite} {
t.Run(backend, func(t *testing.T) {
beadsDir := t.TempDir()
cfg := &configfile.Config{Backend: backend}
if err := cfg.Save(beadsDir); err != nil {
t.Fatalf("save config: %v", err)
}
factories := map[string]func(context.Context, string) (interface{ Close() error }, error){
"read-write": func(ctx context.Context, dir string) (interface{ Close() error }, error) {
return newDoltStoreFromConfig(ctx, dir)
},
"read-only": func(ctx context.Context, dir string) (interface{ Close() error }, error) {
return newReadOnlyStoreFromConfig(ctx, dir)
},
}
for name, open := range factories {
t.Run(name, func(t *testing.T) {
store, err := open(t.Context(), beadsDir)
if err == nil {
if store != nil {
_ = store.Close()
}
t.Fatalf("expected removed-backend error for %s", backend)
}
if !strings.Contains(err.Error(), "no longer supported") {
t.Fatalf("error should explain that %s is no longer supported: %v", backend, err)
}
guidance := strings.ToLower(err.Error())
if !strings.Contains(guidance, "export") || !strings.Contains(guidance, "dolt") {
t.Fatalf("error should provide safe migration guidance: %v", err)
}
// With no Dolt data on disk the configured database really is
// the only copy, so the export path is right and the D-8 heal
// must not be offered — that edit would open an empty store.
if strings.Contains(guidance, "to heal") {
t.Fatalf("error offered a metadata heal for a workspace with no Dolt data: %v", err)
}
for _, name := range []string{"embeddeddolt", "dolt", "beads.db"} {
path := filepath.Join(beadsDir, name)
if _, statErr := os.Stat(path); !os.IsNotExist(statErr) {
t.Fatalf("removed backend %s created local storage at %s (stat error: %v)", backend, path, statErr)
}
}
})
}
})
}
}
func TestRequireDoltBackend(t *testing.T) {
beadsDir := t.TempDir()
for _, cfg := range []*configfile.Config{nil, {}, {Backend: configfile.BackendDolt}} {
if err := requireDoltBackend(cfg, beadsDir); err != nil {
t.Fatalf("Dolt config %#v rejected: %v", cfg, err)
}
}
for _, backend := range []string{configfile.BackendPostgres, configfile.BackendMySQL, configfile.BackendSQLite} {
err := requireDoltBackend(&configfile.Config{Backend: backend}, beadsDir)
if err == nil || !strings.Contains(err.Error(), "no longer supported") || !strings.Contains(err.Error(), "export") {
t.Fatalf("removed backend %q guard error = %v, want rollback and migration guidance", backend, err)
}
}
}
// removedBackendWantSubstrings returns the guidance substrings every removed-backend
// rejection must carry, including the backend-specific rationale marker.
func removedBackendWantSubstrings(backend string) []string {
wants := []string{"no longer supported", "was not opened", "export", "dolt"}
if backend == configfile.BackendSQLite {
return append(wants, "single engine")
}
return append(wants, "general-purpose server databases", "simple and resource-light")
}