beads/cmd/bd/init_guard_test.go
Harry Miller 4a25937df2
fix: replace deprecated --force flag with --reinit-local in init error messages (#3695)
* fix: replace deprecated --force flag with --reinit-local in init error messages

Four error messages in init.go suggested 'bd init --force --prefix <x>'
when a workspace was already initialized. The --force flag was deprecated
in favor of --reinit-local, but the error messages were never updated.

Fixes #3684

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* test: add regression tests for GH#3684 --reinit-local in error messages

Add TestCheckExistingBeadsData_SuggestsReinitLocal with two subtests
(embedded_dolt, sqlite_db_file) that verify the 'already initialized'
error messages recommend --reinit-local instead of the deprecated --force.

Also strengthen existing guard tests (server_mode_with_dolt_dir_blocks_init,
embedded_mode_with_existing_db_blocks_init, embedded_metadata_ignores_ambient)
with GH#3684 assertions.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-05-04 11:42:47 -07:00

453 lines
15 KiB
Go

package main
import (
"encoding/json"
"os"
"path/filepath"
"strings"
"testing"
)
func TestInitGuardServerMessage(t *testing.T) {
tests := map[string]struct {
dbName string
host string
port int
prefix string
syncRemote string
wantContains []string
wantNotContain []string
}{
"DB missing, no sync.remote configured (FR-010, FR-011)": {
dbName: "acf_beads",
host: "127.0.0.1",
port: 3309,
prefix: "acf",
syncRemote: "",
wantContains: []string{
`"acf_beads"`,
"127.0.0.1:3309",
"not found on server",
"bd doctor",
"bd dolt status",
"bd bootstrap",
"set sync.remote",
".beads/config.yaml",
"Aborting",
"--force destroys ALL existing issues",
},
wantNotContain: []string{
"sync.remote is configured",
// GH#2363: must NOT suggest --force as the primary action
"bd init --force --prefix",
},
},
"DB missing, sync.remote IS configured (FR-010, FR-011)": {
dbName: "beads_kc",
host: "192.168.1.50",
port: 3307,
prefix: "kc",
syncRemote: "https://doltremoteapi.dolthub.com/myorg/beads",
wantContains: []string{
`"beads_kc"`,
"192.168.1.50:3307",
"not found on server",
"bd doctor",
"bd dolt status",
"bd bootstrap",
"sync.remote is configured",
"https://doltremoteapi.dolthub.com/myorg/beads",
"--force destroys ALL existing issues",
},
wantNotContain: []string{
"set sync.remote",
// GH#2363: must NOT suggest --force as the primary action
"bd init --force --prefix",
"bd init --force to bootstrap",
},
},
}
for name, tt := range tests {
t.Run(name, func(t *testing.T) {
err := initGuardServerMessage(tt.dbName, tt.host, tt.port, tt.prefix, tt.syncRemote)
if err == nil {
t.Fatal("expected non-nil error")
}
msg := err.Error()
for _, want := range tt.wantContains {
if !strings.Contains(msg, want) {
t.Errorf("expected message to contain %q, got:\n%s", want, msg)
}
}
for _, notWant := range tt.wantNotContain {
if strings.Contains(msg, notWant) {
t.Errorf("expected message NOT to contain %q, got:\n%s", notWant, msg)
}
}
})
}
}
func TestInitGuardDBCheck_ExistsPath(t *testing.T) {
// FR-012: When checkDatabaseOnServer returns Exists=true, the init guard
// should fall through to existing "already initialized" message.
// We verify the guard's branching logic: only Reachable=true AND Exists=false
// triggers the new message; Exists=true must NOT trigger it.
t.Run("exists=true skips refined message", func(t *testing.T) {
// Simulate the guard's decision logic directly.
// When DB exists, the guard should NOT call initGuardServerMessage.
result := initGuardDBCheck{Exists: true, Reachable: true}
if result.Reachable && !result.Exists && result.Err == nil {
t.Fatal("guard would incorrectly show refined message for existing DB")
}
// Pass: the condition is false, so the guard falls through to "already initialized".
})
t.Run("exists=false triggers refined message", func(t *testing.T) {
result := initGuardDBCheck{Exists: false, Reachable: true}
if !(result.Reachable && !result.Exists && result.Err == nil) {
t.Fatal("guard would NOT show refined message for missing DB")
}
// Verify the message content matches FR-010.
err := initGuardServerMessage("test_db", "127.0.0.1", 3309, "test", "")
if err == nil {
t.Fatal("expected non-nil error")
}
if !strings.Contains(err.Error(), "not found on server") {
t.Errorf("expected 'not found on server' in message, got:\n%s", err.Error())
}
if !strings.Contains(err.Error(), "bd bootstrap") {
t.Errorf("expected bootstrap-first recovery guidance, got:\n%s", err.Error())
}
})
}
func TestInitGuardDBCheck_ServerUnreachable(t *testing.T) {
// FR-030: When server is unreachable, should return Reachable=false
// so caller falls through to existing error path without panic.
result := checkDatabaseOnServer("127.0.0.1", 1, "root", "", "nonexistent_db", false)
if result.Reachable {
t.Fatal("expected Reachable=false for connection refused")
}
if result.Err == nil {
t.Fatal("expected non-nil error for connection refused")
}
// Key assertion: no panic occurred — FR-030 satisfied.
}
func TestInitGuard_FreshCloneWithMetadataJSON(t *testing.T) {
// GH#2433: On a fresh clone, metadata.json is committed (tracked by git)
// but dolt/ directory is gitignored. The init guard should recognize this
// as a fresh clone and allow init to proceed.
t.Run("server_mode_metadata_no_dolt_dir_allows_init", func(t *testing.T) {
// Switch to server mode for this subtest
oldServerMode := serverMode
serverMode = true
defer func() { serverMode = oldServerMode }()
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatal(err)
}
// Write metadata.json as it would be on a fresh clone:
// DoltMode=server, DoltDatabase set, but no dolt/ directory.
metadata := map[string]interface{}{
"database": "dolt",
"backend": "dolt",
"dolt_mode": "server",
"dolt_database": "myproject",
}
data, _ := json.Marshal(metadata)
metadataPath := filepath.Join(beadsDir, "metadata.json")
if err := os.WriteFile(metadataPath, data, 0644); err != nil {
t.Fatal(err)
}
// No dolt/ directory — simulates fresh clone with gitignored dolt/.
// No server running — simulates machine B with no local server.
err := checkExistingBeadsDataAt(beadsDir, "myproject")
if err != nil {
t.Errorf("fresh clone with metadata.json should allow init, got: %v", err)
}
})
t.Run("server_mode_with_dolt_dir_blocks_init", func(t *testing.T) {
// Switch to server mode for this subtest
oldServerMode := serverMode
serverMode = true
defer func() { serverMode = oldServerMode }()
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatal(err)
}
// Write metadata.json with server mode
metadata := map[string]interface{}{
"database": "dolt",
"backend": "dolt",
"dolt_mode": "server",
"dolt_database": "myproject",
}
data, _ := json.Marshal(metadata)
if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), data, 0644); err != nil {
t.Fatal(err)
}
// Create dolt/ directory — this is NOT a fresh clone
doltDir := filepath.Join(beadsDir, "dolt")
if err := os.MkdirAll(doltDir, 0755); err != nil {
t.Fatal(err)
}
err := checkExistingBeadsDataAt(beadsDir, "myproject")
if err == nil {
t.Error("existing dolt directory should block init")
}
if err != nil && !strings.Contains(err.Error(), "already initialized") {
t.Errorf("expected 'already initialized' message, got: %v", err)
}
// GH#3684: must suggest --reinit-local, not deprecated --force
if err != nil && strings.Contains(err.Error(), "init --force") {
t.Errorf("message must NOT suggest deprecated --force, got:\n%s", err)
}
})
t.Run("embedded_mode_no_embeddeddolt_dir_allows_init", func(t *testing.T) {
// Embedded mode is the default — no need to set serverMode
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatal(err)
}
// Write metadata.json with embedded mode
metadata := map[string]interface{}{
"database": "dolt",
"backend": "dolt",
"dolt_mode": "embedded",
}
data, _ := json.Marshal(metadata)
if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), data, 0644); err != nil {
t.Fatal(err)
}
// No embeddeddolt/ directory — simulates fresh clone
err := checkExistingBeadsDataAt(beadsDir, "test")
if err != nil {
t.Errorf("fresh clone with embedded metadata should allow init, got: %v", err)
}
})
t.Run("embedded_mode_with_existing_db_blocks_init", func(t *testing.T) {
// Embedded mode is the default — no need to set serverMode
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatal(err)
}
// Write metadata.json with embedded mode
metadata := map[string]interface{}{
"database": "dolt",
"backend": "dolt",
"dolt_mode": "embedded",
}
data, _ := json.Marshal(metadata)
if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), data, 0644); err != nil {
t.Fatal(err)
}
// Create embeddeddolt/<db>/.dolt/ to simulate an existing embedded database
dbDir := filepath.Join(beadsDir, "embeddeddolt", "beads", ".dolt")
if err := os.MkdirAll(dbDir, 0755); err != nil {
t.Fatal(err)
}
err := checkExistingBeadsDataAt(beadsDir, "test")
if err == nil {
t.Error("existing embedded database should block init")
}
if err != nil && !strings.Contains(err.Error(), "already initialized") {
t.Errorf("expected 'already initialized' message, got: %v", err)
}
// GH#3684: must suggest --reinit-local, not deprecated --force
if err != nil && strings.Contains(err.Error(), "init --force") {
t.Errorf("message must NOT suggest deprecated --force, got:\n%s", err)
}
})
t.Run("embedded_metadata_ignores_ambient_shared_server_mode", func(t *testing.T) {
t.Setenv("BEADS_DOLT_SHARED_SERVER", "1")
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatal(err)
}
metadata := map[string]interface{}{
"database": "dolt",
"backend": "dolt",
"dolt_mode": "embedded",
}
data, _ := json.Marshal(metadata)
if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), data, 0644); err != nil {
t.Fatal(err)
}
dbDir := filepath.Join(beadsDir, "embeddeddolt", "beads", ".dolt")
if err := os.MkdirAll(dbDir, 0755); err != nil {
t.Fatal(err)
}
err := checkExistingBeadsDataAt(beadsDir, "test")
if err == nil {
t.Error("existing embedded database should still block init when shared server mode is enabled elsewhere")
}
if err != nil && !strings.Contains(err.Error(), "already initialized") {
t.Errorf("expected 'already initialized' message, got: %v", err)
}
// GH#3684: must suggest --reinit-local, not deprecated --force
if err != nil && strings.Contains(err.Error(), "init --force") {
t.Errorf("message must NOT suggest deprecated --force, got:\n%s", err)
}
})
t.Run("no_metadata_json_allows_init", func(t *testing.T) {
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatal(err)
}
// No metadata.json, no dolt/ — fresh project, never initialized
err := checkExistingBeadsDataAt(beadsDir, "test")
if err != nil {
t.Errorf("empty beads dir should allow init, got: %v", err)
}
})
}
// GH#2363: Regression — AI agent followed "bd init --force" suggestion and wiped DB.
// Ensure the message never suggests --force as an actionable command.
func TestInitGuardServerMessage_NoForceAsAction(t *testing.T) {
err := initGuardServerMessage("test_beads", "127.0.0.1", 3307, "test", "")
msg := err.Error()
// The message should mention --force only in the caution/warning section,
// never as a suggested command to run.
if strings.Contains(msg, "bd init --force --prefix") {
t.Errorf("message must NOT suggest 'bd init --force --prefix' as an action:\n%s", msg)
}
if strings.Contains(msg, "bd init --force to") {
t.Errorf("message must NOT suggest 'bd init --force to ...' as an action:\n%s", msg)
}
}
// GH#3684: Regression — init "already initialized" messages must suggest
// --reinit-local (not the deprecated --force) for the reinit path.
func TestCheckExistingBeadsData_SuggestsReinitLocal(t *testing.T) {
t.Run("embedded_dolt", func(t *testing.T) {
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
// Write metadata.json with embedded dolt mode
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatal(err)
}
metadata := map[string]interface{}{
"database": "dolt", "backend": "dolt", "dolt_mode": "embedded",
}
data, _ := json.Marshal(metadata)
if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), data, 0644); err != nil {
t.Fatal(err)
}
// Create embeddeddolt/<db>/.dolt/ to simulate existing DB
if err := os.MkdirAll(filepath.Join(beadsDir, "embeddeddolt", "beads", ".dolt"), 0755); err != nil {
t.Fatal(err)
}
err := checkExistingBeadsDataAt(beadsDir, "test")
if err == nil {
t.Fatal("expected error for existing database")
}
msg := err.Error()
if !strings.Contains(msg, "--reinit-local") {
t.Errorf("message must suggest --reinit-local, got:\n%s", msg)
}
if strings.Contains(msg, "init --force") {
t.Errorf("message must NOT suggest deprecated --force, got:\n%s", msg)
}
})
t.Run("sqlite_db_file", func(t *testing.T) {
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0755); err != nil {
t.Fatal(err)
}
// Create a fake beads.db file (no metadata.json → falls through to SQLite check)
if err := os.WriteFile(filepath.Join(beadsDir, "beads.db"), []byte("fake"), 0644); err != nil {
t.Fatal(err)
}
err := checkExistingBeadsDataAt(beadsDir, "test")
if err == nil {
t.Fatal("expected error for existing database file")
}
msg := err.Error()
if !strings.Contains(msg, "--reinit-local") {
t.Errorf("message must suggest --reinit-local, got:\n%s", msg)
}
if strings.Contains(msg, "init --force") {
t.Errorf("message must NOT suggest deprecated --force, got:\n%s", msg)
}
})
}
// GH#2338, GH#2327: Regression — error messages must always include enough
// context to identify the active target (host, port, DB name).
func TestInitGuardServerMessage_IncludesTargetIdentity(t *testing.T) {
err := initGuardServerMessage("custom_db", "10.0.0.5", 3309, "custom", "")
msg := err.Error()
for _, want := range []string{"custom_db", "10.0.0.5", "3309"} {
if !strings.Contains(msg, want) {
t.Errorf("message must include target identity %q, got:\n%s", want, msg)
}
}
}
// GH#1111: Regression — safe recovery paths must be suggested before destructive ones.
// Verify that diagnostic commands appear before any mention of --force.
func TestInitGuardServerMessage_DiagnosticsBeforeForce(t *testing.T) {
err := initGuardServerMessage("test_beads", "127.0.0.1", 3307, "test", "")
msg := err.Error()
doctorIdx := strings.Index(msg, "bd doctor")
forceIdx := strings.Index(msg, "--force")
if doctorIdx == -1 {
t.Fatal("message must contain 'bd doctor'")
}
if forceIdx == -1 {
t.Fatal("message must contain '--force' (in caution section)")
}
if doctorIdx > forceIdx {
t.Errorf("'bd doctor' (at %d) must appear before '--force' (at %d) in message:\n%s",
doctorIdx, forceIdx, msg)
}
}