beads/cmd/bd/init_test.go
Kevin Glynn d585928bb3
feat(init): add --init-if-missing for idempotent init (#3490) (#4332)
* feat(init): add --init-if-missing for idempotent init (#3490)

bd init aborts with exit 1 when the workspace is already initialized,
forcing scaffold scripts to pre-stat .beads/embeddeddolt/<prefix> to tell
"already initialized" (benign) apart from real errors. Add an opt-in
--init-if-missing flag: when the workspace already exists, init prints a
benign "Skipping init: workspace already initialized." to stderr and exits 0.
Default behavior (flag absent) is unchanged - exit 1 with the existing
"already initialized ... Aborting" message.

The flag is intercepted only at the existing checkExistingBeadsData guard
call site; detection logic and the --force/--reinit-local paths are untouched.

Docs regenerated via scripts/generate-cli-docs.sh and generate-llms-full.sh.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(init): abort --init-if-missing on explicit prefix mismatch

--init-if-missing silently skipped whenever a workspace already existed,
even if the caller passed an explicit --prefix that differed from the
existing workspace. That masked a real mismatch: `bd init --prefix bar
--init-if-missing` against an existing `foo` workspace exited 0 and
ignored the requested prefix.

Now, when --prefix is set explicitly (and --database is not), compare the
requested prefix against the existing workspace's recorded DoltDatabase
and abort on a genuine mismatch; matching or undeterminable cases still
skip benignly. Extracts the prefix->dbName normalization into shared
helpers so the guard derives exactly the same name init records, and
factors the decision into a pure, unit-tested helper.

Refs #3490

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(init): don't mask operational errors or --database mismatch under --init-if-missing

Two idempotent-init correctness fixes on top of #4332 (reviewer Bernoulli):

1. checkExistingBeadsData now distinguishes the benign "already initialized"
   outcome (errWorkspaceAlreadyInitialized, carried by a workspaceExistsError
   that keeps the user-facing message) from operational errors such as an
   unreadable .beads/embeddeddolt directory. --init-if-missing skips only the
   benign case; an operational error still aborts instead of being masked as a
   successful idempotent skip.

2. An explicit --database mismatch now aborts --init-if-missing, mirroring the
   existing --prefix guard. --database is the authoritative database selector,
   so it is checked even when --prefix is also set.

Tests: initIfMissingDatabaseMismatch table; checkExistingBeadsDataAt returns a
sentinel-matching error for an existing database and a non-matching
(operational) error when embeddeddolt is unreadable.

Agent-Signature: claude-opus-4-8-high on behalf of maphew

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: matt wilkie <maphew@gmail.com>
2026-06-18 09:51:27 -07:00

2535 lines
77 KiB
Go

//go:build cgo
package main
import (
"bytes"
"context"
"errors"
"fmt"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"testing"
"github.com/steveyegge/beads/internal/beads"
"github.com/steveyegge/beads/internal/configfile"
"github.com/steveyegge/beads/internal/git"
"github.com/steveyegge/beads/internal/storage/dolt"
"github.com/steveyegge/beads/internal/testutil"
)
// skipIfNoDolt skips the test when no Dolt server is available.
// Checks both binary availability and test server status.
func skipIfNoDolt(t *testing.T) {
t.Helper()
testutil.RequireDoltBinary(t)
if testDoltServerPort == 0 {
t.Skip("skipping: Dolt test server not running")
}
}
func TestInitCommand(t *testing.T) {
skipIfNoDolt(t)
tests := []struct {
name string
prefix string
quiet bool
wantOutputText string
wantNoOutput bool
}{
{
name: "init with default prefix",
prefix: "",
quiet: false,
wantOutputText: "bd initialized successfully",
},
{
name: "init with custom prefix",
prefix: "myproject",
quiet: false,
wantOutputText: "myproject-<hash>",
},
{
name: "init with quiet flag",
prefix: "test",
quiet: true,
wantNoOutput: true,
},
{
name: "init with prefix ending in hyphen",
prefix: "test-",
quiet: false,
wantOutputText: "test-<hash>",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Reset global state
origDBPath := dbPath
origStore := store
defer func() {
if store != nil && store != origStore {
store.Close()
}
store = origStore
dbPath = origDBPath
}()
dbPath = ""
store = nil
// Reset Cobra command state
rootCmd.SetArgs([]string{})
initCmd.Flags().Set("prefix", "")
initCmd.Flags().Set("quiet", "false")
tmpDir := t.TempDir()
t.Chdir(tmpDir)
// Capture output
var buf bytes.Buffer
oldStdout := os.Stdout
r, w, _ := os.Pipe()
os.Stdout = w
defer func() {
os.Stdout = oldStdout
}()
// Build command arguments
args := []string{"init"}
if tt.prefix != "" {
args = append(args, "--prefix", tt.prefix)
}
if tt.quiet {
args = append(args, "--quiet")
}
rootCmd.SetArgs(args)
// Run command
var err error
err = rootCmd.Execute()
// Restore stdout and read output
w.Close()
buf.ReadFrom(r)
os.Stdout = oldStdout
output := buf.String()
if err != nil {
t.Fatalf("init command failed: %v", err)
}
// Check output
if tt.wantNoOutput {
if output != "" {
t.Errorf("Expected no output with --quiet, got: %s", output)
}
} else if tt.wantOutputText != "" {
if !strings.Contains(output, tt.wantOutputText) {
t.Errorf("Expected output to contain %q, got: %s", tt.wantOutputText, output)
}
}
// Verify .beads directory was created
beadsDir := filepath.Join(tmpDir, ".beads")
if _, err := os.Stat(beadsDir); os.IsNotExist(err) {
t.Error(".beads directory was not created")
}
// Verify .gitignore was created with proper content
gitignorePath := filepath.Join(beadsDir, ".gitignore")
gitignoreContent, err := os.ReadFile(gitignorePath)
if err != nil {
t.Errorf(".gitignore file was not created: %v", err)
} else {
// Check for essential patterns
gitignoreStr := string(gitignoreContent)
expectedPatterns := []string{
"*.db",
"*.db?*",
"*.db-journal",
"*.db-wal",
"*.db-shm",
"bd.sock",
"dolt/",
}
for _, pattern := range expectedPatterns {
if !strings.Contains(gitignoreStr, pattern) {
t.Errorf(".gitignore missing expected pattern: %s", pattern)
}
}
}
// Verify Dolt database directory was created
doltPath := filepath.Join(beadsDir, "dolt")
if info, err := os.Stat(doltPath); os.IsNotExist(err) {
t.Errorf("Dolt database directory was not created at %s", doltPath)
} else if !info.IsDir() {
t.Errorf("Expected %s to be a directory", doltPath)
}
// Database content verification (prefix, metadata) is skipped here because
// embedded Dolt's Close() can timeout, leaving file locks held and preventing
// re-opening the DB in the same process. The init command's own internal logic
// verifies these writes succeed; prefix/metadata correctness is also covered
// by dedicated Dolt storage tests.
})
}
}
// Note: Error case testing is omitted because the init command calls os.Exit()
// on errors, which makes it difficult to test in a unit test context.
func TestInitAlreadyInitialized(t *testing.T) {
skipIfNoDolt(t)
// Reset global state
origDBPath := dbPath
defer func() { dbPath = origDBPath }()
dbPath = ""
tmpDir := t.TempDir()
t.Chdir(tmpDir)
// Initialize once
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("First init failed: %v", err)
}
// Initialize again with same prefix and --force flag (bd-emg: safety guard)
// Without --force, init should refuse when database already exists
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--quiet", "--force"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Second init with --force failed: %v", err)
}
// Verify database still works
dbPath := filepath.Join(tmpDir, ".beads", "dolt")
store, err := openExistingTestDB(t, dbPath)
if err != nil {
t.Fatalf("Failed to open database: %v", err)
}
defer store.Close()
ctx := context.Background()
prefix, err := store.GetConfig(ctx, "issue_prefix")
if err != nil {
t.Fatalf("Failed to get prefix after re-init: %v", err)
}
if prefix != "test" {
t.Errorf("Expected prefix 'test', got %q", prefix)
}
}
// GH#3490: `bd init --init-if-missing` makes init idempotent for scaffold
// scripts. When the workspace is already initialized, init must skip and
// return without error (exit 0), emitting a benign "Skipping init" message,
// instead of aborting via os.Exit(1). The default (no-flag) abort path calls
// os.Exit(1) and therefore cannot be exercised in-process (see the note above
// TestInitAlreadyInitialized); this test covers the new success path.
func TestInitIfMissing(t *testing.T) {
skipIfNoDolt(t)
// Reset global state
origDBPath := dbPath
// Cobra flag values persist across Execute() calls on the shared command
// tree (a sibling test may have left --force set, and our own first init
// sets --quiet). Normalize the flags this test depends on before each run,
// and restore defaults afterward so we neither inherit nor leak state.
resetInitFlags := func() {
_ = initCmd.Flags().Set("force", "false")
_ = initCmd.Flags().Set("reinit-local", "false")
_ = initCmd.Flags().Set("init-if-missing", "false")
_ = initCmd.Flags().Set("quiet", "false")
_ = initCmd.Flags().Set("prefix", "")
}
defer func() {
dbPath = origDBPath
resetInitFlags()
}()
dbPath = ""
resetInitFlags()
tmpDir := t.TempDir()
t.Chdir(tmpDir)
// First init creates the workspace.
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("First init failed: %v", err)
}
// Re-running with --init-if-missing must be a benign no-op that exits 0:
// Execute() returns nil rather than the process aborting via os.Exit(1).
// Clear --quiet (set by the first run) so the skip message is emitted, and
// ensure no stale --force bypasses the already-initialized guard.
resetInitFlags()
oldStderr := os.Stderr
r, w, _ := os.Pipe()
os.Stderr = w
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--init-if-missing"})
execErr := rootCmd.Execute()
w.Close()
os.Stderr = oldStderr
var buf bytes.Buffer
buf.ReadFrom(r)
stderr := buf.String()
if execErr != nil {
t.Fatalf("init --init-if-missing on an initialized workspace should succeed, got: %v", execErr)
}
if !strings.Contains(stderr, "Skipping init: workspace already initialized") {
t.Errorf("expected a 'Skipping init: workspace already initialized' message on stderr, got:\n%s", stderr)
}
// The skip is a no-op: the existing workspace must remain in place (init
// returned before touching any data). We assert on the .beads directory
// rather than a specific backend layout so the test holds for both the
// embedded and server test modes.
beadsDir := filepath.Join(tmpDir, ".beads")
if info, err := os.Stat(beadsDir); err != nil || !info.IsDir() {
t.Fatalf("expected existing .beads workspace to remain at %s, stat err: %v", beadsDir, err)
}
}
// TestInitIfMissingPrefixMismatch covers the guard that keeps --init-if-missing
// from masking a genuine prefix mismatch (review follow-up on #4332/#3490): a
// re-init that explicitly requests a different prefix than the existing
// workspace must abort, while a matching prefix (after normalization) or an
// undeterminable existing name must fall through to the benign skip.
func TestInitIfMissingPrefixMismatch(t *testing.T) {
tests := []struct {
name string
existing string
requested string
want bool
}{
{name: "exact match", existing: "foo", requested: "foo", want: false},
{name: "case-insensitive match", existing: "Foo", requested: "foo", want: false},
{name: "hyphen normalizes to underscore", existing: "my_proj", requested: "my-proj", want: false},
{name: "trailing hyphen trimmed", existing: "foo", requested: "foo-", want: false},
{name: "leading-digit gets bd_ prefix", existing: "bd_001", requested: "001", want: false},
{name: "genuine mismatch aborts", existing: "foo", requested: "bar", want: true},
{name: "unknown existing falls through", existing: "", requested: "bar", want: false},
{name: "empty requested falls through", existing: "foo", requested: "", want: false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := initIfMissingPrefixMismatch(tt.existing, tt.requested); got != tt.want {
t.Errorf("initIfMissingPrefixMismatch(%q, %q) = %v, want %v",
tt.existing, tt.requested, got, tt.want)
}
})
}
}
// TestInitIfMissingMatchingPrefixSkips verifies the mismatch guard does not
// regress the happy path: re-running with the SAME explicit --prefix as the
// existing workspace still skips cleanly (exit 0) rather than aborting.
func TestInitIfMissingMatchingPrefixSkips(t *testing.T) {
skipIfNoDolt(t)
origDBPath := dbPath
resetInitFlags := func() {
_ = initCmd.Flags().Set("force", "false")
_ = initCmd.Flags().Set("reinit-local", "false")
_ = initCmd.Flags().Set("init-if-missing", "false")
_ = initCmd.Flags().Set("quiet", "false")
_ = initCmd.Flags().Set("prefix", "")
}
defer func() {
dbPath = origDBPath
resetInitFlags()
}()
dbPath = ""
resetInitFlags()
tmpDir := t.TempDir()
t.Chdir(tmpDir)
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("First init failed: %v", err)
}
resetInitFlags()
oldStderr := os.Stderr
r, w, _ := os.Pipe()
os.Stderr = w
// Same prefix as the existing workspace: must skip, not abort.
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--init-if-missing"})
execErr := rootCmd.Execute()
w.Close()
os.Stderr = oldStderr
var buf bytes.Buffer
buf.ReadFrom(r)
stderr := buf.String()
if execErr != nil {
t.Fatalf("init --init-if-missing with matching prefix should succeed, got: %v", execErr)
}
if !strings.Contains(stderr, "Skipping init: workspace already initialized") {
t.Errorf("expected benign skip message, got:\n%s", stderr)
}
}
func TestInitIfMissingDatabaseMismatch(t *testing.T) {
tests := []struct {
name string
existing string
requested string
want bool
}{
{name: "exact match", existing: "foo", requested: "foo", want: false},
{name: "case-insensitive match", existing: "Foo", requested: "foo", want: false},
{name: "genuine mismatch aborts", existing: "foo", requested: "bar", want: true},
{name: "unknown existing falls through", existing: "", requested: "bar", want: false},
{name: "empty requested falls through", existing: "foo", requested: "", want: false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := initIfMissingDatabaseMismatch(tt.existing, tt.requested); got != tt.want {
t.Errorf("initIfMissingDatabaseMismatch(%q, %q) = %v, want %v",
tt.existing, tt.requested, got, tt.want)
}
})
}
}
// TestCheckExistingBeadsDataOperationalErrorNotMasked verifies the core of the
// --init-if-missing idempotency fix: only the benign "already initialized"
// outcome matches errWorkspaceAlreadyInitialized (and may be skipped), while an
// operational failure must NOT match it — otherwise --init-if-missing would mask
// a real error (e.g. an unreadable .beads/embeddeddolt) as a successful skip.
func TestCheckExistingBeadsDataOperationalErrorNotMasked(t *testing.T) {
saveEmbeddedConfig := func(t *testing.T, beadsDir string) {
t.Helper()
cfg := &configfile.Config{
Database: "dolt",
Backend: configfile.BackendDolt,
DoltMode: configfile.DoltModeEmbedded,
}
if err := cfg.Save(beadsDir); err != nil {
t.Fatalf("save config: %v", err)
}
}
t.Run("existing database matches sentinel", func(t *testing.T) {
beadsDir := t.TempDir()
saveEmbeddedConfig(t, beadsDir)
// A real embedded database lives at embeddeddolt/<db>/.dolt.
if err := os.MkdirAll(filepath.Join(beadsDir, "embeddeddolt", "mydb", ".dolt"), 0o750); err != nil {
t.Fatal(err)
}
err := checkExistingBeadsDataAt(beadsDir, "mydb")
if err == nil {
t.Fatal("expected already-initialized error, got nil")
}
if !errors.Is(err, errWorkspaceAlreadyInitialized) {
t.Errorf("existing-database error must match errWorkspaceAlreadyInitialized, got: %v", err)
}
})
t.Run("operational error not masked", func(t *testing.T) {
beadsDir := t.TempDir()
saveEmbeddedConfig(t, beadsDir)
// Make embeddeddolt a regular file so os.ReadDir fails with a
// non-IsNotExist (operational) error rather than "already initialized".
if err := os.WriteFile(filepath.Join(beadsDir, "embeddeddolt"), []byte("not a dir"), 0o600); err != nil {
t.Fatal(err)
}
err := checkExistingBeadsDataAt(beadsDir, "mydb")
if err == nil {
t.Fatal("expected operational error, got nil")
}
if errors.Is(err, errWorkspaceAlreadyInitialized) {
t.Errorf("operational error must NOT match errWorkspaceAlreadyInitialized (would be masked by --init-if-missing): %v", err)
}
})
}
func TestInitWithCustomDBPath(t *testing.T) {
t.Skip("BEADS_DB env var does not control Dolt store location; Dolt always uses .beads/dolt/")
// Save original state
origDBPath := dbPath
defer func() { dbPath = origDBPath }()
tmpDir := t.TempDir()
customDBDir := filepath.Join(tmpDir, "custom", "location")
// Change to a different directory to ensure --db flag is actually used
workDir := filepath.Join(tmpDir, "workdir")
if err := os.MkdirAll(workDir, 0750); err != nil {
t.Fatalf("Failed to create work directory: %v", err)
}
t.Chdir(workDir)
customDBPath := filepath.Join(customDBDir, "test.db")
// Test with BEADS_DB environment variable (replacing --db flag test)
t.Run("init with BEADS_DB pointing to custom path", func(t *testing.T) {
dbPath = "" // Reset global
os.Setenv("BEADS_DB", customDBPath)
defer os.Unsetenv("BEADS_DB")
rootCmd.SetArgs([]string{"init", "--prefix", "custom", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Init with BEADS_DB failed: %v", err)
}
// Verify database was created at custom location
if _, err := os.Stat(customDBPath); os.IsNotExist(err) {
t.Errorf("Database was not created at custom path %s", customDBPath)
}
// Verify database works
store, err := openExistingTestDB(t, customDBPath)
if err != nil {
t.Fatalf("Failed to open database: %v", err)
}
defer store.Close()
ctx := context.Background()
prefix, err := store.GetConfig(ctx, "issue_prefix")
if err != nil {
t.Fatalf("Failed to get prefix: %v", err)
}
if prefix != "custom" {
t.Errorf("Expected prefix 'custom', got %q", prefix)
}
// Verify .beads/ directory was NOT created in work directory
if _, err := os.Stat(filepath.Join(workDir, ".beads")); err == nil {
t.Error(".beads/ directory should not be created when using BEADS_DB env var")
}
})
// Test with BEADS_DB env var
t.Run("init with BEADS_DB env var", func(t *testing.T) {
dbPath = "" // Reset global
envDBPath := filepath.Join(tmpDir, "env", "location", "env.db")
os.Setenv("BEADS_DB", envDBPath)
defer os.Unsetenv("BEADS_DB")
rootCmd.SetArgs([]string{"init", "--prefix", "envtest", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Init with BEADS_DB failed: %v", err)
}
// Verify database was created at env location
if _, err := os.Stat(envDBPath); os.IsNotExist(err) {
t.Errorf("Database was not created at BEADS_DB path %s", envDBPath)
}
// Verify database works
store, err := openExistingTestDB(t, envDBPath)
if err != nil {
t.Fatalf("Failed to open database: %v", err)
}
defer store.Close()
ctx := context.Background()
prefix, err := store.GetConfig(ctx, "issue_prefix")
if err != nil {
t.Fatalf("Failed to get prefix: %v", err)
}
if prefix != "envtest" {
t.Errorf("Expected prefix 'envtest', got %q", prefix)
}
})
// Test that BEADS_DB path containing ".beads" doesn't create CWD/.beads
t.Run("init with BEADS_DB path containing .beads", func(t *testing.T) {
dbPath = "" // Reset global
// Path contains ".beads" but is outside work directory
customPath := filepath.Join(tmpDir, "storage", ".beads-backup", "test.db")
os.Setenv("BEADS_DB", customPath)
defer os.Unsetenv("BEADS_DB")
rootCmd.SetArgs([]string{"init", "--prefix", "beadstest", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Init with custom .beads path failed: %v", err)
}
// Verify database was created at custom location
if _, err := os.Stat(customPath); os.IsNotExist(err) {
t.Errorf("Database was not created at custom path %s", customPath)
}
// Verify .beads/ directory was NOT created in work directory
if _, err := os.Stat(filepath.Join(workDir, ".beads")); err == nil {
t.Error(".beads/ directory should not be created in CWD when BEADS_DB path contains .beads")
}
})
// Test with multiple BEADS_DB variations
t.Run("BEADS_DB with subdirectories", func(t *testing.T) {
dbPath = "" // Reset global
envPath := filepath.Join(tmpDir, "env", "subdirs", "test.db")
os.Setenv("BEADS_DB", envPath)
defer os.Unsetenv("BEADS_DB")
rootCmd.SetArgs([]string{"init", "--prefix", "envtest2", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Init with BEADS_DB subdirs failed: %v", err)
}
// Verify database was created at env location
if _, err := os.Stat(envPath); os.IsNotExist(err) {
t.Errorf("Database was not created at BEADS_DB path %s", envPath)
}
// Verify .beads/ directory was NOT created in work directory
if _, err := os.Stat(filepath.Join(workDir, ".beads")); err == nil {
t.Error(".beads/ directory should not be created in CWD when BEADS_DB is set")
}
})
}
// TestSetupClaudeSettings_InvalidJSON verifies that invalid JSON in existing
// settings.local.json returns an error instead of silently overwriting.
// This is a regression test for bd-5bj where user settings were lost.
func TestSetupClaudeSettings_InvalidJSON(t *testing.T) {
tmpDir := t.TempDir()
t.Chdir(tmpDir)
// Create .claude directory
claudeDir := filepath.Join(tmpDir, ".claude")
if err := os.MkdirAll(claudeDir, 0755); err != nil {
t.Fatalf("Failed to create .claude directory: %v", err)
}
// Create settings.local.json with invalid JSON (array syntax in object context)
// This is the exact pattern that caused the bug in the user's file
invalidJSON := `{
"permissions": {
"allow": [
"Bash(python3:*)"
],
"deny": [
"_comment": "Add commands to block here"
]
}
}`
settingsPath := filepath.Join(claudeDir, "settings.local.json")
if err := os.WriteFile(settingsPath, []byte(invalidJSON), 0644); err != nil {
t.Fatalf("Failed to write invalid settings: %v", err)
}
// Call setupClaudeSettings - should return an error
var err error
err = setupClaudeSettings(false)
if err == nil {
t.Fatal("Expected error for invalid JSON, got nil")
}
// Verify the error message mentions invalid JSON
if !strings.Contains(err.Error(), "invalid JSON") {
t.Errorf("Expected error to mention 'invalid JSON', got: %v", err)
}
// Verify the original file was NOT modified
content, err := os.ReadFile(settingsPath)
if err != nil {
t.Fatalf("Failed to read settings file: %v", err)
}
if !strings.Contains(string(content), "permissions") {
t.Error("Original file content should be preserved")
}
if strings.Contains(string(content), "bd prime") {
t.Error("File should NOT contain bd prime prompt after error")
}
}
// TestSetupClaudeSettings_ValidJSON verifies that valid JSON is properly updated
func TestSetupClaudeSettings_ValidJSON(t *testing.T) {
tmpDir := t.TempDir()
t.Chdir(tmpDir)
// Create .claude directory
claudeDir := filepath.Join(tmpDir, ".claude")
if err := os.MkdirAll(claudeDir, 0755); err != nil {
t.Fatalf("Failed to create .claude directory: %v", err)
}
// Create settings.local.json with valid JSON
validJSON := `{
"permissions": {
"allow": [
"Bash(python3:*)"
]
},
"hooks": {
"PreToolUse": []
}
}`
settingsPath := filepath.Join(claudeDir, "settings.local.json")
if err := os.WriteFile(settingsPath, []byte(validJSON), 0644); err != nil {
t.Fatalf("Failed to write valid settings: %v", err)
}
// Call setupClaudeSettings - should succeed
var err error
err = setupClaudeSettings(false)
if err != nil {
t.Fatalf("Expected no error for valid JSON, got: %v", err)
}
// Verify the file was updated with prompt AND preserved existing settings
content, err := os.ReadFile(settingsPath)
if err != nil {
t.Fatalf("Failed to read settings file: %v", err)
}
contentStr := string(content)
// Should contain the new prompt
if !strings.Contains(contentStr, "bd prime") {
t.Error("File should contain bd prime prompt")
}
// Should preserve existing permissions
if !strings.Contains(contentStr, "permissions") {
t.Error("File should preserve permissions section")
}
// Should preserve existing hooks
if !strings.Contains(contentStr, "hooks") {
t.Error("File should preserve hooks section")
}
if !strings.Contains(contentStr, "PreToolUse") {
t.Error("File should preserve PreToolUse hook")
}
}
// TestSetupClaudeSettings_NoExistingFile verifies behavior when no file exists
func TestSetupClaudeSettings_NoExistingFile(t *testing.T) {
tmpDir := t.TempDir()
t.Chdir(tmpDir)
// Don't create .claude directory - setupClaudeSettings should create it
// Call setupClaudeSettings - should succeed
var err error
err = setupClaudeSettings(false)
if err != nil {
t.Fatalf("Expected no error when no file exists, got: %v", err)
}
// Verify the file was created with prompt
settingsPath := filepath.Join(tmpDir, ".claude", "settings.local.json")
content, err := os.ReadFile(settingsPath)
if err != nil {
t.Fatalf("Failed to read settings file: %v", err)
}
if !strings.Contains(string(content), "bd prime") {
t.Error("File should contain bd prime prompt")
}
}
// setupIsolatedGitConfig creates an empty git config in tmpDir and sets GIT_CONFIG_GLOBAL
// to prevent tests from using the real user's global git config.
func setupIsolatedGitConfig(t *testing.T, tmpDir string) {
t.Helper()
gitConfigPath := filepath.Join(tmpDir, ".gitconfig")
if err := os.WriteFile(gitConfigPath, []byte(""), 0644); err != nil {
t.Fatal(err)
}
t.Setenv("GIT_CONFIG_GLOBAL", gitConfigPath)
}
// TestSetupGlobalGitIgnore_ReadOnly verifies graceful handling when the
// gitignore file cannot be written (prints manual instructions instead of failing).
func TestSetupGlobalGitIgnore_ReadOnly(t *testing.T) {
t.Run("read-only file", func(t *testing.T) {
if runtime.GOOS == "darwin" {
t.Skip("macOS allows file owner to write to read-only (0444) files")
}
tmpDir := t.TempDir()
setupIsolatedGitConfig(t, tmpDir)
configDir := filepath.Join(tmpDir, ".config", "git")
if err := os.MkdirAll(configDir, 0755); err != nil {
t.Fatal(err)
}
ignorePath := filepath.Join(configDir, "ignore")
if err := os.WriteFile(ignorePath, []byte("# existing\n"), 0644); err != nil {
t.Fatal(err)
}
if err := os.Chmod(ignorePath, 0444); err != nil {
t.Fatal(err)
}
defer os.Chmod(ignorePath, 0644)
output := captureStdout(t, func() error {
return setupGlobalGitIgnore(tmpDir, "/test/project", false)
})
if !strings.Contains(output, "Unable to write") {
t.Error("expected instructions for manual addition")
}
if !strings.Contains(output, "/test/project/.beads/") {
t.Error("expected .beads pattern in output")
}
})
t.Run("symlink to read-only file", func(t *testing.T) {
if runtime.GOOS == "darwin" {
t.Skip("macOS allows file owner to write to read-only (0444) files")
}
tmpDir := t.TempDir()
setupIsolatedGitConfig(t, tmpDir)
// Target file in a separate location
targetDir := filepath.Join(tmpDir, "target")
if err := os.MkdirAll(targetDir, 0755); err != nil {
t.Fatal(err)
}
targetFile := filepath.Join(targetDir, "ignore")
if err := os.WriteFile(targetFile, []byte("# existing\n"), 0644); err != nil {
t.Fatal(err)
}
if err := os.Chmod(targetFile, 0444); err != nil {
t.Fatal(err)
}
defer os.Chmod(targetFile, 0644)
// Symlink from expected location
configDir := filepath.Join(tmpDir, ".config", "git")
if err := os.MkdirAll(configDir, 0755); err != nil {
t.Fatal(err)
}
if err := os.Symlink(targetFile, filepath.Join(configDir, "ignore")); err != nil {
t.Fatal(err)
}
output := captureStdout(t, func() error {
return setupGlobalGitIgnore(tmpDir, "/test/project", false)
})
if !strings.Contains(output, "Unable to write") {
t.Error("expected instructions for manual addition")
}
if !strings.Contains(output, "/test/project/.beads/") {
t.Error("expected .beads pattern in output")
}
})
}
// TestInitPromptRoleConfig tests the beads.role git config read/write functions
func TestInitPromptRoleConfig(t *testing.T) {
t.Run("getBeadsRole returns empty when not configured", func(t *testing.T) {
tmpDir := newGitRepo(t)
t.Chdir(tmpDir)
role, hasRole := getBeadsRole()
if hasRole {
t.Errorf("Expected hasRole=false when not configured, got true with role=%q", role)
}
if role != "" {
t.Errorf("Expected empty role when not configured, got %q", role)
}
})
t.Run("setBeadsRole and getBeadsRole roundtrip", func(t *testing.T) {
tmpDir := newGitRepo(t)
t.Chdir(tmpDir)
// Set role to contributor
if err := setBeadsRole("contributor"); err != nil {
t.Fatalf("Failed to set beads.role: %v", err)
}
role, hasRole := getBeadsRole()
if !hasRole {
t.Error("Expected hasRole=true after setting role")
}
if role != "contributor" {
t.Errorf("Expected role 'contributor', got %q", role)
}
// Change to maintainer
if err := setBeadsRole("maintainer"); err != nil {
t.Fatalf("Failed to set beads.role: %v", err)
}
role, hasRole = getBeadsRole()
if !hasRole {
t.Error("Expected hasRole=true after setting role")
}
if role != "maintainer" {
t.Errorf("Expected role 'maintainer', got %q", role)
}
})
}
// TestInitPromptSkippedWithFlags verifies that --contributor and --team flags skip the prompt
func TestInitPromptSkippedWithFlags(t *testing.T) {
skipIfNoDolt(t)
t.Run("contributor flag skips prompt and runs wizard", func(t *testing.T) {
// Reset global state
origDBPath := dbPath
defer func() { dbPath = origDBPath }()
dbPath = ""
// Reset caches so RepoContext picks up new directory
beads.ResetCaches()
git.ResetCaches()
defer func() {
beads.ResetCaches()
git.ResetCaches()
}()
// Reset Cobra flags
initCmd.Flags().Set("contributor", "false")
tmpDir := newGitRepo(t)
t.Chdir(tmpDir)
// Verify no role is set initially
role, hasRole := getBeadsRole()
if hasRole {
t.Fatalf("Expected no role initially, got %q", role)
}
// Run bd init with --contributor flag (quiet to suppress wizard output)
// The wizard will fail because there's no planning repo, but that's OK
// We just want to verify the flag bypasses the prompt
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--contributor", "--quiet"})
_ = rootCmd.Execute() // Ignore error - wizard may fail
// The --contributor flag should NOT set beads.role (that's done by prompt, not flag)
// The flag just triggers the wizard directly
})
t.Run("team flag skips prompt", func(t *testing.T) {
// Reset global state
origDBPath := dbPath
defer func() { dbPath = origDBPath }()
dbPath = ""
// Reset caches so RepoContext picks up new directory
beads.ResetCaches()
git.ResetCaches()
defer func() {
beads.ResetCaches()
git.ResetCaches()
}()
// Reset Cobra flags
initCmd.Flags().Set("team", "false")
tmpDir := newGitRepo(t)
t.Chdir(tmpDir)
// Verify no role is set initially
role, hasRole := getBeadsRole()
if hasRole {
t.Fatalf("Expected no role initially, got %q", role)
}
// Run bd init with --team flag
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--team", "--quiet"})
_ = rootCmd.Execute() // Ignore error - wizard may fail
// The --team flag should not set beads.role
// (team wizard is separate from contributor/maintainer roles)
})
}
// TestInitPromptTTYDetection verifies shouldPromptForRole behavior
func TestInitPromptTTYDetection(t *testing.T) {
// Note: In test environment, stdin is typically NOT a TTY (it's a pipe)
// This test verifies the function works, not that we're in a TTY
t.Run("shouldPromptForRole returns false in test environment", func(t *testing.T) {
// In test environment, stdin is typically piped, not a TTY
result := shouldPromptForRole()
// We can't guarantee what the result will be in all test environments,
// but we can verify the function doesn't panic and returns a bool
if result {
t.Log("Test environment has TTY stdin (unusual but acceptable)")
} else {
t.Log("Test environment does not have TTY stdin (expected)")
}
})
}
// TestInitPromptNonGitRepo verifies prompt is skipped in non-git directories
func TestInitPromptNonGitRepo(t *testing.T) {
skipIfNoDolt(t)
// Reset global state
origDBPath := dbPath
defer func() { dbPath = origDBPath }()
dbPath = ""
// Reset caches so RepoContext picks up new directory
beads.ResetCaches()
git.ResetCaches()
defer func() {
beads.ResetCaches()
git.ResetCaches()
}()
// Reset Cobra flags that may be set from previous tests
initCmd.Flags().Set("contributor", "false")
initCmd.Flags().Set("team", "false")
tmpDir := t.TempDir()
t.Chdir(tmpDir)
// DON'T initialize git repo
// Run bd init - should succeed without prompting (no git repo)
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Init should succeed in non-git directory: %v", err)
}
// Verify .beads was created
beadsDir := filepath.Join(tmpDir, ".beads")
if _, err := os.Stat(beadsDir); os.IsNotExist(err) {
t.Error(".beads directory should be created even without git")
}
}
// TestInitPromptExistingRole verifies behavior when beads.role is already set
func TestInitPromptExistingRole(t *testing.T) {
skipIfNoDolt(t)
t.Run("existing role is preserved on reinit with --force", func(t *testing.T) {
// Reset global state
origDBPath := dbPath
defer func() { dbPath = origDBPath }()
dbPath = ""
// Reset caches so RepoContext picks up new directory
beads.ResetCaches()
git.ResetCaches()
defer func() {
beads.ResetCaches()
git.ResetCaches()
}()
// Reset Cobra flags that may be set from previous tests
initCmd.Flags().Set("contributor", "false")
initCmd.Flags().Set("team", "false")
initCmd.Flags().Set("force", "false")
tmpDir := newGitRepo(t)
t.Chdir(tmpDir)
// Set role before init
if err := setBeadsRole("contributor"); err != nil {
t.Fatalf("Failed to set beads.role: %v", err)
}
// Run bd init (non-interactive, so prompt is skipped)
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Init failed: %v", err)
}
// Verify role is still set
role, hasRole := getBeadsRole()
if !hasRole {
t.Error("Expected beads.role to still be set after init")
}
if role != "contributor" {
t.Errorf("Expected role 'contributor' to be preserved, got %q", role)
}
// Reset Cobra flags for reinit
initCmd.Flags().Set("force", "false")
// Reinit with --force (non-interactive)
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--quiet", "--force"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Reinit failed: %v", err)
}
// Verify role is still set (not cleared by reinit)
role, hasRole = getBeadsRole()
if !hasRole {
t.Error("Expected beads.role to still be set after reinit")
}
if role != "contributor" {
t.Errorf("Expected role 'contributor' to be preserved after reinit, got %q", role)
}
})
}
func TestInitContributorSetsBeadsRoleContributor(t *testing.T) {
skipIfNoDolt(t)
origDBPath := dbPath
defer func() { dbPath = origDBPath }()
dbPath = ""
beads.ResetCaches()
git.ResetCaches()
defer func() {
beads.ResetCaches()
git.ResetCaches()
}()
initCmd.Flags().Set("contributor", "false")
initCmd.Flags().Set("team", "false")
initCmd.Flags().Set("force", "false")
tmpDir := newGitRepo(t)
t.Chdir(tmpDir)
// Keep test isolated from the real home/planning repo.
testHome := t.TempDir()
t.Setenv("HOME", testHome)
// Configure remotes so contributor wizard doesn't ask the "continue anyway" prompt.
cmd := exec.Command("git", "remote", "add", "origin", "git@github.com:osamu2001/zmx.git")
cmd.Dir = tmpDir
if err := cmd.Run(); err != nil {
t.Fatalf("failed to add origin remote: %v", err)
}
cmd = exec.Command("git", "remote", "add", "upstream", "git@github.com:neurosnap/zmx.git")
cmd.Dir = tmpDir
if err := cmd.Run(); err != nil {
t.Fatalf("failed to add upstream remote: %v", err)
}
// Wizard answers:
// 1) "Do you want to use a separate planning repo anyway? [Y/n]" -> Enter (default yes)
// 2) "Planning repo path [press Enter for default]" -> Enter (default ~/.beads-planning)
r, w, err := os.Pipe()
if err != nil {
t.Fatalf("failed to create stdin pipe: %v", err)
}
oldStdin := os.Stdin
os.Stdin = r
t.Cleanup(func() { os.Stdin = oldStdin })
t.Cleanup(func() { _ = r.Close() })
_, _ = w.WriteString("\n\n")
_ = w.Close()
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--contributor", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("init --contributor failed: %v", err)
}
role, hasRole := getBeadsRole()
if !hasRole {
t.Fatal("expected beads.role to be configured")
}
if role != "contributor" {
t.Fatalf("beads.role = %q, want %q", role, "contributor")
}
}
// TestInitNonInteractiveAlwaysSetsRole verifies that bd init --non-interactive
// always leaves beads.role set, even when no --role flag is provided (GH#2950).
// This is the safety net for the init flow.
func TestInitNonInteractiveAlwaysSetsRole(t *testing.T) {
skipIfNoDolt(t)
origDBPath := dbPath
defer func() { dbPath = origDBPath }()
dbPath = ""
beads.ResetCaches()
git.ResetCaches()
defer func() {
beads.ResetCaches()
git.ResetCaches()
}()
initCmd.Flags().Set("contributor", "false")
initCmd.Flags().Set("team", "false")
initCmd.Flags().Set("force", "false")
initCmd.Flags().Set("role", "")
tmpDir := newGitRepo(t)
t.Chdir(tmpDir)
// Ensure no role is set before init
exec.Command("git", "config", "--unset", "beads.role").Run() //nolint:errcheck
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--quiet", "--non-interactive"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("init --non-interactive failed: %v", err)
}
role, hasRole := getBeadsRole()
if !hasRole {
t.Fatal("expected beads.role to be configured after non-interactive init (GH#2950)")
}
if role != "maintainer" {
t.Fatalf("beads.role = %q, want %q (default for non-interactive)", role, "maintainer")
}
}
// TestInitWithRedirect verifies that bd init creates the database in the redirect target,
// not in the local .beads directory. (GH#bd-0qel)
// TestInitRedirect groups redirect-related init tests.
func TestInitRedirect(t *testing.T) {
skipIfNoDolt(t)
resetRedirectState := func(t *testing.T) {
t.Helper()
origDBPath := dbPath
origBeadsDir := os.Getenv("BEADS_DIR")
t.Cleanup(func() {
dbPath = origDBPath
if origBeadsDir != "" {
os.Setenv("BEADS_DIR", origBeadsDir)
} else {
os.Unsetenv("BEADS_DIR")
}
})
dbPath = ""
os.Unsetenv("BEADS_DIR")
initCmd.Flags().Set("prefix", "")
initCmd.Flags().Set("quiet", "false")
initCmd.Flags().Set("force", "false")
}
t.Run("RedirectCreatesDBInTarget", func(t *testing.T) {
resetRedirectState(t)
tmpDir := t.TempDir()
projectDir := filepath.Join(tmpDir, "project")
if err := os.MkdirAll(projectDir, 0755); err != nil {
t.Fatal(err)
}
localBeadsDir := filepath.Join(projectDir, ".beads")
if err := os.MkdirAll(localBeadsDir, 0755); err != nil {
t.Fatal(err)
}
targetBeadsDir := filepath.Join(tmpDir, "canonical", ".beads")
if err := os.MkdirAll(targetBeadsDir, 0755); err != nil {
t.Fatal(err)
}
redirectPath := filepath.Join(localBeadsDir, beads.RedirectFileName)
if err := os.WriteFile(redirectPath, []byte("../canonical/.beads\n"), 0644); err != nil {
t.Fatal(err)
}
t.Chdir(projectDir)
rootCmd.SetArgs([]string{"init", "--prefix", "redirect-test", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Init with redirect failed: %v", err)
}
targetDBPath := filepath.Join(targetBeadsDir, "dolt")
if _, err := os.Stat(targetDBPath); os.IsNotExist(err) {
t.Errorf("Dolt database was NOT created in redirect target: %s", targetDBPath)
}
localDBPath := filepath.Join(localBeadsDir, "dolt")
if _, err := os.Stat(localDBPath); err == nil {
t.Errorf("Database was incorrectly created in local .beads: %s (should be in redirect target)", localDBPath)
}
store, err := openExistingTestDB(t, targetDBPath)
if err != nil {
t.Fatalf("Failed to open database in redirect target: %v", err)
}
defer store.Close()
ctx := context.Background()
prefix, err := store.GetConfig(ctx, "issue_prefix")
if err != nil {
t.Fatalf("Failed to get issue prefix from database: %v", err)
}
if prefix != "redirect-test" {
t.Errorf("Expected prefix 'redirect-test', got %q", prefix)
}
})
// Verifies that bd init errors when the redirect target already has a database,
// preventing accidental overwrites. (GH#bd-0qel)
t.Run("ErrorWhenTargetHasExistingDB", func(t *testing.T) {
resetRedirectState(t)
tmpDir := t.TempDir()
canonicalDir := filepath.Join(tmpDir, "canonical")
canonicalBeadsDir := filepath.Join(canonicalDir, ".beads")
if err := os.MkdirAll(canonicalBeadsDir, 0755); err != nil {
t.Fatal(err)
}
canonicalDBPath := filepath.Join(canonicalBeadsDir, "beads.db")
// Create the db file so checkExistingBeadsData detects it
if err := os.WriteFile(canonicalDBPath, []byte{}, 0644); err != nil {
t.Fatalf("Failed to create canonical db file: %v", err)
}
projectDir := filepath.Join(tmpDir, "project")
projectBeadsDir := filepath.Join(projectDir, ".beads")
if err := os.MkdirAll(projectBeadsDir, 0755); err != nil {
t.Fatal(err)
}
redirectPath := filepath.Join(projectBeadsDir, beads.RedirectFileName)
if err := os.WriteFile(redirectPath, []byte("../canonical/.beads\n"), 0644); err != nil {
t.Fatal(err)
}
// Use os.Chdir since checkExistingBeadsData reads CWD directly
origWd, _ := os.Getwd()
if err := os.Chdir(projectDir); err != nil {
t.Fatal(err)
}
defer os.Chdir(origWd)
err := checkExistingBeadsData("new-prefix")
if err == nil {
t.Fatal("Expected checkExistingBeadsData to return error when redirect target already has database")
}
errorMsg := err.Error()
if !strings.Contains(errorMsg, "redirect target already has database") {
t.Errorf("Expected error about redirect target having database, got: %s", errorMsg)
}
// Verify the canonical DB file still exists (wasn't deleted/overwritten)
if _, statErr := os.Stat(canonicalDBPath); os.IsNotExist(statErr) {
t.Error("Canonical database file should still exist after error")
}
})
}
// =============================================================================
// BEADS_DIR Tests
// =============================================================================
// These tests verify that bd init respects the BEADS_DIR environment variable
// for both safety checks and database creation.
// TestInitBEADS_DIR groups BEADS_DIR-related init tests.
// Tests requirements FR-001, FR-002, FR-004, NFR-001.
func TestInitBEADS_DIR(t *testing.T) {
skipIfNoDolt(t)
// resetBeadsDirState resets global state and env vars for each subtest.
resetBeadsDirState := func(t *testing.T) {
t.Helper()
origDBPath := dbPath
t.Cleanup(func() {
dbPath = origDBPath
beads.ResetCaches()
git.ResetCaches()
})
dbPath = ""
beads.ResetCaches()
git.ResetCaches()
initCmd.Flags().Set("prefix", "")
initCmd.Flags().Set("quiet", "false")
initCmd.Flags().Set("backend", "")
}
// checkExistingBeadsData tests (FR-001, FR-004)
t.Run("CheckExisting_NoExistingDB", func(t *testing.T) {
resetBeadsDirState(t)
tmpDir := t.TempDir()
beadsDirPath := filepath.Join(tmpDir, "external", ".beads")
os.MkdirAll(beadsDirPath, 0755)
os.Setenv("BEADS_DIR", beadsDirPath)
t.Cleanup(func() { os.Unsetenv("BEADS_DIR") })
beads.ResetCaches()
err := checkExistingBeadsData("test")
if err != nil {
t.Errorf("Expected no error when BEADS_DIR has no database, got: %v", err)
}
})
t.Run("CheckExisting_CWDIgnoredWhenSet", func(t *testing.T) {
resetBeadsDirState(t)
tmpDir := t.TempDir()
// Create CWD with existing database (should be ignored)
cwdBeadsDir := filepath.Join(tmpDir, "cwd", ".beads")
os.MkdirAll(cwdBeadsDir, 0755)
cwdDBPath := filepath.Join(cwdBeadsDir, beads.CanonicalDatabaseName)
// Create the db file so checkExistingBeadsData detects it
if err := os.WriteFile(cwdDBPath, []byte{}, 0644); err != nil {
t.Fatal(err)
}
// Create BEADS_DIR location (no database)
beadsDirPath := filepath.Join(tmpDir, "external", ".beads")
os.MkdirAll(beadsDirPath, 0755)
os.Setenv("BEADS_DIR", beadsDirPath)
t.Cleanup(func() { os.Unsetenv("BEADS_DIR") })
beads.ResetCaches()
origWd, _ := os.Getwd()
os.Chdir(filepath.Join(tmpDir, "cwd"))
defer os.Chdir(origWd)
err := checkExistingBeadsData("test")
if err != nil {
t.Errorf("Expected no error when BEADS_DIR has no database (CWD should be ignored), got: %v", err)
}
})
t.Run("CheckExisting_ErrorWhenDBExists", func(t *testing.T) {
resetBeadsDirState(t)
tmpDir := t.TempDir()
beadsDirPath := filepath.Join(tmpDir, "external", ".beads")
os.MkdirAll(beadsDirPath, 0755)
testDBPath := filepath.Join(beadsDirPath, beads.CanonicalDatabaseName)
// Create the db file so checkExistingBeadsData detects it
if err := os.WriteFile(testDBPath, []byte{}, 0644); err != nil {
t.Fatal(err)
}
os.Setenv("BEADS_DIR", beadsDirPath)
t.Cleanup(func() { os.Unsetenv("BEADS_DIR") })
beads.ResetCaches()
err := checkExistingBeadsData("test")
if err == nil {
t.Error("Expected error when BEADS_DIR already has database")
}
if !strings.Contains(err.Error(), beadsDirPath) {
t.Errorf("Expected error to mention BEADS_DIR path %s, got: %v", beadsDirPath, err)
}
})
// FR-002: init creates database at BEADS_DIR
t.Run("InitCreatesDBAtBeadsDir", func(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("Skipping BEADS_DIR test on Windows")
}
resetBeadsDirState(t)
tmpDir := t.TempDir()
beadsDirPath := filepath.Join(tmpDir, "external", ".beads")
os.MkdirAll(filepath.Dir(beadsDirPath), 0755)
os.Setenv("BEADS_DIR", beadsDirPath)
t.Cleanup(func() { os.Unsetenv("BEADS_DIR") })
beads.ResetCaches()
git.ResetCaches()
cwdPath := filepath.Join(tmpDir, "workdir")
os.MkdirAll(cwdPath, 0755)
t.Chdir(cwdPath)
rootCmd.SetArgs([]string{"init", "--prefix", "beadsdir-test", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Init with BEADS_DIR failed: %v", err)
}
expectedDBPath := filepath.Join(beadsDirPath, "dolt")
if info, err := os.Stat(expectedDBPath); os.IsNotExist(err) {
t.Errorf("Dolt database was not created at BEADS_DIR path: %s", expectedDBPath)
} else if !info.IsDir() {
t.Errorf("Expected %s to be a directory", expectedDBPath)
}
cwdDBPath := filepath.Join(cwdPath, ".beads", "dolt")
if _, err := os.Stat(cwdDBPath); err == nil {
t.Errorf("Database should NOT have been created at CWD: %s", cwdDBPath)
}
store, err := openExistingTestDB(t, expectedDBPath)
if err != nil {
t.Fatalf("Failed to open database at BEADS_DIR: %v", err)
}
defer store.Close()
ctx := context.Background()
prefix, err := store.GetConfig(ctx, "issue_prefix")
if err != nil {
t.Fatalf("Failed to get prefix from database: %v", err)
}
if prefix != "beadsdir-test" {
t.Errorf("Expected prefix 'beadsdir-test', got %q", prefix)
}
})
// NFR-001: existing behavior unchanged when BEADS_DIR not set
t.Run("WithoutBeadsDirNoBehaviorChange", func(t *testing.T) {
resetBeadsDirState(t)
os.Unsetenv("BEADS_DIR")
beads.ResetCaches()
git.ResetCaches()
tmpDir := t.TempDir()
t.Chdir(tmpDir)
rootCmd.SetArgs([]string{"init", "--prefix", "no-beadsdir", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Init without BEADS_DIR failed: %v", err)
}
expectedDBPath := filepath.Join(tmpDir, ".beads", "dolt")
if info, err := os.Stat(expectedDBPath); os.IsNotExist(err) {
t.Errorf("Dolt database was not created at default CWD/.beads path: %s", expectedDBPath)
} else if !info.IsDir() {
t.Errorf("Expected %s to be a directory", expectedDBPath)
}
store, err := openExistingTestDB(t, expectedDBPath)
if err != nil {
t.Fatalf("Failed to open database: %v", err)
}
defer store.Close()
ctx := context.Background()
prefix, err := store.GetConfig(ctx, "issue_prefix")
if err != nil {
t.Fatalf("Failed to get prefix from database: %v", err)
}
if prefix != "no-beadsdir" {
t.Errorf("Expected prefix 'no-beadsdir', got %q", prefix)
}
})
// Worktree bypass: BEADS_DIR skips the worktree guard and git init
t.Run("WorktreeBypassWhenBeadsDirSet", func(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("Skipping worktree test on Windows")
}
resetBeadsDirState(t)
tmpDir := t.TempDir()
// Create a main git repo with an initial commit (required for worktrees)
mainRepo := filepath.Join(tmpDir, "main-repo")
if err := os.MkdirAll(mainRepo, 0755); err != nil {
t.Fatalf("Failed to create main repo dir: %v", err)
}
runGit := func(dir string, args ...string) {
t.Helper()
cmd := exec.Command("git", args...)
cmd.Dir = dir
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("git %v in %s failed: %v\n%s", args, dir, err, out)
}
}
runGit(mainRepo, "init")
runGit(mainRepo, "config", "user.email", "test@test.com")
runGit(mainRepo, "config", "user.name", "Test")
runGit(mainRepo, "commit", "--allow-empty", "-m", "initial")
// Create a worktree
worktreeDir := filepath.Join(tmpDir, "my-worktree")
runGit(mainRepo, "worktree", "add", worktreeDir, "-b", "test-wt")
// Set BEADS_DIR to a standalone location outside the repo
beadsDirPath := filepath.Join(tmpDir, "standalone", ".beads")
if err := os.MkdirAll(filepath.Dir(beadsDirPath), 0755); err != nil {
t.Fatalf("Failed to create standalone dir: %v", err)
}
os.Setenv("BEADS_DIR", beadsDirPath)
t.Cleanup(func() { os.Unsetenv("BEADS_DIR") })
beads.ResetCaches()
git.ResetCaches()
// cd into the worktree — without BEADS_DIR this would fail
t.Chdir(worktreeDir)
rootCmd.SetArgs([]string{"init", "--prefix", "wt-bypass", "--skip-hooks", "--quiet"})
err := rootCmd.Execute()
if err != nil {
t.Fatalf("Init with BEADS_DIR from worktree should succeed, got: %v", err)
}
// Verify database was created at BEADS_DIR, not in the worktree
expectedDBPath := filepath.Join(beadsDirPath, "dolt")
if _, statErr := os.Stat(expectedDBPath); os.IsNotExist(statErr) {
t.Errorf("Dolt database was not created at BEADS_DIR path: %s", expectedDBPath)
}
worktreeDBPath := filepath.Join(worktreeDir, ".beads", "dolt")
if _, statErr := os.Stat(worktreeDBPath); statErr == nil {
t.Errorf("Database should NOT have been created in worktree: %s", worktreeDBPath)
}
})
// Precedence: BEADS_DB > BEADS_DIR
t.Run("BEADS_DB_OverridesBeadsDir", func(t *testing.T) {
t.Skip("BEADS_DB env var does not control Dolt store location; Dolt always uses .beads/dolt/")
resetBeadsDirState(t)
beadsDirTarget := t.TempDir()
beadsDBTarget := t.TempDir()
beadsDirBeads := filepath.Join(beadsDirTarget, ".beads")
if err := os.MkdirAll(beadsDirBeads, 0750); err != nil {
t.Fatal(err)
}
beadsDBPath := filepath.Join(beadsDBTarget, "override.db")
t.Setenv("BEADS_DIR", beadsDirBeads)
t.Setenv("BEADS_DB", beadsDBPath)
tmpDir := t.TempDir()
t.Chdir(tmpDir)
rootCmd.SetArgs([]string{"init", "--prefix", "precedence", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Init with BEADS_DB + BEADS_DIR failed: %v", err)
}
if _, err := os.Stat(beadsDBPath); os.IsNotExist(err) {
t.Errorf("Database was NOT created at BEADS_DB path: %s", beadsDBPath)
}
beadsDirDBPath := filepath.Join(beadsDirBeads, beads.CanonicalDatabaseName)
if _, err := os.Stat(beadsDirDBPath); err == nil {
t.Errorf("Database was incorrectly created at BEADS_DIR path: %s (BEADS_DB should override)", beadsDirDBPath)
}
store, err := openExistingTestDB(t, beadsDBPath)
if err != nil {
t.Fatalf("Failed to open database: %v", err)
}
defer store.Close()
ctx := context.Background()
prefix, err := store.GetConfig(ctx, "issue_prefix")
if err != nil {
t.Fatalf("Failed to get prefix from database: %v", err)
}
if prefix != "precedence" {
t.Errorf("Expected prefix 'precedence', got %q", prefix)
}
})
}
// TestInit_WithBEADS_DIR_DoltBackend verifies that bd init with Dolt backend
// creates the database at BEADS_DIR when the environment variable is set.
// This tests requirements FR-002 for Dolt backend.
func TestInit_WithBEADS_DIR_DoltBackend(t *testing.T) {
// Skip on Windows
if runtime.GOOS == "windows" {
t.Skip("Skipping BEADS_DIR Dolt test on Windows")
}
testutil.RequireDoltBinary(t)
// Reset global state
origDBPath := dbPath
defer func() { dbPath = origDBPath }()
dbPath = ""
// Save and restore BEADS_DIR
origBeadsDir := os.Getenv("BEADS_DIR")
defer func() {
if origBeadsDir != "" {
os.Setenv("BEADS_DIR", origBeadsDir)
} else {
os.Unsetenv("BEADS_DIR")
}
beads.ResetCaches()
git.ResetCaches()
}()
// Reset Cobra flags
initCmd.Flags().Set("prefix", "")
initCmd.Flags().Set("quiet", "false")
initCmd.Flags().Set("backend", "")
tmpDir := t.TempDir()
// Create external BEADS_DIR location
beadsDirPath := filepath.Join(tmpDir, "external", ".beads")
os.MkdirAll(filepath.Dir(beadsDirPath), 0755)
os.Setenv("BEADS_DIR", beadsDirPath)
beads.ResetCaches()
git.ResetCaches()
// Change to a different working directory
cwdPath := filepath.Join(tmpDir, "workdir")
os.MkdirAll(cwdPath, 0755)
t.Chdir(cwdPath)
// Run bd init with Dolt backend
rootCmd.SetArgs([]string{"init", "--prefix", "dolt-test", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("Init with BEADS_DIR and Dolt backend failed: %v", err)
}
// In embedded mode (default), the engine creates .beads/embeddeddolt/ —
// .beads/dolt/ should NOT be created (GH#2903).
unexpectedDoltPath := filepath.Join(beadsDirPath, "dolt")
if _, err := os.Stat(unexpectedDoltPath); err == nil {
t.Errorf("Empty .beads/dolt/ should not be created in embedded mode: %s", unexpectedDoltPath)
}
// Verify database was NOT created at CWD
cwdDoltPath := filepath.Join(cwdPath, ".beads", "dolt")
if _, err := os.Stat(cwdDoltPath); err == nil {
t.Errorf("Dolt database should NOT have been created at CWD: %s", cwdDoltPath)
}
}
// Note: TestInit_WithoutBEADS_DIR_NoBehaviorChange and TestInit_BEADS_DB_OverridesBEADS_DIR
// are now subtests of TestInitBEADS_DIR above.
// TestInitDoltMetadata verifies that bd init --backend dolt writes and persists
// all 3 tracking metadata fields (bd_version, repo_id, clone_id) via verifyMetadata.
// Covers FR-001, FR-002, FR-003, FR-004.
func TestInitDoltMetadata(t *testing.T) {
skipIfNoDolt(t)
if runtime.GOOS == "windows" {
t.Skip("Skipping Dolt metadata test on Windows")
}
saveAndRestoreGlobals(t)
dbPath = ""
// Reset caches to avoid stale state
beads.ResetCaches()
git.ResetCaches()
t.Cleanup(func() {
beads.ResetCaches()
git.ResetCaches()
})
// Reset Cobra flags
initCmd.Flags().Set("prefix", "")
initCmd.Flags().Set("quiet", "false")
initCmd.Flags().Set("backend", "")
tmpDir := newGitRepo(t)
t.Chdir(tmpDir)
// Add remote.origin.url so ComputeRepoID succeeds
_ = runCommandInDir(tmpDir, "git", "config", "remote.origin.url", "https://github.com/test/repo.git")
rootCmd.SetArgs([]string{"init", "--prefix", "test", "--quiet"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("init --backend dolt failed: %v", err)
}
// Open the dolt store to verify metadata was written
ctx := context.Background()
doltPath := filepath.Join(tmpDir, ".beads", "dolt")
doltStore, err := openDoltStoreForTest(t, ctx, doltPath, "test")
if err != nil {
t.Fatalf("failed to open dolt store for verification: %v", err)
}
defer doltStore.Close()
// FR-001: bd_version must be written
bdVersion, err := doltStore.GetLocalMetadata(ctx, "bd_version")
if err != nil {
t.Fatalf("GetLocalMetadata(bd_version) failed: %v", err)
}
if bdVersion == "" {
t.Error("bd_version local metadata was not written")
}
// FR-002: repo_id must be written (git repo with remote configured)
repoID, err := doltStore.GetMetadata(ctx, "repo_id")
if err != nil {
t.Fatalf("GetMetadata(repo_id) failed: %v", err)
}
if repoID == "" {
t.Error("repo_id metadata was not written")
}
// FR-003: clone_id must be written
cloneID, err := doltStore.GetMetadata(ctx, "clone_id")
if err != nil {
t.Fatalf("GetMetadata(clone_id) failed: %v", err)
}
if cloneID == "" {
t.Error("clone_id metadata was not written")
}
}
// openDoltStoreForTest opens an existing Dolt store for read-only verification in tests.
func openDoltStoreForTest(t *testing.T, ctx context.Context, doltPath, dbName string) (*dolt.DoltStore, error) {
t.Helper()
return dolt.New(ctx, &dolt.Config{
Path: doltPath,
Database: dbName,
ReadOnly: true,
})
}
// TestVerifyMetadataSuccess verifies that verifyMetadata writes and reads back metadata.
// Note: Failure path tests (write errors, read-back mismatches) were removed because
// verifyMetadata now takes *dolt.DoltStore (concrete type), making interface-based
// mocking impossible. The failure paths are simple error-to-stderr logic.
func TestVerifyMetadataSuccess(t *testing.T) {
skipIfNoDolt(t)
ctx := context.Background()
tmpDir := t.TempDir()
testDB := filepath.Join(tmpDir, "test.db")
store := newTestStore(t, testDB)
defer store.Close()
ok := verifyMetadata(ctx, store, "test_key", "test_value")
if !ok {
t.Error("verifyMetadata should return true on success")
}
// Verify the value was actually written
val, err := store.GetMetadata(ctx, "test_key")
if err != nil {
t.Fatalf("GetMetadata failed: %v", err)
}
if val != "test_value" {
t.Errorf("expected 'test_value', got %q", val)
}
}
// TestInitDoltMetadataNoGit verifies that bd init outside a git repo gracefully
// skips repo_id while still writing bd_version and clone_id.
// Verifies warning output; actual metadata persistence checked by e2e tests.
// Covers FR-015 (skip repo_id outside git).
func TestInitDoltMetadataNoGit(t *testing.T) {
skipIfNoDolt(t)
if runtime.GOOS == "windows" {
t.Skip("Skipping Dolt metadata test on Windows")
}
saveAndRestoreGlobals(t)
dbPath = ""
beads.ResetCaches()
git.ResetCaches()
t.Cleanup(func() {
beads.ResetCaches()
git.ResetCaches()
})
// Reset Cobra flags
initCmd.Flags().Set("prefix", "")
initCmd.Flags().Set("quiet", "false")
initCmd.Flags().Set("backend", "")
// Create temp dir WITHOUT git init — bd init will create one,
// but there will be no remote configured so upstream warning is expected.
tmpDir := t.TempDir()
t.Chdir(tmpDir)
// Run init in a non-git directory (bd init will create git repo internally)
rootCmd.SetArgs([]string{"init", "--prefix", "nogit"})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("init --prefix nogit failed: %v", err)
}
// Note: no upstream/repository ID warning expected here because bd init
// creates a brand-new git repo with no remotes, and the upstream warning
// is intentionally skipped for repos with no remotes (not noise-worthy).
// Verify .beads/dolt directory was created (init succeeded)
doltPath := filepath.Join(tmpDir, ".beads", "dolt")
if info, err := os.Stat(doltPath); os.IsNotExist(err) {
t.Errorf("Dolt database directory was not created: %s", doltPath)
} else if !info.IsDir() {
t.Errorf("Expected Dolt path to be a directory: %s", doltPath)
}
// Verify no SQLite database was created (backend-specific)
sqlitePath := filepath.Join(tmpDir, ".beads", "beads.db")
if _, err := os.Stat(sqlitePath); err == nil {
t.Errorf("unexpected sqlite database created in dolt mode")
}
}
func TestInitServerModeWritesDoltCompatibilityMarker(t *testing.T) {
skipIfNoDolt(t)
saveAndRestoreGlobals(t)
ensureCleanGlobalState(t)
dbPath = ""
store = nil
tmpDir := t.TempDir()
t.Chdir(tmpDir)
beadsDir := filepath.Join(tmpDir, ".beads")
doltDir := filepath.Join(beadsDir, "dolt")
if err := os.MkdirAll(beadsDir, 0o700); err != nil {
t.Fatalf("creating beads dir: %v", err)
}
if err := os.MkdirAll(filepath.Join(doltDir, ".dolt"), 0o750); err != nil {
t.Fatalf("creating simulated server data dir: %v", err)
}
database := uniqueTestDBName(t)
t.Cleanup(func() {
dropTestDatabase(database, testDoltServerPort)
})
rootCmd.SetArgs([]string{
"init",
"--server",
"--external",
"--server-host", "127.0.0.1",
"--server-port", fmt.Sprintf("%d", testDoltServerPort),
"--database", database,
"--prefix", "marker",
"--quiet",
"--skip-hooks",
"--skip-agents",
})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("server init failed: %v", err)
}
markerPath := filepath.Join(doltDir, ".bd-dolt-ok")
if _, err := os.Stat(markerPath); err != nil {
t.Fatalf("expected server init to write %s: %v", markerPath, err)
}
}
func TestInitServerModeWarnsOnMarkerFailureInQuietMode(t *testing.T) {
skipIfNoDolt(t)
saveAndRestoreGlobals(t)
ensureCleanGlobalState(t)
dbPath = ""
store = nil
tmpDir := t.TempDir()
t.Chdir(tmpDir)
beadsDir := filepath.Join(tmpDir, ".beads")
doltDir := filepath.Join(beadsDir, "dolt")
if err := os.MkdirAll(doltDir, 0o700); err != nil {
t.Fatalf("creating dolt dir: %v", err)
}
if err := os.WriteFile(filepath.Join(doltDir, ".dolt"), []byte("not a dir"), 0o600); err != nil {
t.Fatalf("creating invalid dot-dolt marker: %v", err)
}
database := uniqueTestDBName(t)
t.Cleanup(func() {
dropTestDatabase(database, testDoltServerPort)
})
oldStderr := os.Stderr
r, w, err := os.Pipe()
if err != nil {
t.Fatalf("pipe stderr: %v", err)
}
os.Stderr = w
defer func() {
os.Stderr = oldStderr
}()
rootCmd.SetArgs([]string{
"init",
"--server",
"--external",
"--server-host", "127.0.0.1",
"--server-port", fmt.Sprintf("%d", testDoltServerPort),
"--database", database,
"--prefix", "marker",
"--quiet",
"--skip-hooks",
"--skip-agents",
})
if err := rootCmd.Execute(); err != nil {
w.Close()
t.Fatalf("server init failed: %v", err)
}
if err := w.Close(); err != nil {
t.Fatalf("close stderr writer: %v", err)
}
var stderr bytes.Buffer
if _, err := stderr.ReadFrom(r); err != nil {
t.Fatalf("read stderr: %v", err)
}
if !strings.Contains(stderr.String(), "Warning: failed to write Dolt compatibility marker") {
t.Fatalf("expected marker warning in stderr, got:\n%s", stderr.String())
}
if !strings.Contains(stderr.String(), doltDir) {
t.Fatalf("expected marker warning to include dolt dir %s, got:\n%s", doltDir, stderr.String())
}
}
func setupBareParentInitWorktree(t *testing.T) (string, string) {
t.Helper()
tmpDir := t.TempDir()
bareDir := filepath.Join(tmpDir, "repo.git")
mainWorktreeDir := filepath.Join(tmpDir, "main")
featureWorktreeDir := filepath.Join(tmpDir, "feature")
runGit := func(dir string, args ...string) {
t.Helper()
cmd := exec.Command("git", args...)
cmd.Dir = dir
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("git %v in %s failed: %v\n%s", args, dir, err, out)
}
}
runGit(tmpDir, "init", "--bare", bareDir)
runGit(tmpDir, "--git-dir", bareDir, "symbolic-ref", "HEAD", "refs/heads/main")
runGit(tmpDir, "--git-dir", bareDir, "config", "user.email", "test@example.com")
runGit(tmpDir, "--git-dir", bareDir, "config", "user.name", "Test User")
emptyTreeCmd := exec.Command("git", "--git-dir", bareDir, "hash-object", "-t", "tree", "/dev/null")
emptyTreeCmd.Dir = tmpDir
emptyTreeOut, err := emptyTreeCmd.CombinedOutput()
if err != nil {
t.Fatalf("git hash-object failed: %v\n%s", err, emptyTreeOut)
}
emptyTree := strings.TrimSpace(string(emptyTreeOut))
commitCmd := exec.Command("git", "--git-dir", bareDir, "commit-tree", "-m", "Initial commit", emptyTree)
commitCmd.Dir = tmpDir
commitOut, err := commitCmd.CombinedOutput()
if err != nil {
t.Fatalf("git commit-tree failed: %v\n%s", err, commitOut)
}
initCommit := strings.TrimSpace(string(commitOut))
runGit(tmpDir, "--git-dir", bareDir, "update-ref", "HEAD", initCommit)
runGit(tmpDir, "--git-dir", bareDir, "worktree", "add", mainWorktreeDir, "main")
runGit(mainWorktreeDir, "branch", "feature")
runGit(tmpDir, "--git-dir", bareDir, "worktree", "add", featureWorktreeDir, "feature")
return bareDir, featureWorktreeDir
}
// TestInitDatabaseFlag tests the --database flag for bd init.
// Uses subprocess execution because:
// - init manipulates extensive Cobra global state that's difficult to reset
// - FatalError calls os.Exit(1) for validation errors, which kills in-process tests
//
// Each subtest runs bd init in a temp directory and verifies metadata.json.
func TestInitDatabaseFlag(t *testing.T) {
skipIfNoDolt(t)
bd := buildBDForInitTests(t)
t.Run("metadata_written", func(t *testing.T) {
tmpDir := t.TempDir()
// Run init with --database to specify a pre-existing database name
cmd := exec.Command(bd, "init", "--database", "myapp_production", "--quiet")
cmd.Dir = tmpDir
cmd.Env = os.Environ()
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("bd init --database failed: %v\n%s", err, out)
}
// Verify metadata.json contains the correct database name
beadsDir := filepath.Join(tmpDir, ".beads")
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("Failed to load metadata.json: %v", err)
}
if cfg == nil {
t.Fatal("metadata.json not found")
}
if cfg.DoltDatabase != "myapp_production" {
t.Errorf("Expected DoltDatabase %q, got %q", "myapp_production", cfg.DoltDatabase)
}
if cfg.DoltMode != configfile.DoltModeServer {
t.Errorf("Expected DoltMode %q, got %q", configfile.DoltModeServer, cfg.DoltMode)
}
})
t.Run("BareParentWorktreeAutoInit", func(t *testing.T) {
skipIfNoDolt(t)
if runtime.GOOS == "windows" {
t.Skip("Skipping worktree test on Windows")
}
origDBPath := dbPath
t.Cleanup(func() {
dbPath = origDBPath
beads.ResetCaches()
git.ResetCaches()
})
dbPath = ""
beads.ResetCaches()
git.ResetCaches()
bd := buildBDForInitTests(t)
bareDir, worktreeDir := setupBareParentInitWorktree(t)
bareBeadsDir := filepath.Join(bareDir, ".beads")
cmd := exec.Command(bd, "init", "--prefix", "bare-fallback", "--skip-hooks", "--quiet")
cmd.Dir = worktreeDir
cmd.Env = append(os.Environ(), "BEADS_DOLT_SHARED_SERVER=1")
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("bd init from bare-parent worktree failed: %v\n%s", err, out)
}
if _, err := os.Stat(filepath.Join(bareBeadsDir, "metadata.json")); err != nil {
t.Fatalf("expected bare parent metadata.json to exist: %v", err)
}
if _, err := os.Stat(filepath.Join(worktreeDir, ".beads")); !os.IsNotExist(err) {
t.Fatalf("worktree should not get a local .beads directory, stat err=%v", err)
}
retry := exec.Command(bd, "init", "--prefix", "bare-fallback", "--skip-hooks", "--quiet")
retry.Dir = worktreeDir
retry.Env = append(os.Environ(), "BEADS_DOLT_SHARED_SERVER=1")
retryOut, retryErr := retry.CombinedOutput()
if retryErr == nil {
t.Fatal("expected second bd init to fail against existing bare-parent .beads")
}
if !strings.Contains(string(retryOut), "already initialized") && !strings.Contains(string(retryOut), "already exists") {
t.Fatalf("expected existing-data guard on second init, got:\n%s", retryOut)
}
})
t.Run("with_prefix", func(t *testing.T) {
tmpDir := t.TempDir()
// Run init with both --database and --prefix
// --database should override prefix for DB name, but prefix still sets issue_prefix
cmd := exec.Command(bd, "init", "--database", "shared_db", "--prefix", "team-alpha", "--quiet")
cmd.Dir = tmpDir
cmd.Env = os.Environ()
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("bd init --database --prefix failed: %v\n%s", err, out)
}
// Verify metadata.json
beadsDir := filepath.Join(tmpDir, ".beads")
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("Failed to load metadata.json: %v", err)
}
if cfg == nil {
t.Fatal("metadata.json not found")
}
// --database overrides the SQL database name
if cfg.DoltDatabase != "shared_db" {
t.Errorf("Expected DoltDatabase %q (from --database), got %q", "shared_db", cfg.DoltDatabase)
}
// Verify the database was opened and issue_prefix was set
// by reopening the store and checking config
dbPath := filepath.Join(beadsDir, "dolt")
s, err := openExistingTestDB(t, dbPath)
if err != nil {
t.Fatalf("Failed to reopen database: %v", err)
}
defer s.Close()
ctx := context.Background()
issuePrefix, err := s.GetConfig(ctx, "issue_prefix")
if err != nil {
t.Fatalf("Failed to get issue_prefix: %v", err)
}
if issuePrefix != "team-alpha" {
t.Errorf("Expected issue_prefix %q (from --prefix), got %q", "team-alpha", issuePrefix)
}
})
t.Run("server_config_in_metadata", func(t *testing.T) {
tmpDir := t.TempDir()
// Run init with --database
cmd := exec.Command(bd, "init", "--database", "test_server_cfg", "--quiet")
cmd.Dir = tmpDir
cmd.Env = os.Environ()
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("bd init --database failed: %v\n%s", err, out)
}
// Verify metadata.json has both dolt_database and dolt_mode: server
beadsDir := filepath.Join(tmpDir, ".beads")
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("Failed to load metadata.json: %v", err)
}
if cfg == nil {
t.Fatal("metadata.json not found")
}
if cfg.DoltDatabase != "test_server_cfg" {
t.Errorf("Expected DoltDatabase %q, got %q", "test_server_cfg", cfg.DoltDatabase)
}
if cfg.DoltMode != configfile.DoltModeServer {
t.Errorf("Expected DoltMode %q, got %q", configfile.DoltModeServer, cfg.DoltMode)
}
if cfg.Backend != configfile.BackendDolt {
t.Errorf("Expected Backend %q, got %q", configfile.BackendDolt, cfg.Backend)
}
})
t.Run("shared_server_flag_selects_server_mode", func(t *testing.T) {
tmpDir := t.TempDir()
cmd := exec.Command(bd, "init", "--shared-server", "--prefix", "shared-mode-test", "--skip-hooks")
cmd.Dir = tmpDir
cmd.Env = os.Environ()
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("bd init --shared-server failed: %v\n%s", err, out)
}
beadsDir := filepath.Join(tmpDir, ".beads")
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("Failed to load metadata.json: %v", err)
}
if cfg == nil {
t.Fatal("metadata.json not found")
}
if cfg.DoltMode != configfile.DoltModeServer {
t.Errorf("Expected DoltMode %q, got %q", configfile.DoltModeServer, cfg.DoltMode)
}
configYAML, err := os.ReadFile(filepath.Join(beadsDir, "config.yaml"))
if err != nil {
t.Fatalf("Failed to read config.yaml: %v", err)
}
if !strings.Contains(string(configYAML), "dolt.shared-server: true") {
t.Fatalf("expected config.yaml to enable shared server, got:\n%s", configYAML)
}
outStr := string(out)
if !strings.Contains(outStr, "Shared server mode enabled") {
t.Fatalf("expected init output to mention shared server mode, got:\n%s", outStr)
}
if !strings.Contains(outStr, "Mode: server") {
t.Fatalf("expected init output to report server mode, got:\n%s", outStr)
}
if strings.Contains(outStr, "Mode: embedded") {
t.Fatalf("init output should not report embedded mode when --shared-server is set:\n%s", outStr)
}
})
t.Run("validation_invalid_name", func(t *testing.T) {
tmpDir := t.TempDir()
// Run init with an invalid database name (contains semicolon = SQL injection)
cmd := exec.Command(bd, "init", "--database", "bad;name", "--quiet")
cmd.Dir = tmpDir
cmd.Env = os.Environ()
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatal("Expected error for invalid database name, but command succeeded")
}
outStr := string(out)
if !strings.Contains(outStr, "invalid database name") {
t.Errorf("Expected error to mention 'invalid database name', got: %s", outStr)
}
// Verify no .beads directory was created (early validation prevents side effects)
beadsDir := filepath.Join(tmpDir, ".beads")
if _, err := os.Stat(beadsDir); err == nil {
t.Error(".beads directory should not be created when validation fails")
}
})
t.Run("validation_name_with_spaces", func(t *testing.T) {
tmpDir := t.TempDir()
// Database name with spaces should fail validation
cmd := exec.Command(bd, "init", "--database", "my database", "--quiet")
cmd.Dir = tmpDir
cmd.Env = os.Environ()
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatal("Expected error for database name with spaces, but command succeeded")
}
outStr := string(out)
if !strings.Contains(outStr, "invalid database name") {
t.Errorf("Expected error to mention 'invalid database name', got: %s", outStr)
}
})
t.Run("validation_name_with_backtick", func(t *testing.T) {
tmpDir := t.TempDir()
// Database name with backtick injection should fail validation
cmd := exec.Command(bd, "init", "--database", "db`; DROP DATABASE x; --", "--quiet")
cmd.Dir = tmpDir
cmd.Env = os.Environ()
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatal("Expected error for database name with backtick injection, but command succeeded")
}
outStr := string(out)
if !strings.Contains(outStr, "invalid database name") {
t.Errorf("Expected error to mention 'invalid database name', got: %s", outStr)
}
})
}
func TestBareParentWorktreeCoreCommandsWithoutRedirect(t *testing.T) {
skipIfNoDolt(t)
if runtime.GOOS == "windows" {
t.Skip("Skipping worktree test on Windows")
}
bd := buildBDForInitTests(t)
bareDir, worktreeDir := setupBareParentInitWorktree(t)
bareBeadsDir := filepath.Join(bareDir, ".beads")
sharedEnv := append(os.Environ(), "BEADS_DOLT_SHARED_SERVER=1")
initCmd := exec.Command(bd, "init", "--prefix", "bare-core", "--skip-hooks", "--quiet")
initCmd.Dir = worktreeDir
initCmd.Env = sharedEnv
if out, err := initCmd.CombinedOutput(); err != nil {
t.Fatalf("bd init from bare-parent worktree failed: %v\n%s", err, out)
}
if _, err := os.Stat(filepath.Join(bareBeadsDir, "metadata.json")); err != nil {
t.Fatalf("expected bare parent metadata.json to exist: %v", err)
}
createCmd := exec.Command(bd, "create", "bare fallback issue", "--description", "regression", "--json")
createCmd.Dir = worktreeDir
createCmd.Env = sharedEnv
createOut, err := createCmd.CombinedOutput()
if err != nil {
t.Fatalf("bd create from bare-parent worktree failed: %v\n%s", err, createOut)
}
if !strings.Contains(string(createOut), "bare fallback issue") {
t.Fatalf("bd create output did not include created title:\n%s", createOut)
}
listCmd := exec.Command(bd, "list", "--json")
listCmd.Dir = worktreeDir
listCmd.Env = sharedEnv
listOut, err := listCmd.CombinedOutput()
if err != nil {
t.Fatalf("bd list from bare-parent worktree failed: %v\n%s", err, listOut)
}
if !strings.Contains(string(listOut), "bare fallback issue") {
t.Fatalf("bd list output did not include created issue:\n%s", listOut)
}
}
func TestInitBackendFlag(t *testing.T) {
bd := buildBDForInitTests(t)
t.Run("sqlite_shows_deprecation", func(t *testing.T) {
tmpDir := t.TempDir()
cmd := exec.Command(bd, "init", "--backend", "sqlite", "--quiet")
cmd.Dir = tmpDir
cmd.Env = os.Environ()
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatal("Expected non-zero exit for --backend=sqlite, but command succeeded")
}
outStr := string(out)
if !strings.Contains(outStr, "DEPRECATED") {
t.Errorf("Expected deprecation notice, got: %s", outStr)
}
if !strings.Contains(outStr, "SQLite backend has been removed") {
t.Errorf("Expected 'SQLite backend has been removed' message, got: %s", outStr)
}
if !strings.Contains(outStr, "bd init --from-jsonl") {
t.Errorf("Expected migration instructions, got: %s", outStr)
}
// Verify no .beads directory was created
beadsDir := filepath.Join(tmpDir, ".beads")
if _, err := os.Stat(beadsDir); err == nil {
t.Error(".beads directory should not be created when --backend=sqlite is used")
}
})
t.Run("unknown_backend_errors", func(t *testing.T) {
tmpDir := t.TempDir()
cmd := exec.Command(bd, "init", "--backend", "postgres", "--quiet")
cmd.Dir = tmpDir
cmd.Env = os.Environ()
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatal("Expected non-zero exit for --backend=postgres, but command succeeded")
}
outStr := string(out)
if !strings.Contains(outStr, "unknown backend") {
t.Errorf("Expected 'unknown backend' error, got: %s", outStr)
}
})
t.Run("dolt_backend_succeeds", func(t *testing.T) {
skipIfNoDolt(t)
tmpDir := t.TempDir()
cmd := exec.Command(bd, "init", "--backend", "dolt", "--quiet")
cmd.Dir = tmpDir
cmd.Env = os.Environ()
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("bd init --backend=dolt should succeed: %v\n%s", err, out)
}
})
t.Run("default_backend_is_dolt", func(t *testing.T) {
skipIfNoDolt(t)
tmpDir := t.TempDir()
cmd := exec.Command(bd, "init", "--quiet")
cmd.Dir = tmpDir
cmd.Env = os.Environ()
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("bd init should default to dolt: %v\n%s", err, out)
}
// Verify metadata.json has backend: dolt
beadsDir := filepath.Join(tmpDir, ".beads")
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("Failed to load metadata.json: %v", err)
}
if cfg == nil {
t.Fatal("metadata.json not found")
}
if cfg.Backend != configfile.BackendDolt {
t.Errorf("Expected backend %q, got %q", configfile.BackendDolt, cfg.Backend)
}
})
}
// TestInitDatabaseAdoptsExistingProjectID verifies that bd init --database adopts
// the _project_id from an existing server database instead of generating a new one.
// This prevents PROJECT IDENTITY MISMATCH errors when multiple users connect to
// a shared remote Dolt server. (GH#2922)
func TestInitDatabaseAdoptsExistingProjectID(t *testing.T) {
skipIfNoDolt(t)
// Reset global state
origDBPath := dbPath
origStore := store
defer func() {
if store != nil && store != origStore {
store.Close()
}
store = origStore
dbPath = origDBPath
}()
dbPath = ""
store = nil
ctx := context.Background()
// Create a database with a known _project_id (simulates first user's init)
database := uniqueTestDBName(t)
firstBeadsDir := filepath.Join(t.TempDir(), ".beads")
if err := os.MkdirAll(firstBeadsDir, 0o755); err != nil {
t.Fatalf("mkdir: %v", err)
}
doltNewMutex.Lock()
firstStore, err := dolt.New(ctx, &dolt.Config{
Path: filepath.Join(firstBeadsDir, "dolt"),
BeadsDir: firstBeadsDir,
ServerHost: "127.0.0.1",
ServerPort: testDoltServerPort,
Database: database,
CreateIfMissing: true,
})
doltNewMutex.Unlock()
if err != nil {
t.Fatalf("create first store: %v", err)
}
knownProjectID := "test-known-project-id-gh2922"
if err := firstStore.SetMetadata(ctx, "_project_id", knownProjectID); err != nil {
t.Fatalf("set _project_id: %v", err)
}
if err := firstStore.SetConfig(ctx, "issue_prefix", "test"); err != nil {
t.Fatalf("set issue_prefix: %v", err)
}
firstStore.Close()
t.Cleanup(func() {
dropTestDatabase(database, testDoltServerPort)
})
// Simulate second user — init with --database pointing at the existing DB
secondDir := t.TempDir()
t.Chdir(secondDir)
// Set up minimal git repo (init expects it for repo_id)
if err := exec.Command("git", "-C", secondDir, "init").Run(); err != nil {
t.Fatalf("git init: %v", err)
}
_ = exec.Command("git", "-C", secondDir, "config", "user.email", "test@test.com").Run()
_ = exec.Command("git", "-C", secondDir, "config", "user.name", "Test").Run()
rootCmd.SetArgs([]string{
"init",
"--server",
"--server-host", "127.0.0.1",
"--server-port", fmt.Sprintf("%d", testDoltServerPort),
"--database", database,
"--prefix", "second",
"--quiet",
"--skip-hooks",
"--skip-agents",
})
if err := rootCmd.Execute(); err != nil {
t.Fatalf("second init failed: %v", err)
}
// Verify the second user's metadata.json adopted the existing project_id
secondBeadsDir := filepath.Join(secondDir, ".beads")
cfg, err := configfile.Load(secondBeadsDir)
if err != nil {
t.Fatalf("load metadata.json: %v", err)
}
if cfg.ProjectID != knownProjectID {
t.Errorf("ProjectID = %q, want %q (should adopt existing project_id from server)", cfg.ProjectID, knownProjectID)
}
}