e110632afc
Follow-up to #1102 - migrates remaining git command locations to use RepoContext API for correct repo resolution when BEADS_DIR is set. Files migrated: - sync_branch.go: getCurrentBranch, showSyncStatus, mergeSyncBranch - sync_check.go: checkForcedPush - sync_import.go: doSyncFromMain - autoimport.go: readFromGitRef, checkGitForIssues - status.go: getGitActivity - import.go: attemptAutoMerge (gitRoot lookup) - reinit_test.go: add ResetCaches for test isolation Pattern used throughout: - Try RepoContext first: rc.GitCmd() runs in beads repo - Fallback to CWD for tests or repos without beads - Graceful degradation maintains backwards compatibility
484 lines
14 KiB
Go
484 lines
14 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"runtime"
|
|
"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"
|
|
)
|
|
|
|
// TestDatabaseReinitialization tests all database reinitialization scenarios
|
|
// covered in DATABASE_REINIT_BUG.md
|
|
func TestDatabaseReinitialization(t *testing.T) {
|
|
// Skip on Windows due to git hook autoimport flakiness
|
|
if runtime.GOOS == "windows" {
|
|
t.Skip("Skipping on Windows: git hook autoimport is flaky in CI")
|
|
}
|
|
|
|
// Skip in Nix build environment where git isn't available
|
|
if os.Getenv("NIX_BUILD_TOP") != "" {
|
|
t.Skip("Skipping test in Nix build environment (git not available)")
|
|
}
|
|
|
|
// Check if git is available
|
|
if _, err := exec.LookPath("git"); err != nil {
|
|
t.Skip("git not available in PATH, skipping test")
|
|
}
|
|
|
|
t.Run("fresh_clone_auto_import", testFreshCloneAutoImport)
|
|
t.Run("database_removal_scenario", testDatabaseRemovalScenario)
|
|
t.Run("legacy_filename_support", testLegacyFilenameSupport)
|
|
t.Run("precedence_test", testPrecedenceTest)
|
|
t.Run("init_safety_check", testInitSafetyCheck)
|
|
}
|
|
|
|
// testFreshCloneAutoImport verifies auto-import works on fresh clone
|
|
func testFreshCloneAutoImport(t *testing.T) {
|
|
beads.ResetCaches() // Reset cached RepoContext between subtests
|
|
dir := t.TempDir()
|
|
|
|
// Initialize git repo
|
|
runCmd(t, dir, "git", "init")
|
|
runCmd(t, dir, "git", "config", "user.email", "test@example.com")
|
|
runCmd(t, dir, "git", "config", "user.name", "Test User")
|
|
|
|
// Create .beads directory with issues.jsonl (canonical name)
|
|
beadsDir := filepath.Join(dir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create .beads dir: %v", err)
|
|
}
|
|
|
|
// Create test issue data
|
|
issue := &types.Issue{
|
|
ID: "test-1",
|
|
Title: "Test issue",
|
|
Description: "Test description",
|
|
Status: types.StatusOpen,
|
|
Priority: 2,
|
|
IssueType: types.TypeTask,
|
|
}
|
|
|
|
jsonlPath := filepath.Join(beadsDir, "issues.jsonl")
|
|
if err := writeJSONL(jsonlPath, []*types.Issue{issue}); err != nil {
|
|
t.Fatalf("Failed to write JSONL: %v", err)
|
|
}
|
|
|
|
// Commit to git (use forward slashes for git path)
|
|
runCmd(t, dir, "git", "add", ".beads/issues.jsonl")
|
|
runCmd(t, dir, "git", "commit", "-m", "Initial commit")
|
|
|
|
// Remove database to simulate fresh clone
|
|
dbPath := filepath.Join(beadsDir, "test.db")
|
|
os.Remove(dbPath)
|
|
|
|
// Run bd init with auto-import disabled to test checkGitForIssues
|
|
store, err := sqlite.New(context.Background(), dbPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create database: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
ctx := context.Background()
|
|
if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("Failed to set prefix: %v", err)
|
|
}
|
|
|
|
// Test checkGitForIssues detects issues.jsonl
|
|
t.Chdir(dir)
|
|
|
|
git.ResetCaches() // Reset git caches after changing directory
|
|
|
|
git.ResetCaches()
|
|
|
|
|
|
count, path, gitRef := checkGitForIssues()
|
|
if count != 1 {
|
|
t.Errorf("Expected 1 issue in git, got %d", count)
|
|
}
|
|
// Normalize path for comparison (handle both forward and backslash)
|
|
expectedPath := normalizeGitPath(".beads/issues.jsonl")
|
|
if normalizeGitPath(path) != expectedPath {
|
|
t.Errorf("Expected path %s, got %s", expectedPath, path)
|
|
}
|
|
|
|
// Import from git
|
|
if err := importFromGit(ctx, dbPath, store, path, gitRef); err != nil {
|
|
t.Fatalf("Import failed: %v", err)
|
|
}
|
|
|
|
// Verify issue was imported
|
|
stats, err := store.GetStatistics(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Failed to get stats: %v", err)
|
|
}
|
|
if stats.TotalIssues != 1 {
|
|
t.Errorf("Expected 1 issue after import, got %d", stats.TotalIssues)
|
|
}
|
|
}
|
|
|
|
// testDatabaseRemovalScenario tests the primary bug scenario
|
|
func testDatabaseRemovalScenario(t *testing.T) {
|
|
beads.ResetCaches() // Reset cached RepoContext between subtests
|
|
dir := t.TempDir()
|
|
|
|
// Initialize git repo
|
|
runCmd(t, dir, "git", "init")
|
|
runCmd(t, dir, "git", "config", "user.email", "test@example.com")
|
|
runCmd(t, dir, "git", "config", "user.name", "Test User")
|
|
|
|
// Create .beads directory with issues.jsonl (canonical name)
|
|
beadsDir := filepath.Join(dir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create .beads dir: %v", err)
|
|
}
|
|
|
|
// Create multiple test issues
|
|
issues := []*types.Issue{
|
|
{
|
|
ID: "test-1",
|
|
Title: "First issue",
|
|
Status: types.StatusOpen,
|
|
Priority: 1,
|
|
IssueType: types.TypeTask,
|
|
},
|
|
{
|
|
ID: "test-2",
|
|
Title: "Second issue",
|
|
Status: types.StatusOpen,
|
|
Priority: 2,
|
|
IssueType: types.TypeBug,
|
|
},
|
|
}
|
|
|
|
jsonlPath := filepath.Join(beadsDir, "issues.jsonl")
|
|
if err := writeJSONL(jsonlPath, issues); err != nil {
|
|
t.Fatalf("Failed to write JSONL: %v", err)
|
|
}
|
|
|
|
// Commit to git
|
|
runCmd(t, dir, "git", "add", ".beads/issues.jsonl")
|
|
runCmd(t, dir, "git", "commit", "-m", "Add issues")
|
|
|
|
// Simulate rm -rf .beads/ followed by partial bd init
|
|
// (in practice, bd init creates config.yaml before auto-import)
|
|
os.RemoveAll(beadsDir)
|
|
os.MkdirAll(beadsDir, 0755)
|
|
// Create minimal config so FindBeadsDir recognizes this as a beads directory
|
|
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("issue-prefix: test\n"), 0644); err != nil {
|
|
t.Fatalf("Failed to write config.yaml: %v", err)
|
|
}
|
|
|
|
// Change to test directory
|
|
t.Chdir(dir)
|
|
|
|
git.ResetCaches() // Reset git caches after changing directory
|
|
|
|
git.ResetCaches()
|
|
|
|
|
|
// Test checkGitForIssues finds issues.jsonl (canonical name)
|
|
count, path, gitRef := checkGitForIssues()
|
|
if count != 2 {
|
|
t.Errorf("Expected 2 issues in git, got %d", count)
|
|
}
|
|
expectedPath := normalizeGitPath(".beads/issues.jsonl")
|
|
if normalizeGitPath(path) != expectedPath {
|
|
t.Errorf("Expected %s, got %s", expectedPath, path)
|
|
}
|
|
|
|
// Initialize database and import
|
|
dbPath := filepath.Join(beadsDir, "test.db")
|
|
store, err := sqlite.New(context.Background(), dbPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create database: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
ctx := context.Background()
|
|
if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("Failed to set prefix: %v", err)
|
|
}
|
|
|
|
if err := importFromGit(ctx, dbPath, store, path, gitRef); err != nil {
|
|
t.Fatalf("Import failed: %v", err)
|
|
}
|
|
|
|
// Verify correct filename was detected
|
|
if filepath.Base(path) != "issues.jsonl" {
|
|
t.Errorf("Should have imported from issues.jsonl, got %s", path)
|
|
}
|
|
|
|
// Verify stats show >0 issues
|
|
stats, err := store.GetStatistics(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Failed to get stats: %v", err)
|
|
}
|
|
if stats.TotalIssues != 2 {
|
|
t.Errorf("Expected 2 issues, got %d", stats.TotalIssues)
|
|
}
|
|
}
|
|
|
|
// testLegacyFilenameSupport tests issues.jsonl fallback
|
|
func testLegacyFilenameSupport(t *testing.T) {
|
|
beads.ResetCaches() // Reset cached RepoContext between subtests
|
|
dir := t.TempDir()
|
|
|
|
// Initialize git repo
|
|
runCmd(t, dir, "git", "init")
|
|
runCmd(t, dir, "git", "config", "user.email", "test@example.com")
|
|
runCmd(t, dir, "git", "config", "user.name", "Test User")
|
|
|
|
// Create .beads directory with issues.jsonl (legacy)
|
|
beadsDir := filepath.Join(dir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create .beads dir: %v", err)
|
|
}
|
|
|
|
issue := &types.Issue{
|
|
ID: "test-1",
|
|
Title: "Legacy issue",
|
|
Status: types.StatusOpen,
|
|
Priority: 2,
|
|
IssueType: types.TypeTask,
|
|
}
|
|
|
|
// Use legacy filename
|
|
jsonlPath := filepath.Join(beadsDir, "issues.jsonl")
|
|
if err := writeJSONL(jsonlPath, []*types.Issue{issue}); err != nil {
|
|
t.Fatalf("Failed to write JSONL: %v", err)
|
|
}
|
|
|
|
// Commit to git
|
|
runCmd(t, dir, "git", "add", ".beads/issues.jsonl")
|
|
runCmd(t, dir, "git", "commit", "-m", "Add legacy issue")
|
|
|
|
// Change to test directory
|
|
t.Chdir(dir)
|
|
|
|
git.ResetCaches() // Reset git caches after changing directory
|
|
|
|
git.ResetCaches()
|
|
|
|
|
|
// Test checkGitForIssues finds issues.jsonl
|
|
count, path, gitRef := checkGitForIssues()
|
|
if count != 1 {
|
|
t.Errorf("Expected 1 issue in git, got %d", count)
|
|
}
|
|
expectedPath := normalizeGitPath(".beads/issues.jsonl")
|
|
if normalizeGitPath(path) != expectedPath {
|
|
t.Errorf("Expected %s, got %s", expectedPath, path)
|
|
}
|
|
|
|
// Initialize and import
|
|
dbPath := filepath.Join(beadsDir, "test.db")
|
|
store, err := sqlite.New(context.Background(), dbPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create database: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
ctx := context.Background()
|
|
if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("Failed to set prefix: %v", err)
|
|
}
|
|
|
|
if err := importFromGit(ctx, dbPath, store, path, gitRef); err != nil {
|
|
t.Fatalf("Import failed: %v", err)
|
|
}
|
|
|
|
// Verify import succeeded
|
|
stats, err := store.GetStatistics(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Failed to get stats: %v", err)
|
|
}
|
|
if stats.TotalIssues != 1 {
|
|
t.Errorf("Expected 1 issue, got %d", stats.TotalIssues)
|
|
}
|
|
}
|
|
|
|
// testPrecedenceTest verifies issues.jsonl is preferred over beads.jsonl
|
|
func testPrecedenceTest(t *testing.T) {
|
|
beads.ResetCaches() // Reset cached RepoContext between subtests
|
|
dir := t.TempDir()
|
|
|
|
// Initialize git repo
|
|
runCmd(t, dir, "git", "init")
|
|
runCmd(t, dir, "git", "config", "user.email", "test@example.com")
|
|
runCmd(t, dir, "git", "config", "user.name", "Test User")
|
|
|
|
// Create .beads directory with BOTH files
|
|
beadsDir := filepath.Join(dir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create .beads dir: %v", err)
|
|
}
|
|
|
|
// Create issues.jsonl with 2 issues (canonical, should be preferred)
|
|
canonicalIssues := []*types.Issue{
|
|
{ID: "test-1", Title: "From issues.jsonl", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask},
|
|
{ID: "test-2", Title: "Also from issues.jsonl", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask},
|
|
}
|
|
if err := writeJSONL(filepath.Join(beadsDir, "issues.jsonl"), canonicalIssues); err != nil {
|
|
t.Fatalf("Failed to write issues.jsonl: %v", err)
|
|
}
|
|
|
|
// Create beads.jsonl with 1 issue (should be ignored)
|
|
legacyIssues := []*types.Issue{
|
|
{ID: "test-99", Title: "From beads.jsonl", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask},
|
|
}
|
|
if err := writeJSONL(filepath.Join(beadsDir, "beads.jsonl"), legacyIssues); err != nil {
|
|
t.Fatalf("Failed to write beads.jsonl: %v", err)
|
|
}
|
|
|
|
// Commit both files
|
|
runCmd(t, dir, "git", "add", ".beads/")
|
|
runCmd(t, dir, "git", "commit", "-m", "Add both files")
|
|
|
|
// Change to test directory
|
|
t.Chdir(dir)
|
|
|
|
git.ResetCaches() // Reset git caches after changing directory
|
|
|
|
git.ResetCaches()
|
|
|
|
|
|
// Test checkGitForIssues prefers issues.jsonl
|
|
count, path, _ := checkGitForIssues()
|
|
if count != 2 {
|
|
t.Errorf("Expected 2 issues (from issues.jsonl), got %d", count)
|
|
}
|
|
expectedPath := normalizeGitPath(".beads/issues.jsonl")
|
|
if normalizeGitPath(path) != expectedPath {
|
|
t.Errorf("Expected issues.jsonl to be preferred, got %s", path)
|
|
}
|
|
}
|
|
|
|
// testInitSafetyCheck tests the safety check that prevents silent data loss
|
|
func testInitSafetyCheck(t *testing.T) {
|
|
beads.ResetCaches() // Reset cached RepoContext between subtests
|
|
dir := t.TempDir()
|
|
|
|
// Initialize git repo
|
|
runCmd(t, dir, "git", "init")
|
|
runCmd(t, dir, "git", "config", "user.email", "test@example.com")
|
|
runCmd(t, dir, "git", "config", "user.name", "Test User")
|
|
|
|
// Create .beads directory with issues.jsonl (canonical name)
|
|
beadsDir := filepath.Join(dir, ".beads")
|
|
if err := os.MkdirAll(beadsDir, 0755); err != nil {
|
|
t.Fatalf("Failed to create .beads dir: %v", err)
|
|
}
|
|
|
|
issue := &types.Issue{
|
|
ID: "test-1",
|
|
Title: "Test issue",
|
|
Status: types.StatusOpen,
|
|
Priority: 1,
|
|
IssueType: types.TypeTask,
|
|
}
|
|
|
|
jsonlPath := filepath.Join(beadsDir, "issues.jsonl")
|
|
if err := writeJSONL(jsonlPath, []*types.Issue{issue}); err != nil {
|
|
t.Fatalf("Failed to write JSONL: %v", err)
|
|
}
|
|
|
|
// Commit to git
|
|
runCmd(t, dir, "git", "add", ".beads/issues.jsonl")
|
|
runCmd(t, dir, "git", "commit", "-m", "Add issue")
|
|
|
|
// Change to test directory
|
|
t.Chdir(dir)
|
|
|
|
git.ResetCaches() // Reset git caches after changing directory
|
|
|
|
git.ResetCaches()
|
|
|
|
|
|
// Create empty database (simulating failed import)
|
|
dbPath := filepath.Join(beadsDir, "test.db")
|
|
store, err := sqlite.New(context.Background(), dbPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create database: %v", err)
|
|
}
|
|
ctx := context.Background()
|
|
if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("Failed to set prefix: %v", err)
|
|
}
|
|
|
|
// Verify safety check would detect the problem
|
|
stats, err := store.GetStatistics(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Failed to get stats: %v", err)
|
|
}
|
|
|
|
if stats.TotalIssues == 0 {
|
|
// Database is empty - check if git has issues
|
|
recheck, recheckPath, _ := checkGitForIssues()
|
|
if recheck == 0 {
|
|
t.Error("Safety check should have detected issues in git")
|
|
}
|
|
expectedPath := normalizeGitPath(".beads/issues.jsonl")
|
|
if normalizeGitPath(recheckPath) != expectedPath {
|
|
t.Errorf("Safety check found wrong path: %s", recheckPath)
|
|
}
|
|
// This would trigger the error exit in real init.go
|
|
t.Logf("Safety check correctly detected %d issues in git at %s", recheck, recheckPath)
|
|
} else {
|
|
t.Error("Database should be empty for this test")
|
|
}
|
|
|
|
store.Close()
|
|
}
|
|
|
|
// Helper functions
|
|
|
|
// runCmd runs a command and fails the test if it returns an error
|
|
// If the command is "git init", it automatically adds --initial-branch=main
|
|
// for modern git compatibility.
|
|
func runCmd(t *testing.T, dir string, name string, args ...string) {
|
|
t.Helper()
|
|
// Add --initial-branch=main to git init for modern git compatibility
|
|
if name == "git" && len(args) > 0 && args[0] == "init" {
|
|
args = append(args, "--initial-branch=main")
|
|
}
|
|
cmd := exec.Command(name, args...)
|
|
cmd.Dir = dir
|
|
if output, err := cmd.CombinedOutput(); err != nil {
|
|
t.Fatalf("Command %s %v failed: %v\nOutput: %s", name, args, err, output)
|
|
}
|
|
}
|
|
|
|
// writeJSONL writes issues to a JSONL file
|
|
func writeJSONL(path string, issues []*types.Issue) error {
|
|
f, err := os.Create(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
|
|
enc := json.NewEncoder(f)
|
|
for _, issue := range issues {
|
|
if err := enc.Encode(issue); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// normalizeGitPath converts a path to use forward slashes for git compatibility
|
|
// Git always uses forward slashes internally, even on Windows
|
|
func normalizeGitPath(path string) string {
|
|
if runtime.GOOS == windowsOS {
|
|
return filepath.ToSlash(path)
|
|
}
|
|
return path
|
|
}
|