beads/cmd/bd/init_embedded_test.go
matt wilkie d7d3dad580
fix(dolt): adopt git origin on first push (#3940)
* fix(dolt): adopt git origin on first push

bd dolt push now wires an existing git origin when no Dolt remote is configured, while init without origin stays local and doctor shows the concrete adoption command. This keeps refs/dolt/data sync discoverable without treating plain remotes as existing Dolt history.\n\n_kilocode-openai/gpt-5.5- on behalf of maphew_

* fix(dolt): address origin adoption review nits

Share Dolt remote URL normalization between the push adoption path and doctor guidance, fail before mutating Dolt state when no beads workspace is selected, and cover CheckRemoteConsistency's adoption detail.

_codex-gpt-5-medium on behalf of maphew_
2026-05-18 10:43:51 -07:00

1232 lines
42 KiB
Go

//go:build cgo
package main
import (
"bytes"
"context"
"encoding/json"
"fmt"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"sync"
"testing"
"time"
"github.com/steveyegge/beads/internal/configfile"
"github.com/steveyegge/beads/internal/storage/embeddeddolt"
"github.com/steveyegge/beads/internal/types"
)
var (
embeddedBDOnce sync.Once
embeddedBD string
embeddedBDErr error
)
// buildEmbeddedBD returns the path to an embedded bd binary for subprocess tests.
// If BEADS_TEST_BD_BINARY is set, uses that pre-built binary (skipping the ~45s build).
// CI can pre-build once and pass the path to all test invocations.
func buildEmbeddedBD(t *testing.T) string {
t.Helper()
embeddedBDOnce.Do(func() {
if prebuilt := os.Getenv("BEADS_TEST_BD_BINARY"); prebuilt != "" {
if _, err := os.Stat(prebuilt); err != nil {
embeddedBDErr = fmt.Errorf("BEADS_TEST_BD_BINARY=%q not found: %w", prebuilt, err)
return
}
embeddedBD = prebuilt
return
}
tmpDir, err := os.MkdirTemp("", "bd-embedded-init-test-*")
if err != nil {
embeddedBDErr = fmt.Errorf("failed to create temp dir: %w", err)
return
}
name := "bd"
if runtime.GOOS == "windows" {
name = "bd.exe"
}
embeddedBD = filepath.Join(tmpDir, name)
cmd := exec.Command("go", "build", "-tags", "gms_pure_go", "-o", embeddedBD, ".")
if out, err := cmd.CombinedOutput(); err != nil {
embeddedBDErr = fmt.Errorf("go build failed: %v\n%s", err, out)
}
})
if embeddedBDErr != nil {
t.Fatalf("Failed to build embedded bd binary: %v", embeddedBDErr)
}
return embeddedBD
}
func initGitRepoAt(t *testing.T, dir string) {
t.Helper()
for _, args := range [][]string{
{"init"},
{"config", "user.email", "test@test.com"},
{"config", "user.name", "Test"},
// Force repo-local hooks so tests ignore any global hooksPath override.
{"config", "core.hooksPath", ".git/hooks"},
} {
cmd := exec.Command("git", args...)
cmd.Dir = dir
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("git %s failed: %v\n%s", args[0], err, out)
}
}
}
func bdEnv(dir string) []string {
var env []string
for _, e := range os.Environ() {
if strings.HasPrefix(e, "BEADS_") {
continue
}
env = append(env, e)
}
return append(env, "HOME="+dir, "BEADS_DOLT_AUTO_START=0", "BEADS_NO_DAEMON=1")
}
func isEmbeddedLockOutput(out string) bool {
out = strings.ToLower(out)
return strings.Contains(out, "one writer at a time") ||
strings.Contains(out, "database is locked") ||
strings.Contains(out, "locked by another dolt process")
}
func runCommandBuffers(t *testing.T, cmd *exec.Cmd) (stdout, stderr bytes.Buffer, err error) {
t.Helper()
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err = cmd.Run()
return stdout, stderr, err
}
// bdRunWithFlockRetry runs a bd command with retry on flock contention.
// Returns stdout and nil on success, or combined stdout/stderr and the last
// error after retries are exhausted or a non-flock error occurs.
func bdRunWithFlockRetry(t *testing.T, bd, dir string, args ...string) ([]byte, error) {
t.Helper()
var out []byte
var err error
for attempt := 0; attempt < 10; attempt++ {
cmd := exec.Command(bd, args...)
cmd.Dir = dir
cmd.Env = bdEnv(dir)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err = cmd.Run()
if err == nil {
return stdout.Bytes(), nil
}
out = append(stdout.Bytes(), stderr.Bytes()...)
if !isEmbeddedLockOutput(string(out)) {
return out, err
}
t.Logf("bd %s: flock contention (attempt %d/10), retrying...", args[0], attempt+1)
time.Sleep(time.Duration(500*(1<<min(attempt, 4))) * time.Millisecond)
}
return out, err
}
// bdInit creates a temp dir with a git repo, runs bd init --quiet with the
// given extra args, and returns (dir, beadsDir, combined output).
// Fatals if bd init fails.
func bdInit(t *testing.T, bd string, extraArgs ...string) (dir, beadsDir string, out string) {
t.Helper()
dir = t.TempDir()
initGitRepoAt(t, dir)
out = runBDInit(t, bd, dir, extraArgs...)
beadsDir = filepath.Join(dir, ".beads")
return
}
// bdInitInDir runs bd init --quiet in an existing dir. Fatals on failure.
func runBDInit(t *testing.T, bd, dir string, extraArgs ...string) string {
t.Helper()
args := append([]string{"init", "--quiet"}, extraArgs...)
cmd := exec.Command(bd, args...)
cmd.Dir = dir
cmd.Env = bdEnv(dir)
stdout, stderr, err := runCommandBuffers(t, cmd)
if err != nil {
t.Fatalf("bd init %s failed: %v\nstdout:\n%s\nstderr:\n%s", strings.Join(extraArgs, " "), err, stdout.String(), stderr.String())
}
return stdout.String()
}
// bdInitFail runs bd init --quiet expecting failure. Returns combined output.
func bdInitFail(t *testing.T, bd string, extraArgs ...string) string {
t.Helper()
dir := t.TempDir()
initGitRepoAt(t, dir)
args := append([]string{"init", "--quiet"}, extraArgs...)
cmd := exec.Command(bd, args...)
cmd.Dir = dir
cmd.Env = bdEnv(dir)
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatal("bd init should have failed")
}
return string(out)
}
func readBack(t *testing.T, beadsDir, database, key string, metadata bool) string {
t.Helper()
// The embedded dolt driver holds a process-level lock, so concurrent
// test functions in the same shard can transiently block each other.
// Retry a few times before giving up.
const maxAttempts = 5
var lastErr error
for attempt := 0; attempt < maxAttempts; attempt++ {
if attempt > 0 {
time.Sleep(time.Duration(attempt) * 500 * time.Millisecond)
}
val, err := readBackOnce(t, beadsDir, database, key, metadata)
if err == nil {
return val
}
lastErr = err
if !strings.Contains(err.Error(), "locked") {
break // non-lock error, don't retry
}
t.Logf("readBack: attempt %d/%d got lock error, retrying: %v", attempt+1, maxAttempts, err)
}
t.Fatalf("readBack: %v", lastErr)
return "" // unreachable
}
func readBackOnce(t *testing.T, beadsDir, database, key string, metadata bool) (string, error) {
t.Helper()
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
store, err := embeddeddolt.Open(ctx, beadsDir, database, "main")
if err != nil {
return "", fmt.Errorf("New failed: %w", err)
}
defer store.Close()
if metadata {
val, err := store.GetMetadata(ctx, key)
if err != nil {
return "", fmt.Errorf("GetMetadata(%q) failed: %w", key, err)
}
return val, nil
}
val, err := store.GetConfig(ctx, key)
if err != nil {
return "", fmt.Errorf("GetConfig(%q) failed: %w", key, err)
}
return val, nil
}
func stripANSI(s string) string {
var out strings.Builder
for i := 0; i < len(s); i++ {
if s[i] == '\033' && i+1 < len(s) && s[i+1] == '[' {
for i += 2; i < len(s); i++ {
if (s[i] >= 'A' && s[i] <= 'Z') || (s[i] >= 'a' && s[i] <= 'z') {
break
}
}
continue
}
out.WriteByte(s[i])
}
return out.String()
}
func runDolt(t *testing.T, doltBin, dir string, args ...string) string {
t.Helper()
cmd := exec.Command(doltBin, args...)
cmd.Dir = dir
out, err := cmd.Output()
if err != nil {
t.Fatalf("dolt %s failed: %v", strings.Join(args, " "), err)
}
return stripANSI(string(out))
}
func doltHeadHash(t *testing.T, doltBin, dir string) string {
t.Helper()
line := strings.TrimSpace(runDolt(t, doltBin, dir, "log", "-n", "1", "--oneline"))
if idx := strings.IndexByte(line, ' '); idx > 0 {
return line[:idx]
}
t.Fatalf("unexpected dolt log --oneline output: %q", line)
return ""
}
func requireFile(t *testing.T, path string) {
t.Helper()
if _, err := os.Stat(path); os.IsNotExist(err) {
t.Errorf("expected file to exist: %s", path)
}
}
func requireNoFile(t *testing.T, path string) {
t.Helper()
if _, err := os.Stat(path); err == nil {
t.Errorf("expected file not to exist: %s", path)
}
}
func TestEmbeddedInit(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt init tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
t.Run("basic", func(t *testing.T) {
dir, beadsDir, _ := bdInit(t, bd, "--prefix", "basic")
embeddedDir := filepath.Join(beadsDir, "embeddeddolt")
requireFile(t, beadsDir)
requireFile(t, embeddedDir)
requireFile(t, filepath.Join(embeddedDir, "basic", ".dolt"))
if doltBin, err := exec.LookPath("dolt"); err == nil {
dbDir := filepath.Join(embeddedDir, "basic")
statusOut := runDolt(t, doltBin, dbDir, "status")
if !strings.Contains(statusOut, "nothing to commit") {
t.Errorf("expected clean working set, got:\n%s", statusOut)
}
logOut := runDolt(t, doltBin, dbDir, "log", "--oneline")
for _, want := range []string{"schema: apply migrations", "bd init"} {
if !strings.Contains(logOut, want) {
t.Errorf("dolt log missing %q commit:\n%s", want, logOut)
}
}
}
_ = dir
})
t.Run("prefix", func(t *testing.T) {
_, beadsDir, _ := bdInit(t, bd, "--prefix", "myproj")
if val := readBack(t, beadsDir, "myproj", "issue_prefix", false); val != "myproj" {
t.Errorf("issue_prefix: got %q, want %q", val, "myproj")
}
})
t.Run("prefix_trailing_hyphen", func(t *testing.T) {
_, beadsDir, _ := bdInit(t, bd, "--prefix", "test-")
if val := readBack(t, beadsDir, "test", "issue_prefix", false); val != "test" {
t.Errorf("issue_prefix: got %q, want %q", val, "test")
}
})
t.Run("quiet", func(t *testing.T) {
_, _, out := bdInit(t, bd, "--prefix", "qt")
if strings.Contains(out, "bd initialized") {
t.Error("--quiet should suppress success message")
}
})
t.Run("not_quiet", func(t *testing.T) {
dir := t.TempDir()
initGitRepoAt(t, dir)
cmd := exec.Command(bd, "init", "--prefix", "nq")
cmd.Dir = dir
cmd.Env = bdEnv(dir)
stdout, stderr, err := runCommandBuffers(t, cmd)
if err != nil {
t.Fatalf("bd init failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String())
}
if !strings.Contains(stdout.String(), "bd initialized successfully") {
t.Errorf("expected success message, got: %s", stdout.String())
}
})
t.Run("git_origin_registered_as_dolt_remote", func(t *testing.T) {
bareDir := filepath.Join(t.TempDir(), "plain.git")
runGitForBootstrapTest(t, "", "init", "--bare", "-b", "main", bareDir)
seedDir := t.TempDir()
initGitRepoAt(t, seedDir)
runGitForBootstrapTest(t, seedDir, "branch", "-M", "main")
runGitForBootstrapTest(t, seedDir, "commit", "--allow-empty", "-m", "init")
runGitForBootstrapTest(t, seedDir, "remote", "add", "origin", "file://"+bareDir)
runGitForBootstrapTest(t, seedDir, "push", "-u", "origin", "main")
dir := t.TempDir()
initGitRepoAt(t, dir)
remoteURL := "file://" + bareDir
runGitForBootstrapTest(t, dir, "remote", "add", "origin", remoteURL)
runBDInit(t, bd, dir, "--prefix", "pg", "--skip-hooks", "--skip-agents")
out := bdDolt(t, bd, dir, "remote", "list")
if !strings.Contains(out, "origin") || !strings.Contains(out, remoteURL) {
t.Fatalf("git origin should be registered as a Dolt remote %q; remote list:\n%s", remoteURL, out)
}
configYAML, err := os.ReadFile(filepath.Join(dir, ".beads", "config.yaml"))
if err != nil {
t.Fatalf("read config.yaml: %v", err)
}
if !strings.Contains(string(configYAML), remoteURL) {
t.Fatalf("git origin should be persisted as sync.remote; config.yaml:\n%s", configYAML)
}
bdDolt(t, bd, dir, "push")
ls := exec.Command("git", "ls-remote", remoteURL, "refs/dolt/data")
lsOut, err := ls.CombinedOutput()
if err != nil {
t.Fatalf("git ls-remote refs/dolt/data failed: %v\n%s", err, lsOut)
}
if !strings.Contains(string(lsOut), "refs/dolt/data") {
t.Fatalf("bd dolt push did not publish refs/dolt/data:\n%s", lsOut)
}
})
t.Run("no_git_origin_stays_local", func(t *testing.T) {
dir := t.TempDir()
initGitRepoAt(t, dir)
runBDInit(t, bd, dir, "--prefix", "local", "--skip-hooks", "--skip-agents")
out := bdDolt(t, bd, dir, "remote", "list")
if strings.Contains(out, "origin") {
t.Fatalf("init without git origin should not configure a Dolt remote; remote list:\n%s", out)
}
configYAML, err := os.ReadFile(filepath.Join(dir, ".beads", "config.yaml"))
if err != nil {
t.Fatalf("read config.yaml: %v", err)
}
if strings.Contains(string(configYAML), "sync.remote:") || strings.Contains(string(configYAML), "sync-remote:") {
t.Fatalf("init without git origin should not persist sync.remote; config.yaml:\n%s", configYAML)
}
})
t.Run("dolt_push_lazily_adopts_later_git_origin", func(t *testing.T) {
bareDir := filepath.Join(t.TempDir(), "later-origin.git")
runGitForBootstrapTest(t, "", "init", "--bare", "-b", "main", bareDir)
remoteURL := "file://" + bareDir
dir := t.TempDir()
initGitRepoAt(t, dir)
runGitForBootstrapTest(t, dir, "branch", "-M", "main")
runGitForBootstrapTest(t, dir, "commit", "--allow-empty", "-m", "init")
runBDInit(t, bd, dir, "--prefix", "late", "--skip-hooks", "--skip-agents")
bdCreate(t, bd, dir, "Lazy remote adoption", "--type", "task")
runGitForBootstrapTest(t, dir, "remote", "add", "origin", remoteURL)
runGitForBootstrapTest(t, dir, "push", "-u", "origin", "main")
bdDolt(t, bd, dir, "push")
out := bdDolt(t, bd, dir, "remote", "list")
if !strings.Contains(out, "origin") || !strings.Contains(out, remoteURL) {
t.Fatalf("bd dolt push should adopt later git origin %q; remote list:\n%s", remoteURL, out)
}
configYAML, err := os.ReadFile(filepath.Join(dir, ".beads", "config.yaml"))
if err != nil {
t.Fatalf("read config.yaml: %v", err)
}
if !strings.Contains(string(configYAML), remoteURL) {
t.Fatalf("bd dolt push should persist sync.remote; config.yaml:\n%s", configYAML)
}
ls := exec.Command("git", "ls-remote", remoteURL, "refs/dolt/data")
lsOut, err := ls.CombinedOutput()
if err != nil {
t.Fatalf("git ls-remote refs/dolt/data failed: %v\n%s", err, lsOut)
}
if !strings.Contains(string(lsOut), "refs/dolt/data") {
t.Fatalf("bd dolt push did not publish refs/dolt/data:\n%s", lsOut)
}
})
t.Run("dolt_push_adopts_target_origin_with_dash_c", func(t *testing.T) {
targetBare := filepath.Join(t.TempDir(), "target-origin.git")
ambientBare := filepath.Join(t.TempDir(), "ambient-origin.git")
runGitForBootstrapTest(t, "", "init", "--bare", "-b", "main", targetBare)
runGitForBootstrapTest(t, "", "init", "--bare", "-b", "main", ambientBare)
targetURL := "file://" + targetBare
ambientURL := "file://" + ambientBare
targetDir := t.TempDir()
initGitRepoAt(t, targetDir)
runGitForBootstrapTest(t, targetDir, "branch", "-M", "main")
runGitForBootstrapTest(t, targetDir, "commit", "--allow-empty", "-m", "init")
runBDInit(t, bd, targetDir, "--prefix", "dc", "--skip-hooks", "--skip-agents")
bdCreate(t, bd, targetDir, "Dash C remote adoption", "--type", "task")
runGitForBootstrapTest(t, targetDir, "remote", "add", "origin", targetURL)
runGitForBootstrapTest(t, targetDir, "push", "-u", "origin", "main")
ambientDir := t.TempDir()
initGitRepoAt(t, ambientDir)
runGitForBootstrapTest(t, ambientDir, "remote", "add", "origin", ambientURL)
cmd := exec.Command(bd, "-C", targetDir, "dolt", "push")
cmd.Dir = ambientDir
cmd.Env = bdEnv(ambientDir)
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("bd -C target dolt push failed: %v\n%s", err, out)
}
out := bdDolt(t, bd, targetDir, "remote", "list")
if !strings.Contains(out, "origin") || !strings.Contains(out, targetURL) {
t.Fatalf("bd -C target dolt push should adopt target origin %q; remote list:\n%s", targetURL, out)
}
if strings.Contains(out, ambientURL) {
t.Fatalf("bd -C target dolt push adopted ambient origin %q; remote list:\n%s", ambientURL, out)
}
})
t.Run("stealth_skips_git_origin_remote_synthesis", func(t *testing.T) {
bareDir := filepath.Join(t.TempDir(), "stealth.git")
runGitForBootstrapTest(t, "", "init", "--bare", "-b", "main", bareDir)
dir := t.TempDir()
initGitRepoAt(t, dir)
runGitForBootstrapTest(t, dir, "remote", "add", "origin", "file://"+bareDir)
runBDInit(t, bd, dir, "--prefix", "st", "--stealth", "--skip-agents")
out := bdDolt(t, bd, dir, "remote", "list")
if strings.Contains(out, "origin") {
t.Fatalf("stealth init should not synthesize a Dolt remote; remote list:\n%s", out)
}
configYAML, err := os.ReadFile(filepath.Join(dir, ".beads", "config.yaml"))
if err != nil {
t.Fatalf("read config.yaml: %v", err)
}
if strings.Contains(string(configYAML), "sync.remote:") || strings.Contains(string(configYAML), "sync-remote:") {
t.Fatalf("stealth init should not persist sync.remote; config.yaml:\n%s", configYAML)
}
})
t.Run("remote_bootstraps_existing_dolt_data", func(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("uses os.Symlink to mask dolt off PATH; symlink semantics differ on Windows")
}
remoteDir := filepath.Join(t.TempDir(), "remote")
remoteURL := "file://" + remoteDir
sourceDir, _, _ := bdInit(t, bd, "--prefix", "src", "--skip-hooks", "--skip-agents")
sourceCfg, err := configfile.Load(filepath.Join(sourceDir, ".beads"))
if err != nil {
t.Fatalf("load source metadata.json: %v", err)
}
if sourceCfg.ProjectID == "" {
t.Fatal("source project ID is empty")
}
cmd := exec.Command(bd, "create", "Remote issue", "--type", "task")
cmd.Dir = sourceDir
cmd.Env = bdEnv(sourceDir)
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("bd create failed: %v\n%s", err, out)
}
bdDolt(t, bd, sourceDir, "commit")
bdDolt(t, bd, sourceDir, "remote", "add", "origin", remoteURL)
bdDolt(t, bd, sourceDir, "push", "--force")
cloneDir := t.TempDir()
initGitRepoAt(t, cloneDir)
gitBin, err := exec.LookPath("git")
if err != nil {
t.Fatalf("git not found: %v", err)
}
pathDir := filepath.Join(t.TempDir(), "path")
if err := os.MkdirAll(pathDir, 0o750); err != nil {
t.Fatal(err)
}
if err := os.Symlink(gitBin, filepath.Join(pathDir, "git")); err != nil {
t.Fatalf("symlink git into PATH: %v", err)
}
noDoltEnv := bdEnv(cloneDir)
replacedPath := false
for i, entry := range noDoltEnv {
if strings.HasPrefix(entry, "PATH=") {
noDoltEnv[i] = "PATH=" + pathDir
replacedPath = true
break
}
}
if !replacedPath {
noDoltEnv = append(noDoltEnv, "PATH="+pathDir)
}
cmd = exec.Command(bd, "init", "--quiet", "--prefix", "clone", "--remote", remoteURL, "--skip-hooks", "--skip-agents")
cmd.Dir = cloneDir
cmd.Env = noDoltEnv
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("bd init --remote without dolt CLI failed: %v\n%s", err, out)
}
cloneCfg, err := configfile.Load(filepath.Join(cloneDir, ".beads"))
if err != nil {
t.Fatalf("load clone metadata.json: %v", err)
}
if cloneCfg.ProjectID != sourceCfg.ProjectID {
t.Fatalf("clone ProjectID = %q, want source ProjectID %q", cloneCfg.ProjectID, sourceCfg.ProjectID)
}
if val := readBack(t, filepath.Join(cloneDir, ".beads"), "clone", "_project_id", true); val != sourceCfg.ProjectID {
t.Fatalf("clone database _project_id = %q, want source ProjectID %q", val, sourceCfg.ProjectID)
}
cmd = exec.Command(bd, "list")
cmd.Dir = cloneDir
cmd.Env = bdEnv(cloneDir)
stdout, stderr, err := runCommandBuffers(t, cmd)
if err != nil {
t.Fatalf("bd list failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String())
}
if !strings.Contains(stdout.String(), "Remote issue") {
t.Fatalf("cloned database missing remote issue:\n%s", stdout.String())
}
cloneBeadsDir := filepath.Join(cloneDir, ".beads")
out := bdDolt(t, bd, cloneDir, "remote", "list")
if !strings.Contains(out, "origin") || !strings.Contains(out, remoteURL) {
t.Fatalf("expected origin remote %q in remote list:\n%s", remoteURL, out)
}
configYAML, err := os.ReadFile(filepath.Join(cloneBeadsDir, "config.yaml"))
if err != nil {
t.Fatalf("read config.yaml: %v", err)
}
if !strings.Contains(string(configYAML), remoteURL) {
t.Fatalf("config.yaml should persist --remote URL %q:\n%s", remoteURL, configYAML)
}
})
t.Run("remote_empty_initializes_fresh_and_wires_origin", func(t *testing.T) {
remoteDir := filepath.Join(t.TempDir(), "empty-remote")
if err := os.MkdirAll(remoteDir, 0o750); err != nil {
t.Fatal(err)
}
remoteURL := "file://" + remoteDir
dir := t.TempDir()
initGitRepoAt(t, dir)
runBDInit(t, bd, dir, "--prefix", "fresh", "--remote", remoteURL, "--skip-hooks", "--skip-agents")
beadsDir := filepath.Join(dir, ".beads")
if val := readBack(t, beadsDir, "fresh", "issue_prefix", false); val != "fresh" {
t.Fatalf("fresh issue_prefix = %q, want %q", val, "fresh")
}
out := bdDolt(t, bd, dir, "remote", "list")
if !strings.Contains(out, "origin") || !strings.Contains(out, remoteURL) {
t.Fatalf("expected origin remote %q in remote list:\n%s", remoteURL, out)
}
configYAML, err := os.ReadFile(filepath.Join(beadsDir, "config.yaml"))
if err != nil {
t.Fatalf("read config.yaml: %v", err)
}
if !strings.Contains(string(configYAML), remoteURL) {
t.Fatalf("config.yaml should persist --remote URL %q:\n%s", remoteURL, configYAML)
}
})
t.Run("remote_clone_failure_emits_url_and_hint", func(t *testing.T) {
// remotesapi:// is rejected by dolt as an unknown scheme almost
// instantly, so this exercises the non-empty-remote clone failure
// path without depending on TCP timeouts. Verifies (a) init exits
// non-zero rather than silently bootstrapping fresh, (b) the wrap
// from cmd/bd/init.go echoes the URL the user typed in %q form,
// and (c) the Hint: line is present.
remoteURL := "remotesapi://127.0.0.1:1/no-such-db"
dir := t.TempDir()
initGitRepoAt(t, dir)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, bd, "init", "--quiet", "--prefix", "fail", "--remote", remoteURL, "--skip-hooks", "--skip-agents")
cmd.Dir = dir
cmd.Env = bdEnv(dir)
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatalf("expected bd init --remote with bogus URL to fail; got success:\n%s", out)
}
wantWrap := fmt.Sprintf("failed to clone remote %q", remoteURL)
if !strings.Contains(string(out), wantWrap) {
t.Fatalf("expected init.go wrap %q in output; got:\n%s", wantWrap, out)
}
if !strings.Contains(string(out), "Hint:") {
t.Fatalf("expected error output to include a Hint: about reachability/credentials; got:\n%s", out)
}
if _, statErr := os.Stat(filepath.Join(dir, ".beads", "config.yaml")); statErr == nil {
t.Fatalf(".beads/config.yaml should not exist after a failed clone; init must not silently fall through to fresh init")
}
})
t.Run("remote_http_url_preserved_verbatim", func(t *testing.T) {
// Explicit --remote http:// URL pointed at a refused TCP port:
// asserts the URL flows through to the clone call unchanged
// (no normalization to git+http://), per GH#3339. The 30s context
// caps gRPC dial backoff in case a CI runner ever stalls.
remoteURL := "http://127.0.0.1:1/no-such-db"
dir := t.TempDir()
initGitRepoAt(t, dir)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, bd, "init", "--quiet", "--prefix", "fail2", "--remote", remoteURL, "--skip-hooks", "--skip-agents")
cmd.Dir = dir
cmd.Env = bdEnv(dir)
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatalf("expected bd init --remote with unreachable http URL to fail; got success:\n%s", out)
}
// Match the %q-quoted form init.go writes ("http://...") so this
// can't accidentally pass against an output that contains the
// rewritten "git+http://..." substring.
wantWrap := fmt.Sprintf("failed to clone remote %q", remoteURL)
if !strings.Contains(string(out), wantWrap) {
t.Fatalf("expected init.go wrap %q in output (proves no git+http:// rewrite); got:\n%s", wantWrap, out)
}
if strings.Contains(string(out), "git+http://127.0.0.1:1") {
t.Fatalf("explicit --remote http:// must not be normalized to git+http://; got:\n%s", out)
}
})
t.Run("database", func(t *testing.T) {
_, beadsDir, _ := bdInit(t, bd, "--database", "custom_db")
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("failed to load metadata.json: %v", err)
}
if cfg.DoltDatabase != "custom_db" {
t.Errorf("DoltDatabase: got %q, want %q", cfg.DoltDatabase, "custom_db")
}
requireFile(t, filepath.Join(beadsDir, "embeddeddolt", "custom_db", ".dolt"))
if val := readBack(t, beadsDir, "custom_db", "issue_prefix", false); val == "" {
t.Error("issue_prefix not set in custom_db")
}
})
t.Run("database_with_prefix", func(t *testing.T) {
_, beadsDir, _ := bdInit(t, bd, "--database", "shared_db", "--prefix", "alpha")
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("failed to load metadata.json: %v", err)
}
if cfg.DoltDatabase != "shared_db" {
t.Errorf("DoltDatabase: got %q, want %q", cfg.DoltDatabase, "shared_db")
}
if val := readBack(t, beadsDir, "shared_db", "issue_prefix", false); val != "alpha" {
t.Errorf("issue_prefix: got %q, want %q", val, "alpha")
}
})
t.Run("skip_hooks", func(t *testing.T) {
_, beadsDir, _ := bdInit(t, bd, "--prefix", "sh", "--skip-hooks")
requireNoFile(t, filepath.Join(beadsDir, "hooks"))
})
t.Run("stealth", func(t *testing.T) {
dir, _, _ := bdInit(t, bd, "--prefix", "st", "--stealth")
requireNoFile(t, filepath.Join(dir, "AGENTS.md"))
})
t.Run("force_reinit", func(t *testing.T) {
doltBin, err := exec.LookPath("dolt")
if err != nil {
t.Skip("dolt CLI not on PATH")
}
dir, beadsDir, _ := bdInit(t, bd, "--prefix", "fi")
dbDir := filepath.Join(beadsDir, "embeddeddolt", "fi")
statusOut := runDolt(t, doltBin, dbDir, "status")
if !strings.Contains(statusOut, "nothing to commit") {
t.Errorf("after first init: expected clean working set, got:\n%s", statusOut)
}
logOut1 := runDolt(t, doltBin, dbDir, "log", "--oneline")
for _, want := range []string{"schema: apply migrations", "bd init"} {
if !strings.Contains(logOut1, want) {
t.Errorf("after first init: missing %q commit:\n%s", want, logOut1)
}
}
headAfterFirst := doltHeadHash(t, doltBin, dbDir)
t.Logf("HEAD after first init: %s", headAfterFirst)
t.Logf("log after first init:\n%s", logOut1)
// Second init with --force
runBDInit(t, bd, dir, "--prefix", "fi", "--force")
statusOut = runDolt(t, doltBin, dbDir, "status")
if !strings.Contains(statusOut, "nothing to commit") {
t.Errorf("after force reinit: expected clean working set, got:\n%s", statusOut)
}
logOut2 := runDolt(t, doltBin, dbDir, "log", "--oneline")
t.Logf("HEAD after force reinit: %s", doltHeadHash(t, doltBin, dbDir))
t.Logf("log after force reinit:\n%s", logOut2)
for _, want := range []string{"schema: apply migrations", "bd init"} {
if !strings.Contains(logOut2, want) {
t.Errorf("after force reinit: missing %q commit:\n%s", want, logOut2)
}
}
commitCount1 := strings.Count(strings.TrimSpace(logOut1), "\n") + 1
commitCount2 := strings.Count(strings.TrimSpace(logOut2), "\n") + 1
if commitCount2 < commitCount1 {
t.Errorf("commit count decreased after force reinit: before=%d after=%d", commitCount1, commitCount2)
}
if val := readBack(t, beadsDir, "fi", "issue_prefix", false); val != "fi" {
t.Errorf("issue_prefix after --force: got %q, want %q", val, "fi")
}
})
t.Run("setup_exclude", func(t *testing.T) {
dir, _, _ := bdInit(t, bd, "--prefix", "se", "--setup-exclude")
content, err := os.ReadFile(filepath.Join(dir, ".git", "info", "exclude"))
if err != nil {
t.Fatalf("failed to read .git/info/exclude: %v", err)
}
if !strings.Contains(string(content), ".beads") {
t.Error("--setup-exclude should add .beads to .git/info/exclude")
}
})
t.Run("auto_commit_bypasses_hooks", func(t *testing.T) {
dir := t.TempDir()
initGitRepoAt(t, dir)
preCommitPath := filepath.Join(dir, ".git", "hooks", "pre-commit")
preCommit := "#!/bin/sh\necho hook-fired >> .hook-ran\nexit 1\n"
if err := os.WriteFile(preCommitPath, []byte(preCommit), 0755); err != nil {
t.Fatal(err)
}
unsetHooksPath := exec.Command("git", "config", "--unset", "core.hooksPath")
unsetHooksPath.Dir = dir
if out, err := unsetHooksPath.CombinedOutput(); err != nil {
t.Fatalf("git config --unset core.hooksPath failed: %v\n%s", err, out)
}
runBDInit(t, bd, dir, "--prefix", "hook")
if _, err := os.Stat(filepath.Join(dir, ".hook-ran")); err == nil {
t.Fatal("expected init auto-commit to bypass git hooks")
}
logCmd := exec.Command("git", "log", "--oneline", "-n", "1")
logCmd.Dir = dir
stdout, stderr, err := runCommandBuffers(t, logCmd)
if err != nil {
t.Fatalf("git log failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String())
}
if !strings.Contains(stdout.String(), "bd init: initialize beads issue tracking") {
t.Fatalf("expected init commit to succeed, got log: %s", stdout.String())
}
})
t.Run("from_jsonl", func(t *testing.T) {
dir := t.TempDir()
initGitRepoAt(t, dir)
beadsDir := filepath.Join(dir, ".beads")
if err := os.MkdirAll(beadsDir, 0750); err != nil {
t.Fatal(err)
}
issues := []types.Issue{
{ID: "jl-abc123", Title: "One", Status: types.StatusOpen, Priority: 2, IssueType: types.TypeTask, CreatedAt: time.Now(), UpdatedAt: time.Now()},
{ID: "jl-def456", Title: "Two", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeBug, CreatedAt: time.Now(), UpdatedAt: time.Now()},
}
var lines []string
for _, issue := range issues {
b, _ := json.Marshal(issue)
lines = append(lines, string(b))
}
if err := os.WriteFile(filepath.Join(beadsDir, "issues.jsonl"), []byte(strings.Join(lines, "\n")+"\n"), 0644); err != nil {
t.Fatal(err)
}
preCommitPath := filepath.Join(dir, ".git", "hooks", "pre-commit")
preCommit := "#!/bin/sh\necho hook-fired >> .hook-ran\nexit 1\n"
if err := os.WriteFile(preCommitPath, []byte(preCommit), 0755); err != nil {
t.Fatal(err)
}
unsetHooksPath := exec.Command("git", "config", "--unset", "core.hooksPath")
unsetHooksPath.Dir = dir
if out, err := unsetHooksPath.CombinedOutput(); err != nil {
t.Fatalf("git config --unset core.hooksPath failed: %v\n%s", err, out)
}
cmd := exec.Command(bd, "init", "--prefix", "jl", "--from-jsonl", "--quiet")
cmd.Dir = dir
cmd.Env = bdEnv(dir)
stdout, stderr, err := runCommandBuffers(t, cmd)
if err != nil {
t.Fatalf("--from-jsonl should succeed now that CreateIssuesWithFullOptions is implemented: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String())
}
if _, err := os.Stat(filepath.Join(dir, ".hook-ran")); err == nil {
t.Fatal("expected --from-jsonl auto-commit to bypass git hooks")
}
logCmd := exec.Command("git", "log", "--oneline", "-n", "1")
logCmd.Dir = dir
stdout.Reset()
stderr.Reset()
logCmd.Stdout = &stdout
logCmd.Stderr = &stderr
if err := logCmd.Run(); err != nil {
t.Fatalf("git log failed: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String())
}
if !strings.Contains(stdout.String(), "bd init: initialize beads issue tracking") {
t.Fatalf("expected init commit to succeed, got log: %s", stdout.String())
}
})
t.Run("backend_dolt", func(t *testing.T) {
_, beadsDir, _ := bdInit(t, bd, "--prefix", "bdolt", "--backend", "dolt")
embeddedDir := filepath.Join(beadsDir, "embeddeddolt")
requireFile(t, embeddedDir)
requireFile(t, filepath.Join(embeddedDir, "bdolt", ".dolt"))
})
t.Run("rejected_backends", func(t *testing.T) {
for _, tc := range []struct {
backend, wantErr string
}{
{"sqlite", "DEPRECATED"},
{"postgres", "unknown backend"},
} {
out := bdInitFail(t, bd, "--backend", tc.backend)
if !strings.Contains(out, tc.wantErr) {
t.Errorf("--backend %s: expected %q, got: %s", tc.backend, tc.wantErr, out)
}
}
})
t.Run("server_flags_ignored", func(t *testing.T) {
_, beadsDir, _ := bdInit(t, bd, "--prefix", "sv",
"--server-host", "10.0.0.1", "--server-port", "4444", "--server-user", "alice")
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("failed to load metadata.json: %v", err)
}
if cfg.DoltServerHost != "10.0.0.1" {
t.Errorf("DoltServerHost: got %q, want %q", cfg.DoltServerHost, "10.0.0.1")
}
if cfg.DoltServerPort != 4444 {
t.Errorf("DoltServerPort: got %d, want %d", cfg.DoltServerPort, 4444)
}
if cfg.DoltServerUser != "alice" {
t.Errorf("DoltServerUser: got %q, want %q", cfg.DoltServerUser, "alice")
}
})
t.Run("metadata_written", func(t *testing.T) {
_, beadsDir, _ := bdInit(t, bd, "--prefix", "meta")
// bd_version is in local_metadata (dolt-ignored), not metadata
func() {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
store, err := embeddeddolt.Open(ctx, beadsDir, "meta", "main")
if err != nil {
t.Fatalf("failed to open store for bd_version check: %v", err)
}
defer store.Close()
if val, err := store.GetLocalMetadata(ctx, "bd_version"); err != nil || val == "" {
t.Error("bd_version local metadata not set")
}
}()
importTime := readBack(t, beadsDir, "meta", "last_import_time", true)
if importTime == "" {
t.Error("last_import_time metadata not set")
}
if _, err := time.Parse(time.RFC3339, importTime); err != nil {
t.Errorf("last_import_time not valid RFC3339: %q", importTime)
}
})
t.Run("metadata_json", func(t *testing.T) {
_, beadsDir, _ := bdInit(t, bd, "--prefix", "mj")
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("failed to load metadata.json: %v", err)
}
if cfg.Backend != configfile.BackendDolt {
t.Errorf("Backend: got %q, want %q", cfg.Backend, configfile.BackendDolt)
}
if cfg.ProjectID == "" {
t.Error("ProjectID should be set")
}
})
t.Run("files_created", func(t *testing.T) {
dir, beadsDir, _ := bdInit(t, bd, "--prefix", "fc", "--skip-hooks")
requireFile(t, filepath.Join(beadsDir, "config.yaml"))
requireFile(t, filepath.Join(beadsDir, "interactions.jsonl"))
requireFile(t, filepath.Join(dir, "AGENTS.md"))
content, err := os.ReadFile(filepath.Join(beadsDir, ".gitignore"))
if err != nil {
t.Fatalf("failed to read .beads/.gitignore: %v", err)
}
for _, pattern := range []string{"*.db", "dolt/", "bd.sock"} {
if !strings.Contains(string(content), pattern) {
t.Errorf(".gitignore missing pattern: %s", pattern)
}
}
})
t.Run("agents_template", func(t *testing.T) {
dir := t.TempDir()
initGitRepoAt(t, dir)
templatePath := filepath.Join(dir, "custom-agents.md")
if err := os.WriteFile(templatePath, []byte("# Custom Agents\nThis is custom.\n"), 0644); err != nil {
t.Fatal(err)
}
runBDInit(t, bd, dir, "--prefix", "at", "--agents-template", templatePath, "--skip-hooks")
content, err := os.ReadFile(filepath.Join(dir, "AGENTS.md"))
if err != nil {
t.Fatalf("failed to read AGENTS.md: %v", err)
}
if !strings.Contains(string(content), "Custom Agents") {
t.Error("AGENTS.md should contain custom template content")
}
})
t.Run("no_git_repo", func(t *testing.T) {
dir := t.TempDir()
// Don't init git — bd init should create one
args := []string{"init", "--prefix", "ng", "--quiet"}
cmd := exec.Command(bd, args...)
cmd.Dir = dir
cmd.Env = bdEnv(dir)
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("bd init (no git) failed: %v\n%s", err, out)
}
requireFile(t, filepath.Join(dir, ".git"))
})
t.Run("database_name_validation", func(t *testing.T) {
out := bdInitFail(t, bd, "--database", "has spaces!")
if !strings.Contains(out, "invalid database name") {
t.Errorf("expected 'invalid database name' error, got: %s", out)
}
})
t.Run("prefix_auto_detect_from_dirname", func(t *testing.T) {
parent := t.TempDir()
dir := filepath.Join(parent, "myproject")
if err := os.MkdirAll(dir, 0750); err != nil {
t.Fatal(err)
}
initGitRepoAt(t, dir)
runBDInit(t, bd, dir)
if val := readBack(t, filepath.Join(dir, ".beads"), "myproject", "issue_prefix", false); val != "myproject" {
t.Errorf("auto-detected issue_prefix: got %q, want %q", val, "myproject")
}
})
t.Run("auto_detect_dotted_dirname", func(t *testing.T) {
// bd init in a directory named like "MyPkg.jl" (common in Julia repos)
// must sanitize the dot when auto-detecting the prefix: metadata.json
// DoltDatabase must match the actual Dolt database name so that reopens
// succeed and bd list works immediately after init.
parent := t.TempDir()
dir := filepath.Join(parent, "MyPkg.jl")
if err := os.MkdirAll(dir, 0750); err != nil {
t.Fatal(err)
}
initGitRepoAt(t, dir)
runBDInit(t, bd, dir)
beadsDir := filepath.Join(dir, ".beads")
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("failed to load metadata.json: %v", err)
}
const want = "MyPkg_jl"
if cfg.DoltDatabase != want {
t.Errorf("DoltDatabase: got %q, want %q (dot must be sanitized)", cfg.DoltDatabase, want)
}
if val := readBack(t, beadsDir, want, "issue_prefix", false); val != want {
t.Errorf("issue_prefix: got %q, want %q", val, want)
}
// Verify bd list succeeds — confirms the database name in metadata.json
// matches the actual Dolt database created during init.
listCmd := exec.Command(bd, "list", "--json")
listCmd.Dir = dir
listCmd.Env = bdEnv(dir)
if out, err := listCmd.CombinedOutput(); err != nil {
t.Fatalf("bd list failed after init in dotted dirname: %v\n%s", err, out)
}
})
t.Run("prefix_numeric_sanitized", func(t *testing.T) {
parent := t.TempDir()
dir := filepath.Join(parent, "001")
if err := os.MkdirAll(dir, 0750); err != nil {
t.Fatal(err)
}
initGitRepoAt(t, dir)
runBDInit(t, bd, dir)
if val := readBack(t, filepath.Join(dir, ".beads"), "bd_001", "issue_prefix", false); val != "bd_001" {
t.Errorf("sanitized issue_prefix: got %q, want %q", val, "bd_001")
}
})
t.Run("invalid_dirname_errors_early", func(t *testing.T) {
// A directory name like "my project" (space) survives hyphen/dot sanitization
// and produces an invalid Dolt database name. The init command should exit
// non-zero with a human-readable error rather than a cryptic storage failure.
parent := t.TempDir()
dir := filepath.Join(parent, "my project")
if err := os.MkdirAll(dir, 0750); err != nil {
t.Fatal(err)
}
initGitRepoAt(t, dir)
cmd := exec.Command(bd, "init", "--quiet")
cmd.Dir = dir
cmd.Env = bdEnv(dir)
out, err := cmd.CombinedOutput()
if err == nil {
t.Fatal("bd init should have failed for directory with invalid name")
}
outStr := string(out)
if !strings.Contains(outStr, "invalid database name") && !strings.Contains(outStr, "produces an invalid") {
t.Errorf("expected actionable error message, got: %s", outStr)
}
})
t.Run("prefix_dot_sanitized", func(t *testing.T) {
// A Julia package repo like GPUPolynomials.jl passes --prefix GPUPolynomials.jl.
// The dot must be replaced with underscore in both the Dolt database name and
// metadata.json DoltDatabase, otherwise reopens fail with a name mismatch.
_, beadsDir, _ := bdInit(t, bd, "--prefix", "GPUPolynomials.jl")
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("failed to load metadata.json: %v", err)
}
const want = "GPUPolynomials_jl"
if cfg.DoltDatabase != want {
t.Errorf("DoltDatabase: got %q, want %q", cfg.DoltDatabase, want)
}
if val := readBack(t, beadsDir, want, "issue_prefix", false); val != "GPUPolynomials_jl" {
t.Errorf("issue_prefix: got %q, want %q", val, "GPUPolynomials_jl")
}
})
t.Run("config_dot_prefix_sanitized", func(t *testing.T) {
dir := t.TempDir()
initGitRepoAt(t, dir)
beadsDir := filepath.Join(dir, ".beads")
if err := os.MkdirAll(beadsDir, 0o750); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("issue-prefix: GPUPolynomials.jl\n"), 0o644); err != nil {
t.Fatal(err)
}
runBDInit(t, bd, dir)
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("failed to load metadata.json: %v", err)
}
const want = "GPUPolynomials_jl"
if cfg.DoltDatabase != want {
t.Errorf("DoltDatabase: got %q, want %q", cfg.DoltDatabase, want)
}
if val := readBack(t, beadsDir, want, "issue_prefix", false); val != want {
t.Errorf("issue_prefix: got %q, want %q", val, want)
}
})
}
// TestEmbeddedInitConcurrent verifies the exclusive flock prevents concurrent
// writers. Exactly one process should succeed; the rest get the lock error.
func TestEmbeddedInitConcurrent(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt init tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
dir := t.TempDir()
initGitRepoAt(t, dir)
const N = 10
env := bdEnv(dir)
type result struct {
idx int
out string
err error
timedOut bool
}
results := make([]result, N)
var wg sync.WaitGroup
wg.Add(N)
for i := 0; i < N; i++ {
go func(idx int) {
defer wg.Done()
ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, bd, "init", "--prefix", "conc", "--force", "--quiet", "--skip-agents")
cmd.Dir = dir
cmd.Env = env
out, err := cmd.CombinedOutput()
results[idx] = result{idx: idx, out: string(out), err: err, timedOut: ctx.Err() == context.DeadlineExceeded}
}(i)
}
wg.Wait()
successes, lockErrors := 0, 0
for _, r := range results {
if r.timedOut {
t.Errorf("process %d timed out after 45s running concurrent bd init: %v\n%s", r.idx, r.err, r.out)
continue
}
if strings.Contains(r.out, "panic") {
t.Errorf("process %d panicked:\n%s", r.idx, r.out)
}
if r.err == nil {
successes++
} else if isEmbeddedLockOutput(r.out) {
lockErrors++
} else {
t.Errorf("process %d failed with unexpected error: %v\n%s", r.idx, r.err, r.out)
}
}
if successes < 1 {
t.Errorf("expected at least 1 success, got %d", successes)
}
if successes+lockErrors != N {
t.Errorf("expected successes (%d) + lock errors (%d) = %d, got %d", successes, lockErrors, N, successes+lockErrors)
}
t.Logf("%d/%d succeeded, %d/%d got lock error", successes, N, lockErrors, N)
beadsDir := filepath.Join(dir, ".beads")
embeddedDir := filepath.Join(beadsDir, "embeddeddolt")
requireFile(t, embeddedDir)
requireFile(t, filepath.Join(embeddedDir, "conc", ".dolt"))
if val := readBack(t, beadsDir, "conc", "issue_prefix", false); val != "conc" {
t.Errorf("issue_prefix: got %q, want %q", val, "conc")
}
cfg, err := configfile.Load(beadsDir)
if err != nil {
t.Fatalf("failed to load metadata.json: %v", err)
}
if cfg.Backend != configfile.BackendDolt {
t.Errorf("Backend: got %q, want %q", cfg.Backend, configfile.BackendDolt)
}
if doltBin, err := exec.LookPath("dolt"); err == nil {
dbDir := filepath.Join(embeddedDir, "conc")
statusOut := runDolt(t, doltBin, dbDir, "status")
if !strings.Contains(statusOut, "nothing to commit") {
t.Errorf("expected clean working set after concurrent init, got:\n%s", statusOut)
}
logOut := runDolt(t, doltBin, dbDir, "log", "--oneline")
if !strings.Contains(logOut, "schema: apply migrations") {
t.Errorf("missing 'schema: apply migrations' commit:\n%s", logOut)
}
}
}