beads/cmd/bd/store_selection_removed_backend_test.go

403 lines
14 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} {
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 []string{"no longer supported", "simple and resource-light", "was not opened", "export", "dolt", "sqlite"} {
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", "sqlite"} {
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", "sqlite"} {
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
}{
{
backend: configfile.BackendPostgres,
args: []string{
"init", "--backend=postgres",
"--pg-url=postgres://beads@127.0.0.1:5432/beads",
"--pg-schema=legacy_workspace",
},
},
{
backend: configfile.BackendMySQL,
args: []string{
"init", "--backend=mysql",
"--mysql-url=beads@tcp(127.0.0.1:3306)/",
"--mysql-database=legacy_workspace",
},
},
}
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 []string{"no longer supported", "general-purpose server databases", "simple and resource-light", "dolt", "sqlite"} {
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"}},
}
for _, backend := range []string{configfile.BackendPostgres, configfile.BackendMySQL} {
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)
}
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, " "), backend, out)
}
message := strings.ToLower(string(out))
for _, want := range []string{"no longer supported", "simple and resource-light", "was not opened", "export", "dolt", "sqlite"} {
if !strings.Contains(message, want) {
t.Errorf("%q error for %s missing %q: %s", strings.Join(command.args, " "), 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("%q created local state for removed backend %s at %s (stat error: %v)", strings.Join(command.args, " "), backend, 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} {
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") || !strings.Contains(guidance, "sqlite") {
t.Fatalf("error should provide safe migration guidance: %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) {
for _, cfg := range []*configfile.Config{nil, {}, {Backend: configfile.BackendDolt}} {
if err := requireDoltBackend(cfg); err != nil {
t.Fatalf("Dolt config %#v rejected: %v", cfg, err)
}
}
if err := requireDoltBackend(&configfile.Config{Backend: configfile.BackendSQLite}); err == nil || !strings.Contains(err.Error(), "not using Dolt") {
t.Fatalf("SQLite Dolt-command guard error = %v, want non-Dolt explanation", err)
}
for _, backend := range []string{configfile.BackendPostgres, configfile.BackendMySQL} {
err := requireDoltBackend(&configfile.Config{Backend: backend})
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)
}
}
}