b3ebedb063
When running bd init in a subdirectory of a hub (e.g., ~/Repos/project where ~/Repos/.beads exists), the new database was incorrectly inheriting issues from the parent hub. Root cause: checkGitForIssues() computed the relative path from gitRoot to beadsDir but did not validate that beadsDir was actually inside the git repository. When beadsDir was outside (e.g., ../.beads), it would still attempt to import, causing contamination. Fix: Add a guard to reject beadsDir paths that start with .. (outside the git repository boundary). 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
562 lines
15 KiB
Go
562 lines
15 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/steveyegge/beads/internal/beads"
|
|
"github.com/steveyegge/beads/internal/git"
|
|
"github.com/steveyegge/beads/internal/storage/sqlite"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
)
|
|
|
|
func TestCheckAndAutoImport_NoAutoImportFlag(t *testing.T) {
|
|
ctx := context.Background()
|
|
tmpDB := t.TempDir() + "/test.db"
|
|
store, err := sqlite.New(context.Background(), tmpDB)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create store: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
// Set the global flag
|
|
oldNoAutoImport := noAutoImport
|
|
noAutoImport = true
|
|
defer func() { noAutoImport = oldNoAutoImport }()
|
|
|
|
result := checkAndAutoImport(ctx, store)
|
|
if result {
|
|
t.Error("Expected auto-import to be disabled when noAutoImport is true")
|
|
}
|
|
}
|
|
|
|
func TestAutoImportIfNewer_NoAutoImportFlag(t *testing.T) {
|
|
// Test that autoImportIfNewer() respects noAutoImport flag directly (bd-4t7 fix)
|
|
ctx := context.Background()
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create beads dir: %v", err)
|
|
}
|
|
|
|
testDBPath := filepath.Join(beadsDir, "bd.db")
|
|
jsonlPath := filepath.Join(beadsDir, "issues.jsonl")
|
|
|
|
// Create database
|
|
testStore, err := sqlite.New(ctx, testDBPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create store: %v", err)
|
|
}
|
|
defer testStore.Close()
|
|
|
|
// Set prefix
|
|
if err := testStore.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("Failed to set prefix: %v", err)
|
|
}
|
|
|
|
// Create JSONL with an issue that should NOT be imported
|
|
jsonlIssue := &types.Issue{
|
|
ID: "test-noimport-bd4t7",
|
|
Title: "Should Not Import",
|
|
Status: types.StatusOpen,
|
|
Priority: 1,
|
|
IssueType: types.TypeTask,
|
|
}
|
|
f, err := os.Create(jsonlPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create JSONL: %v", err)
|
|
}
|
|
encoder := json.NewEncoder(f)
|
|
if err := encoder.Encode(jsonlIssue); err != nil {
|
|
t.Fatalf("Failed to encode issue: %v", err)
|
|
}
|
|
f.Close()
|
|
|
|
// Save and set global state
|
|
oldNoAutoImport := noAutoImport
|
|
oldAutoImportEnabled := autoImportEnabled
|
|
oldStore := store
|
|
oldDbPath := dbPath
|
|
oldRootCtx := rootCtx
|
|
oldStoreActive := storeActive
|
|
|
|
noAutoImport = true
|
|
autoImportEnabled = false // Also set this for consistency
|
|
store = testStore
|
|
dbPath = testDBPath
|
|
rootCtx = ctx
|
|
storeActive = true
|
|
|
|
defer func() {
|
|
noAutoImport = oldNoAutoImport
|
|
autoImportEnabled = oldAutoImportEnabled
|
|
store = oldStore
|
|
dbPath = oldDbPath
|
|
rootCtx = oldRootCtx
|
|
storeActive = oldStoreActive
|
|
}()
|
|
|
|
// Call autoImportIfNewer directly - should be blocked by noAutoImport check
|
|
autoImportIfNewer()
|
|
|
|
// Verify issue was NOT imported
|
|
imported, err := testStore.GetIssue(ctx, "test-noimport-bd4t7")
|
|
if err != nil {
|
|
t.Fatalf("Failed to check for issue: %v", err)
|
|
}
|
|
if imported != nil {
|
|
t.Error("autoImportIfNewer() imported despite noAutoImport=true - bd-4t7 fix failed")
|
|
}
|
|
}
|
|
|
|
func TestCheckAndAutoImport_DatabaseHasIssues(t *testing.T) {
|
|
ctx := context.Background()
|
|
tmpDB := t.TempDir() + "/test.db"
|
|
store, err := sqlite.New(context.Background(), tmpDB)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create store: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
// Set prefix
|
|
if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("Failed to set prefix: %v", err)
|
|
}
|
|
|
|
// Create an issue
|
|
issue := &types.Issue{
|
|
ID: "test-123",
|
|
Title: "Test",
|
|
Description: "Test description",
|
|
Status: types.StatusOpen,
|
|
Priority: 1,
|
|
IssueType: types.TypeTask,
|
|
}
|
|
if err := store.CreateIssue(ctx, issue, "test"); err != nil {
|
|
t.Fatalf("Failed to create issue: %v", err)
|
|
}
|
|
|
|
oldNoAutoImport := noAutoImport
|
|
noAutoImport = false
|
|
defer func() { noAutoImport = oldNoAutoImport }()
|
|
|
|
result := checkAndAutoImport(ctx, store)
|
|
if result {
|
|
t.Error("Expected auto-import to skip when database has issues")
|
|
}
|
|
}
|
|
|
|
func TestCheckAndAutoImport_EmptyDatabaseNoGit(t *testing.T) {
|
|
ctx := context.Background()
|
|
tmpDir := t.TempDir()
|
|
tmpDB := filepath.Join(tmpDir, "test.db")
|
|
store, err := sqlite.New(context.Background(), tmpDB)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create store: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
// Set prefix
|
|
if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("Failed to set prefix: %v", err)
|
|
}
|
|
|
|
oldNoAutoImport := noAutoImport
|
|
oldJsonOutput := jsonOutput
|
|
noAutoImport = false
|
|
jsonOutput = true // Suppress output
|
|
defer func() {
|
|
noAutoImport = oldNoAutoImport
|
|
jsonOutput = oldJsonOutput
|
|
}()
|
|
|
|
// Change to temp dir (no git repo)
|
|
t.Chdir(tmpDir)
|
|
|
|
result := checkAndAutoImport(ctx, store)
|
|
if result {
|
|
t.Error("Expected auto-import to skip when no git repo")
|
|
}
|
|
}
|
|
|
|
func TestFindBeadsDir(t *testing.T) {
|
|
// Create temp directory with .beads and a valid project file
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create .beads dir: %v", err)
|
|
}
|
|
// Create a config.yaml so beads.FindBeadsDir() recognizes this as a valid project
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("prefix: test\n"), 0600); err != nil {
|
|
t.Fatalf("Failed to create config.yaml: %v", err)
|
|
}
|
|
|
|
// Change to tmpDir
|
|
t.Chdir(tmpDir)
|
|
|
|
found := beads.FindBeadsDir()
|
|
if found == "" {
|
|
t.Error("Expected to find .beads directory")
|
|
}
|
|
// Use EvalSymlinks to handle /var vs /private/var on macOS
|
|
expectedPath, _ := filepath.EvalSymlinks(beadsDir)
|
|
foundPath, _ := filepath.EvalSymlinks(found)
|
|
if foundPath != expectedPath {
|
|
t.Errorf("Expected %s, got %s", expectedPath, foundPath)
|
|
}
|
|
}
|
|
|
|
func TestFindBeadsDir_NotFound(t *testing.T) {
|
|
// Create temp directory without .beads
|
|
tmpDir := t.TempDir()
|
|
|
|
t.Chdir(tmpDir)
|
|
|
|
found := beads.FindBeadsDir()
|
|
// findBeadsDir walks up to root, so it might find .beads in parent dirs
|
|
// (e.g., user's home directory). Just verify it's not in tmpDir itself.
|
|
if found != "" && filepath.Dir(found) == tmpDir {
|
|
t.Errorf("Expected not to find .beads in tmpDir, but got %s", found)
|
|
}
|
|
}
|
|
|
|
func TestFindBeadsDir_ParentDirectory(t *testing.T) {
|
|
// Create structure: tmpDir/.beads and tmpDir/subdir
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create .beads dir: %v", err)
|
|
}
|
|
// Create a config.yaml so beads.FindBeadsDir() recognizes this as a valid project
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("prefix: test\n"), 0600); err != nil {
|
|
t.Fatalf("Failed to create config.yaml: %v", err)
|
|
}
|
|
|
|
subDir := filepath.Join(tmpDir, "subdir")
|
|
if err := os.MkdirAll(subDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create subdir: %v", err)
|
|
}
|
|
|
|
// Change to subdir
|
|
t.Chdir(subDir)
|
|
|
|
found := beads.FindBeadsDir()
|
|
if found == "" {
|
|
t.Error("Expected to find .beads directory in parent")
|
|
}
|
|
// Use EvalSymlinks to handle /var vs /private/var on macOS
|
|
expectedPath, _ := filepath.EvalSymlinks(beadsDir)
|
|
foundPath, _ := filepath.EvalSymlinks(found)
|
|
if foundPath != expectedPath {
|
|
t.Errorf("Expected %s, got %s", expectedPath, foundPath)
|
|
}
|
|
}
|
|
|
|
func TestCheckGitForIssues_NoGitRepo(t *testing.T) {
|
|
// Change to temp dir (not a git repo)
|
|
tmpDir := t.TempDir()
|
|
t.Chdir(tmpDir)
|
|
|
|
count, path, gitRef := checkGitForIssues()
|
|
if count != 0 {
|
|
t.Errorf("Expected 0 issues, got %d", count)
|
|
}
|
|
if path != "" {
|
|
t.Errorf("Expected empty path, got %s", path)
|
|
}
|
|
if gitRef != "" {
|
|
t.Errorf("Expected empty gitRef, got %s", gitRef)
|
|
}
|
|
}
|
|
|
|
func TestCheckGitForIssues_NoBeadsDir(t *testing.T) {
|
|
// Use current directory which has git but change to somewhere without .beads
|
|
tmpDir := t.TempDir()
|
|
t.Chdir(tmpDir)
|
|
|
|
count, path, _ := checkGitForIssues()
|
|
if count != 0 || path != "" {
|
|
t.Logf("No .beads dir: count=%d, path=%s (expected 0, empty)", count, path)
|
|
}
|
|
}
|
|
|
|
// TestCheckGitForIssues_ParentHubNotInherited tests the GH#896 fix: when running
|
|
// bd init in a subdirectory of a hub, the parent hub's .beads should NOT be used
|
|
// for importing issues. This prevents contamination from parent hub issues.
|
|
func TestCheckGitForIssues_ParentHubNotInherited(t *testing.T) {
|
|
// Create a structure simulating the bug scenario:
|
|
// tmpDir/
|
|
// .beads/ <- parent hub (NOT a git repo)
|
|
// issues.jsonl
|
|
// config.yaml
|
|
// newproject/ <- new project (IS a git repo)
|
|
// .git/
|
|
tmpDir := t.TempDir()
|
|
|
|
// Create parent hub's .beads with issues
|
|
parentBeadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(parentBeadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create parent .beads: %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(parentBeadsDir, "config.yaml"), []byte("prefix: hub\n"), 0644); err != nil {
|
|
t.Fatalf("Failed to create parent config.yaml: %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(parentBeadsDir, "issues.jsonl"), []byte(`{"id":"hub-001","title":"Parent Issue"}`+"\n"), 0644); err != nil {
|
|
t.Fatalf("Failed to create parent issues.jsonl: %v", err)
|
|
}
|
|
|
|
// Create newproject as a git repo
|
|
newProject := filepath.Join(tmpDir, "newproject")
|
|
if err := os.MkdirAll(newProject, 0755); err != nil {
|
|
t.Fatalf("Failed to create newproject: %v", err)
|
|
}
|
|
|
|
// Initialize git repo in newproject
|
|
t.Chdir(newProject)
|
|
cmd := exec.Command("git", "init")
|
|
if err := cmd.Run(); err != nil {
|
|
t.Fatalf("Failed to git init: %v", err)
|
|
}
|
|
|
|
// Reset git context cache (important for test isolation)
|
|
git.ResetCaches()
|
|
|
|
// Now checkGitForIssues should NOT find the parent hub's issues
|
|
// because the parent .beads is outside the git root (newproject)
|
|
count, path, _ := checkGitForIssues()
|
|
|
|
if count != 0 {
|
|
t.Errorf("GH#896: checkGitForIssues found %d issues from parent hub (should be 0)", count)
|
|
}
|
|
if path != "" {
|
|
t.Errorf("GH#896: checkGitForIssues returned path %q (should be empty)", path)
|
|
}
|
|
}
|
|
|
|
func TestBoolToFlag(t *testing.T) {
|
|
t.Parallel()
|
|
tests := []struct {
|
|
name string
|
|
condition bool
|
|
flag string
|
|
want string
|
|
}{
|
|
{"true condition", true, "--verbose", "--verbose"},
|
|
{"false condition", false, "--verbose", ""},
|
|
{"true with empty flag", true, "", ""},
|
|
{"false with flag", false, "--debug", ""},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt // capture range variable
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
got := boolToFlag(tt.condition, tt.flag)
|
|
if got != tt.want {
|
|
t.Errorf("boolToFlag(%v, %q) = %q, want %q", tt.condition, tt.flag, got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIsNoDbModeConfigured(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
configYAML string
|
|
createFile bool
|
|
want bool
|
|
}{
|
|
{
|
|
name: "no config.yaml exists",
|
|
createFile: false,
|
|
want: false,
|
|
},
|
|
{
|
|
name: "config.yaml without no-db key",
|
|
configYAML: "issue-prefix: test\nauthor: testuser\n",
|
|
createFile: true,
|
|
want: false,
|
|
},
|
|
{
|
|
name: "no-db: true",
|
|
configYAML: "no-db: true\n",
|
|
createFile: true,
|
|
want: true,
|
|
},
|
|
{
|
|
name: "no-db: false",
|
|
configYAML: "no-db: false\n",
|
|
createFile: true,
|
|
want: false,
|
|
},
|
|
{
|
|
name: "no-db in comment should not match",
|
|
configYAML: "# no-db: true\nissue-prefix: test\n",
|
|
createFile: true,
|
|
want: false,
|
|
},
|
|
{
|
|
name: "no-db nested under section should not match",
|
|
configYAML: "settings:\n no-db: true\n",
|
|
createFile: true,
|
|
want: false,
|
|
},
|
|
{
|
|
name: "no-db with other config",
|
|
configYAML: "issue-prefix: bd\nno-db: true\nauthor: steve\n",
|
|
createFile: true,
|
|
want: true,
|
|
},
|
|
{
|
|
name: "empty file",
|
|
configYAML: "",
|
|
createFile: true,
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create beads dir: %v", err)
|
|
}
|
|
|
|
if tt.createFile {
|
|
configPath := filepath.Join(beadsDir, "config.yaml")
|
|
if err := os.WriteFile(configPath, []byte(tt.configYAML), 0644); err != nil {
|
|
t.Fatalf("Failed to write config.yaml: %v", err)
|
|
}
|
|
}
|
|
|
|
got := isNoDbModeConfigured(beadsDir)
|
|
if got != tt.want {
|
|
t.Errorf("isNoDbModeConfigured() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetLocalSyncBranch(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
configYAML string
|
|
envVar string
|
|
want string
|
|
createFile bool
|
|
}{
|
|
{
|
|
name: "no config.yaml exists",
|
|
createFile: false,
|
|
want: "",
|
|
},
|
|
{
|
|
name: "config.yaml has no sync-branch key",
|
|
configYAML: "issue-prefix: test\nauthor: testuser\n",
|
|
createFile: true,
|
|
want: "",
|
|
},
|
|
{
|
|
name: "sync-branch without quotes",
|
|
configYAML: "sync-branch: my-branch\n",
|
|
createFile: true,
|
|
want: "my-branch",
|
|
},
|
|
{
|
|
name: "sync-branch with double quotes",
|
|
configYAML: `sync-branch: "my-quoted-branch"` + "\n",
|
|
createFile: true,
|
|
want: "my-quoted-branch",
|
|
},
|
|
{
|
|
name: "sync-branch with single quotes",
|
|
configYAML: `sync-branch: 'single-quoted'` + "\n",
|
|
createFile: true,
|
|
want: "single-quoted",
|
|
},
|
|
{
|
|
name: "env var takes precedence",
|
|
configYAML: "sync-branch: config-branch\n",
|
|
createFile: true,
|
|
envVar: "env-branch",
|
|
want: "env-branch",
|
|
},
|
|
{
|
|
name: "empty file",
|
|
configYAML: "",
|
|
createFile: true,
|
|
want: "",
|
|
},
|
|
{
|
|
name: "whitespace-only lines",
|
|
configYAML: " \n\t\n \n",
|
|
createFile: true,
|
|
want: "",
|
|
},
|
|
{
|
|
name: "sync-branch after comments",
|
|
configYAML: "# This is a comment\n# sync-branch: fake\nsync-branch: real-branch\n",
|
|
createFile: true,
|
|
want: "real-branch",
|
|
},
|
|
{
|
|
name: "sync-branch with trailing comment",
|
|
configYAML: "sync-branch: branch-name # inline comment not valid YAML but test it\n",
|
|
createFile: true,
|
|
want: "branch-name",
|
|
},
|
|
{
|
|
name: "sync-branch with special characters",
|
|
configYAML: "sync-branch: feature/my-branch_v2.0\n",
|
|
createFile: true,
|
|
want: "feature/my-branch_v2.0",
|
|
},
|
|
{
|
|
name: "sync-branch indented under section (not top-level)",
|
|
configYAML: "settings:\n sync-branch: nested-branch\n",
|
|
createFile: true,
|
|
want: "", // Only top-level sync-branch should be read
|
|
},
|
|
{
|
|
name: "mixed config with sync-branch",
|
|
configYAML: "issue-prefix: bd\nauthor: steve\nsync-branch: beads-sync\npriority: P2\n",
|
|
createFile: true,
|
|
want: "beads-sync",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Create temp beads directory
|
|
tmpDir := t.TempDir()
|
|
beadsDir := filepath.Join(tmpDir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create beads dir: %v", err)
|
|
}
|
|
|
|
// Create config.yaml if needed
|
|
if tt.createFile {
|
|
configPath := filepath.Join(beadsDir, "config.yaml")
|
|
if err := os.WriteFile(configPath, []byte(tt.configYAML), 0644); err != nil {
|
|
t.Fatalf("Failed to write config.yaml: %v", err)
|
|
}
|
|
}
|
|
|
|
// Set env var if specified
|
|
if tt.envVar != "" {
|
|
t.Setenv("BEADS_SYNC_BRANCH", tt.envVar)
|
|
}
|
|
|
|
got := getLocalSyncBranch(beadsDir)
|
|
if got != tt.want {
|
|
t.Errorf("getLocalSyncBranch() = %q, want %q", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|