From d02b810a38b27eff03f47445c0366d610cfae4c6 Mon Sep 17 00:00:00 2001 From: beads/crew/darcy Date: Mon, 23 Feb 2026 10:41:14 -0800 Subject: [PATCH] test: convert doctor test fixtures from SQLite to Dolt (bd-o0u.1) Convert doctor test files to use Dolt-based test fixtures instead of creating temporary SQLite databases. Tests that are fundamentally SQLite-specific (file corruption, sidecars, DB locking, legacy schema migration) are skipped with clear notes about why they dont apply to the Dolt backend. Files converted: - doctor/deep_test.go: use newTestDoltStore + UnderlyingDB() - doctor/database_test.go: remove setupTestDatabase(), simplify cases - doctor/fix/validation_test.go: skip SQLite fixture tests (bd-o0u.5) - doctor_test.go: skip DetectHashBasedIDs (child_counters always exists) - gate_test.go: remove SQLite DB creation, skip placeholder test - doctor_repair_test.go: skip SQLite corruption repair test - doctor_repair_chaos_test.go: skip all SQLite chaos tests - doctor_migrate_fix_test.go: skip legacy SQLite schema migration test Co-Authored-By: Claude Opus 4.6 --- cmd/bd/doctor/database_test.go | 133 +----------- cmd/bd/doctor/deep_test.go | 274 ++++++++++--------------- cmd/bd/doctor/fix/validation_test.go | 164 +-------------- cmd/bd/doctor_migrate_fix_test.go | 140 +------------ cmd/bd/doctor_repair_chaos_test.go | 295 +-------------------------- cmd/bd/doctor_repair_test.go | 95 +-------- cmd/bd/doctor_test.go | 245 +--------------------- cmd/bd/gate_test.go | 63 +----- 8 files changed, 139 insertions(+), 1270 deletions(-) diff --git a/cmd/bd/doctor/database_test.go b/cmd/bd/doctor/database_test.go index 4e5ccf3ce..e83f7998d 100644 --- a/cmd/bd/doctor/database_test.go +++ b/cmd/bd/doctor/database_test.go @@ -1,40 +1,11 @@ package doctor import ( - "database/sql" "os" "path/filepath" "testing" - - _ "github.com/ncruces/go-sqlite3/driver" - _ "github.com/ncruces/go-sqlite3/embed" ) -// setupTestDatabase creates a minimal valid SQLite database for testing -func setupTestDatabase(t *testing.T, dir string) string { - t.Helper() - dbPath := filepath.Join(dir, ".beads", "beads.db") - - db, err := sql.Open("sqlite3", dbPath) - if err != nil { - t.Skipf("skipping: Dolt server not available: %v", err) - } - defer db.Close() - - // Create minimal issues table - _, err = db.Exec(`CREATE TABLE IF NOT EXISTS issues ( - id TEXT PRIMARY KEY, - title TEXT, - status TEXT, - ephemeral INTEGER DEFAULT 0 - )`) - if err != nil { - t.Fatalf("failed to create table: %v", err) - } - - return dbPath -} - func TestCheckDatabaseIntegrity(t *testing.T) { tests := []struct { name string @@ -45,27 +16,18 @@ func TestCheckDatabaseIntegrity(t *testing.T) { { name: "no database", setup: func(t *testing.T, dir string) { - // No database file created + // No database directory created }, expectedStatus: "ok", expectMessage: "N/A (no database)", }, { - name: "valid database", - setup: func(t *testing.T, dir string) { - // SQLite DB is invisible to Dolt backend; no dolt/ dir → "no database" - setupTestDatabase(t, dir) - }, - expectedStatus: "ok", - expectMessage: "N/A (no database)", - }, - { - name: "corrupt database", + name: "stale beads.db file ignored", setup: func(t *testing.T, dir string) { + // A stale beads.db FILE (not directory) is invisible to Dolt backend dbPath := filepath.Join(dir, ".beads", "beads.db") - // SQLite garbage file is invisible to Dolt backend; no dolt/ dir → "no database" - if err := os.WriteFile(dbPath, []byte("not a sqlite database"), 0600); err != nil { - t.Fatalf("failed to create corrupt db: %v", err) + if err := os.WriteFile(dbPath, []byte("stale sqlite file"), 0600); err != nil { + t.Fatalf("failed to create stale db file: %v", err) } }, expectedStatus: "ok", @@ -142,14 +104,6 @@ func TestCheckSchemaCompatibility(t *testing.T) { }, expectedStatus: "ok", }, - { - name: "minimal schema", - setup: func(t *testing.T, dir string) { - // SQLite DB invisible to Dolt backend; no dolt/ dir → "no database" - setupTestDatabase(t, dir) - }, - expectedStatus: "ok", - }, } for _, tt := range tests { @@ -171,83 +125,8 @@ func TestCheckSchemaCompatibility(t *testing.T) { } } -// Edge case tests - func TestCheckDatabaseIntegrity_EdgeCases(t *testing.T) { - tests := []struct { - name string - setup func(t *testing.T, dir string) string - expectedStatus string - }{ - { - name: "locked database file", - setup: func(t *testing.T, dir string) string { - dbPath := setupTestDatabase(t, dir) - - // Open a connection with an exclusive lock - db, err := sql.Open("sqlite3", dbPath) - if err != nil { - t.Fatalf("failed to open database: %v", err) - } - - // Start a transaction to hold a lock - tx, err := db.Begin() - if err != nil { - db.Close() - t.Fatalf("failed to begin transaction: %v", err) - } - - // Write some data to ensure the lock is held - _, err = tx.Exec("INSERT INTO issues (id, title, status) VALUES ('lock-test', 'Lock Test', 'open')") - if err != nil { - tx.Rollback() - db.Close() - t.Fatalf("failed to insert test data: %v", err) - } - - // Keep the transaction open by returning a cleanup function via test context - t.Cleanup(func() { - tx.Rollback() - db.Close() - }) - - return dbPath - }, - expectedStatus: "ok", // Should still succeed with busy_timeout - }, - { - name: "read-only database file", - setup: func(t *testing.T, dir string) string { - dbPath := setupTestDatabase(t, dir) - - // Make the database file read-only - if err := os.Chmod(dbPath, 0400); err != nil { - t.Fatalf("failed to chmod database: %v", err) - } - - return dbPath - }, - expectedStatus: "ok", // Integrity check uses read-only mode - }, - } - - 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.Fatal(err) - } - - tt.setup(t, tmpDir) - - check := CheckDatabaseIntegrity(tmpDir) - - if check.Status != tt.expectedStatus { - t.Errorf("expected status %q, got %q (message: %s)", tt.expectedStatus, check.Status, check.Message) - } - }) - } + t.Skip("SQLite-specific edge cases (locked/read-only files); Dolt backend uses server connections") } func TestCheckDatabaseVersion_EdgeCases(t *testing.T) { diff --git a/cmd/bd/doctor/deep_test.go b/cmd/bd/doctor/deep_test.go index eb76279b5..78870421a 100644 --- a/cmd/bd/doctor/deep_test.go +++ b/cmd/bd/doctor/deep_test.go @@ -1,10 +1,14 @@ +//go:build cgo + package doctor import ( - "database/sql" + "context" "os" "path/filepath" "testing" + + "github.com/steveyegge/beads/internal/types" ) // TestRunDeepValidation_NoBeadsDir verifies deep validation handles missing .beads directory @@ -39,112 +43,63 @@ func TestRunDeepValidation_EmptyBeadsDir(t *testing.T) { } } -// TestRunDeepValidation_WithDatabase verifies deep validation with a basic database +// TestRunDeepValidation_WithDatabase verifies all deep check functions run +// without panicking against a Dolt connection. The shared test database may +// have pre-existing data, so we verify checks complete rather than expecting +// a clean state. Individual check functions are tested in isolation below. func TestRunDeepValidation_WithDatabase(t *testing.T) { - tmpDir := t.TempDir() - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.Mkdir(beadsDir, 0755); err != nil { - t.Fatal(err) + store := newTestDoltStore(t, "deep") + db := store.UnderlyingDB() + + // Run all deep checks against the Dolt connection + checks := []DoctorCheck{ + checkParentConsistency(db), + checkDependencyIntegrity(db), + checkEpicCompleteness(db), + checkAgentBeadIntegrity(db), + checkMailThreadIntegrity(db), + checkMoleculeIntegrity(db), } - // Create a minimal database (use canonical name beads.db) - dbPath := filepath.Join(beadsDir, "beads.db") - db, err := sql.Open("sqlite3", dbPath) - if err != nil { - t.Fatal(err) + // Verify all 6 checks ran and produced valid statuses + if len(checks) != 6 { + t.Errorf("Expected 6 checks, got %d", len(checks)) } - defer db.Close() - - // Create minimal schema matching what deep validation expects - _, err = db.Exec(` - CREATE TABLE issues ( - id TEXT PRIMARY KEY, - title TEXT NOT NULL, - status TEXT NOT NULL DEFAULT 'open', - issue_type TEXT NOT NULL DEFAULT 'task', - notes TEXT DEFAULT '' - ); - CREATE TABLE dependencies ( - issue_id TEXT NOT NULL, - depends_on_id TEXT NOT NULL, - type TEXT NOT NULL DEFAULT 'blocks', - created_by TEXT NOT NULL DEFAULT '', - thread_id TEXT DEFAULT '', - PRIMARY KEY (issue_id, depends_on_id) - ); - CREATE TABLE labels ( - issue_id TEXT NOT NULL, - label TEXT NOT NULL, - PRIMARY KEY (issue_id, label) - ); - `) - if err != nil { - t.Fatal(err) - } - - result := RunDeepValidation(tmpDir) - - // Should have 6 checks (one for each validation type) - if len(result.AllChecks) != 6 { - // Log what we got for debugging - t.Logf("Got %d checks:", len(result.AllChecks)) - for i, check := range result.AllChecks { - t.Logf(" %d: %s - %s", i, check.Name, check.Message) + for _, check := range checks { + if check.Name == "" { + t.Error("Check has empty Name") } - t.Errorf("Expected 6 checks, got %d", len(result.AllChecks)) - } - - // All should pass on empty database - for _, check := range result.AllChecks { - if check.Status == StatusError { - t.Errorf("Check %s failed: %s", check.Name, check.Message) + if check.Status != StatusOK && check.Status != StatusWarning && check.Status != StatusError { + t.Errorf("Check %s has invalid status %q", check.Name, check.Status) } } } // TestCheckParentConsistency_OrphanedDeps verifies detection of orphaned parent-child deps func TestCheckParentConsistency_OrphanedDeps(t *testing.T) { - tmpDir := t.TempDir() - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.Mkdir(beadsDir, 0755); err != nil { - t.Fatal(err) + store := newTestDoltStore(t, "deep") + ctx := context.Background() + + // Insert an issue via store API + issue := &types.Issue{ + Title: "Test Issue", + Status: types.StatusOpen, + Priority: 2, + IssueType: types.TypeTask, + } + if err := store.CreateIssue(ctx, issue, "deep"); err != nil { + t.Fatalf("Failed to create issue: %v", err) } - dbPath := filepath.Join(beadsDir, "beads.db") - db, err := sql.Open("sqlite3", dbPath) - if err != nil { - t.Fatal(err) - } - defer db.Close() + db := store.UnderlyingDB() - // Create schema - _, err = db.Exec(` - CREATE TABLE issues ( - id TEXT PRIMARY KEY, - title TEXT NOT NULL, - status TEXT NOT NULL DEFAULT 'open' - ); - CREATE TABLE dependencies ( - issue_id TEXT NOT NULL, - depends_on_id TEXT NOT NULL, - type TEXT NOT NULL DEFAULT 'blocks', - PRIMARY KEY (issue_id, depends_on_id) - ); - `) + // Insert a parent-child dep pointing to non-existent parent via raw SQL + _, err := db.Exec( + "INSERT INTO dependencies (issue_id, depends_on_id, type, created_by) VALUES (?, ?, ?, ?)", + issue.ID, "deep-missing", "parent-child", "test", + ) if err != nil { - t.Fatal(err) - } - - // Insert an issue - _, err = db.Exec(`INSERT INTO issues (id, title, status) VALUES ('bd-1', 'Test Issue', 'open')`) - if err != nil { - t.Fatal(err) - } - - // Insert a parent-child dep pointing to non-existent parent - _, err = db.Exec(`INSERT INTO dependencies (issue_id, depends_on_id, type) VALUES ('bd-1', 'bd-missing', 'parent-child')`) - if err != nil { - t.Fatal(err) + t.Fatalf("Failed to insert orphaned dep: %v", err) } check := checkParentConsistency(db) @@ -156,54 +111,40 @@ func TestCheckParentConsistency_OrphanedDeps(t *testing.T) { // TestCheckEpicCompleteness_CompletedEpic verifies detection of closeable epics func TestCheckEpicCompleteness_CompletedEpic(t *testing.T) { - tmpDir := t.TempDir() - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.Mkdir(beadsDir, 0755); err != nil { - t.Fatal(err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - db, err := sql.Open("sqlite3", dbPath) - if err != nil { - t.Fatal(err) - } - defer db.Close() - - // Create schema - _, err = db.Exec(` - CREATE TABLE issues ( - id TEXT PRIMARY KEY, - title TEXT NOT NULL, - status TEXT NOT NULL DEFAULT 'open', - issue_type TEXT NOT NULL DEFAULT 'task' - ); - CREATE TABLE dependencies ( - issue_id TEXT NOT NULL, - depends_on_id TEXT NOT NULL, - type TEXT NOT NULL DEFAULT 'blocks', - PRIMARY KEY (issue_id, depends_on_id) - ); - `) - if err != nil { - t.Fatal(err) - } + store := newTestDoltStore(t, "deep") + ctx := context.Background() // Insert an open epic - _, err = db.Exec(`INSERT INTO issues (id, title, status, issue_type) VALUES ('epic-1', 'Epic', 'open', 'epic')`) - if err != nil { - t.Fatal(err) + epic := &types.Issue{ + Title: "Epic", + Status: types.StatusOpen, + Priority: 2, + IssueType: types.TypeEpic, + } + if err := store.CreateIssue(ctx, epic, "deep"); err != nil { + t.Fatalf("Failed to create epic: %v", err) } // Insert a closed child task - _, err = db.Exec(`INSERT INTO issues (id, title, status, issue_type) VALUES ('task-1', 'Task', 'closed', 'task')`) - if err != nil { - t.Fatal(err) + task := &types.Issue{ + Title: "Task", + Status: types.StatusClosed, + Priority: 2, + IssueType: types.TypeTask, + } + if err := store.CreateIssue(ctx, task, "deep"); err != nil { + t.Fatalf("Failed to create task: %v", err) } - // Create parent-child relationship - _, err = db.Exec(`INSERT INTO dependencies (issue_id, depends_on_id, type) VALUES ('task-1', 'epic-1', 'parent-child')`) + db := store.UnderlyingDB() + + // Create parent-child relationship via raw SQL + _, err := db.Exec( + "INSERT INTO dependencies (issue_id, depends_on_id, type, created_by) VALUES (?, ?, ?, ?)", + task.ID, epic.ID, "parent-child", "test", + ) if err != nil { - t.Fatal(err) + t.Fatalf("Failed to insert parent-child dep: %v", err) } check := checkEpicCompleteness(db) @@ -216,56 +157,47 @@ func TestCheckEpicCompleteness_CompletedEpic(t *testing.T) { // TestCheckMailThreadIntegrity_ValidThreads verifies valid thread references pass func TestCheckMailThreadIntegrity_ValidThreads(t *testing.T) { - tmpDir := t.TempDir() - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.Mkdir(beadsDir, 0755); err != nil { - t.Fatal(err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - db, err := sql.Open("sqlite3", dbPath) - if err != nil { - t.Fatal(err) - } - defer db.Close() - - // Create schema with thread_id column - _, err = db.Exec(` - CREATE TABLE issues ( - id TEXT PRIMARY KEY, - title TEXT NOT NULL, - status TEXT NOT NULL DEFAULT 'open' - ); - CREATE TABLE dependencies ( - issue_id TEXT NOT NULL, - depends_on_id TEXT NOT NULL, - type TEXT NOT NULL DEFAULT 'blocks', - thread_id TEXT DEFAULT '', - PRIMARY KEY (issue_id, depends_on_id) - ); - `) - if err != nil { - t.Fatal(err) - } + store := newTestDoltStore(t, "deep") + ctx := context.Background() // Insert issues - _, err = db.Exec(`INSERT INTO issues (id, title, status) VALUES ('thread-root', 'Thread Root', 'open')`) - if err != nil { - t.Fatal(err) + root := &types.Issue{ + Title: "Thread Root", + Status: types.StatusOpen, + Priority: 2, + IssueType: types.TypeTask, } - _, err = db.Exec(`INSERT INTO issues (id, title, status) VALUES ('reply-1', 'Reply', 'open')`) - if err != nil { - t.Fatal(err) + if err := store.CreateIssue(ctx, root, "deep"); err != nil { + t.Fatalf("Failed to create root issue: %v", err) } + reply := &types.Issue{ + Title: "Reply", + Status: types.StatusOpen, + Priority: 2, + IssueType: types.TypeTask, + } + if err := store.CreateIssue(ctx, reply, "deep"); err != nil { + t.Fatalf("Failed to create reply issue: %v", err) + } + + db := store.UnderlyingDB() + // Insert a dependency with valid thread_id - _, err = db.Exec(`INSERT INTO dependencies (issue_id, depends_on_id, type, thread_id) VALUES ('reply-1', 'thread-root', 'replies-to', 'thread-root')`) + _, err := db.Exec( + "INSERT INTO dependencies (issue_id, depends_on_id, type, thread_id, created_by) VALUES (?, ?, ?, ?, ?)", + reply.ID, root.ID, "replies-to", root.ID, "test", + ) if err != nil { - t.Fatal(err) + t.Fatalf("Failed to insert thread dep: %v", err) } check := checkMailThreadIntegrity(db) + // On Dolt/MySQL, pragma_table_info is not available, so the check + // returns StatusOK with "N/A" message. This is expected behavior — + // the check functions will be updated to use Dolt-compatible queries + // in later subtasks (bd-o0u.2+). if check.Status != StatusOK { t.Errorf("Status = %q, want %q: %s", check.Status, StatusOK, check.Message) } diff --git a/cmd/bd/doctor/fix/validation_test.go b/cmd/bd/doctor/fix/validation_test.go index 9b9ed1706..9dec5380e 100644 --- a/cmd/bd/doctor/fix/validation_test.go +++ b/cmd/bd/doctor/fix/validation_test.go @@ -1,12 +1,7 @@ package fix import ( - "os" - "path/filepath" "testing" - - _ "github.com/ncruces/go-sqlite3/driver" - _ "github.com/ncruces/go-sqlite3/embed" ) // TestFixFunctions_RequireBeadsDir verifies all fix functions properly validate @@ -36,162 +31,19 @@ func TestFixFunctions_RequireBeadsDir(t *testing.T) { } } +// The following tests created SQLite databases directly via openDB() to test +// fix functions. Since the fix functions use openAnyDB() which supports both +// SQLite and Dolt, these tests will be re-enabled with Dolt fixtures when the +// fix functions are fully converted to Dolt (bd-o0u.5). + func TestChildParentDependencies_NoBadDeps(t *testing.T) { - // Set up test database with no child→parent deps - dir := t.TempDir() - beadsDir := filepath.Join(dir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatal(err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - db, err := openDB(dbPath) - if err != nil { - t.Fatal(err) - } - - // Create minimal schema - _, err = db.Exec(` - CREATE TABLE issues (id TEXT PRIMARY KEY); - CREATE TABLE dependencies (issue_id TEXT, depends_on_id TEXT, type TEXT); - CREATE TABLE dirty_issues (issue_id TEXT PRIMARY KEY); - INSERT INTO issues (id) VALUES ('bd-abc'), ('bd-abc.1'), ('bd-xyz'); - INSERT INTO dependencies (issue_id, depends_on_id, type) VALUES ('bd-abc.1', 'bd-xyz', 'blocks'); - `) - if err != nil { - t.Fatal(err) - } - db.Close() - - // Run fix - should find no bad deps - err = ChildParentDependencies(dir, false) - if err != nil { - t.Errorf("ChildParentDependencies failed: %v", err) - } - - // Verify the good dependency still exists - db, _ = openDB(dbPath) - defer db.Close() - var count int - db.QueryRow("SELECT COUNT(*) FROM dependencies").Scan(&count) - if count != 1 { - t.Errorf("Expected 1 dependency, got %d", count) - } + t.Skip("SQLite fixture test; will be converted with fix functions in bd-o0u.5") } func TestChildParentDependencies_FixesBadDeps(t *testing.T) { - // Set up test database with child→parent deps - dir := t.TempDir() - beadsDir := filepath.Join(dir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatal(err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - db, err := openDB(dbPath) - if err != nil { - t.Fatal(err) - } - - // Create minimal schema with child→parent dependency - _, err = db.Exec(` - CREATE TABLE issues (id TEXT PRIMARY KEY); - CREATE TABLE dependencies (issue_id TEXT, depends_on_id TEXT, type TEXT); - CREATE TABLE dirty_issues (issue_id TEXT PRIMARY KEY); - INSERT INTO issues (id) VALUES ('bd-abc'), ('bd-abc.1'), ('bd-abc.1.2'); - INSERT INTO dependencies (issue_id, depends_on_id, type) VALUES - ('bd-abc.1', 'bd-abc', 'blocks'), - ('bd-abc.1.2', 'bd-abc', 'blocks'), - ('bd-abc.1.2', 'bd-abc.1', 'blocks'); - `) - if err != nil { - t.Fatal(err) - } - db.Close() - - // Run fix - err = ChildParentDependencies(dir, false) - if err != nil { - t.Errorf("ChildParentDependencies failed: %v", err) - } - - // Verify all bad dependencies were removed - db, _ = openDB(dbPath) - defer db.Close() - var count int - db.QueryRow("SELECT COUNT(*) FROM dependencies").Scan(&count) - if count != 0 { - t.Errorf("Expected 0 dependencies after fix, got %d", count) - } - - // Verify dirty_issues was updated for affected issues - // Note: 2 unique issue_ids (bd-abc.1 appears once, bd-abc.1.2 appears twice but INSERT OR IGNORE dedupes) - var dirtyCount int - db.QueryRow("SELECT COUNT(*) FROM dirty_issues").Scan(&dirtyCount) - if dirtyCount != 2 { - t.Errorf("Expected 2 dirty issues (unique issue_ids from removed deps), got %d", dirtyCount) - } + t.Skip("SQLite fixture test; will be converted with fix functions in bd-o0u.5") } -// TestChildParentDependencies_PreservesParentChildType verifies that legitimate -// parent-child type dependencies are NOT removed (only blocking types are removed). -// Regression test for GitHub issue #750. func TestChildParentDependencies_PreservesParentChildType(t *testing.T) { - // Set up test database with both 'blocks' and 'parent-child' type deps - dir := t.TempDir() - beadsDir := filepath.Join(dir, ".beads") - if err := os.MkdirAll(beadsDir, 0755); err != nil { - t.Fatal(err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - db, err := openDB(dbPath) - if err != nil { - t.Fatal(err) - } - - // Create schema with both 'blocks' (anti-pattern) and 'parent-child' (legitimate) deps - _, err = db.Exec(` - CREATE TABLE issues (id TEXT PRIMARY KEY); - CREATE TABLE dependencies (issue_id TEXT, depends_on_id TEXT, type TEXT); - CREATE TABLE dirty_issues (issue_id TEXT PRIMARY KEY); - INSERT INTO issues (id) VALUES ('bd-abc'), ('bd-abc.1'), ('bd-abc.2'); - INSERT INTO dependencies (issue_id, depends_on_id, type) VALUES - ('bd-abc.1', 'bd-abc', 'parent-child'), - ('bd-abc.2', 'bd-abc', 'parent-child'), - ('bd-abc.1', 'bd-abc', 'blocks'); - `) - if err != nil { - t.Fatal(err) - } - db.Close() - - // Run fix - err = ChildParentDependencies(dir, false) - if err != nil { - t.Fatalf("ChildParentDependencies failed: %v", err) - } - - // Verify only 'blocks' type was removed, 'parent-child' preserved - db, _ = openDB(dbPath) - defer db.Close() - - var blocksCount int - db.QueryRow("SELECT COUNT(*) FROM dependencies WHERE type = 'blocks'").Scan(&blocksCount) - if blocksCount != 0 { - t.Errorf("Expected 0 'blocks' dependencies after fix, got %d", blocksCount) - } - - var parentChildCount int - db.QueryRow("SELECT COUNT(*) FROM dependencies WHERE type = 'parent-child'").Scan(&parentChildCount) - if parentChildCount != 2 { - t.Errorf("Expected 2 'parent-child' dependencies preserved, got %d", parentChildCount) - } - - // Verify only 1 dirty issue (the one with 'blocks' dep removed) - var dirtyCount int - db.QueryRow("SELECT COUNT(*) FROM dirty_issues").Scan(&dirtyCount) - if dirtyCount != 1 { - t.Errorf("Expected 1 dirty issue, got %d", dirtyCount) - } + t.Skip("SQLite fixture test; will be converted with fix functions in bd-o0u.5") } diff --git a/cmd/bd/doctor_migrate_fix_test.go b/cmd/bd/doctor_migrate_fix_test.go index 8a21514e8..c3308d85e 100644 --- a/cmd/bd/doctor_migrate_fix_test.go +++ b/cmd/bd/doctor_migrate_fix_test.go @@ -1,144 +1,12 @@ package main import ( - "database/sql" - "os" - "path/filepath" "testing" - - _ "github.com/ncruces/go-sqlite3/driver" - _ "github.com/ncruces/go-sqlite3/embed" ) -const legacyIssuesSchemaWithoutSpecID = ` -CREATE TABLE issues ( - id TEXT PRIMARY KEY, - content_hash TEXT, - title TEXT NOT NULL CHECK(length(title) <= 500), - description TEXT NOT NULL DEFAULT '', - design TEXT NOT NULL DEFAULT '', - acceptance_criteria TEXT NOT NULL DEFAULT '', - notes TEXT NOT NULL DEFAULT '', - status TEXT NOT NULL DEFAULT 'open', - priority INTEGER NOT NULL DEFAULT 2 CHECK(priority >= 0 AND priority <= 4), - issue_type TEXT NOT NULL DEFAULT 'task', - assignee TEXT, - estimated_minutes INTEGER, - created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, - created_by TEXT DEFAULT '', - owner TEXT DEFAULT '', - updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, - closed_at DATETIME, - closed_by_session TEXT DEFAULT '', - external_ref TEXT, - compaction_level INTEGER DEFAULT 0, - compacted_at DATETIME, - compacted_at_commit TEXT, - original_size INTEGER, - deleted_at DATETIME, - deleted_by TEXT DEFAULT '', - delete_reason TEXT DEFAULT '', - original_type TEXT DEFAULT '', - sender TEXT DEFAULT '', - ephemeral INTEGER DEFAULT 0, - wisp_type TEXT DEFAULT '', - pinned INTEGER DEFAULT 0, - is_template INTEGER DEFAULT 0, - crystallizes INTEGER DEFAULT 0, - mol_type TEXT DEFAULT '', - work_type TEXT DEFAULT 'mutex', - quality_score REAL, - source_system TEXT DEFAULT '', - metadata TEXT NOT NULL DEFAULT '{}', - event_kind TEXT DEFAULT '', - actor TEXT DEFAULT '', - target TEXT DEFAULT '', - payload TEXT DEFAULT '', - CHECK ( - (status = 'closed' AND closed_at IS NOT NULL) OR - (status NOT IN ('closed') AND closed_at IS NULL) - ) -); -` - func TestDoctorFix_UpgradesLegacySchemaWithoutSpecID(t *testing.T) { - requireTestGuardDisabled(t) - if testing.Short() { - t.Skip("skipping slow doctor fix integration test in short mode") - } - - bdExe := buildBDForTest(t) - ws := mkTmpDirInTmp(t, "bd-doctor-migrate-*") - - tmpHome := filepath.Join(ws, "home") - if err := os.MkdirAll(tmpHome, 0o755); err != nil { - t.Fatalf("create temp home: %v", err) - } - t.Setenv("HOME", tmpHome) - - beadsDir := filepath.Join(ws, ".beads") - if err := os.MkdirAll(beadsDir, 0o755); err != nil { - t.Fatalf("create beads dir: %v", err) - } - - metadataPath := filepath.Join(beadsDir, "metadata.json") - if err := os.WriteFile(metadataPath, []byte(`{"database":"beads.db"}`), 0o600); err != nil { - t.Fatalf("write metadata.json: %v", err) - } - - dbPath := filepath.Join(beadsDir, "beads.db") - db, err := sql.Open("sqlite3", "file:"+dbPath+"?_pragma=foreign_keys(ON)&_time_format=sqlite") - if err != nil { - t.Fatalf("open legacy db: %v", err) - } - if _, err := db.Exec(legacyIssuesSchemaWithoutSpecID); err != nil { - _ = db.Close() - t.Fatalf("create legacy issues table: %v", err) - } - if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL)`); err != nil { - _ = db.Close() - t.Fatalf("create metadata table: %v", err) - } - if _, err := db.Exec(`INSERT INTO metadata (key, value) VALUES ('bd_version', '0.49.3')`); err != nil { - _ = db.Close() - t.Fatalf("insert legacy version: %v", err) - } - if err := db.Close(); err != nil { - t.Fatalf("close legacy db: %v", err) - } - - out, err := runBDSideDB(t, bdExe, ws, dbPath, "doctor", "--fix", "--yes") - if err != nil { - t.Fatalf("bd doctor --fix failed: %v\n%s", err, out) - } - - verifyDB, err := sql.Open("sqlite3", "file:"+dbPath+"?mode=ro&_time_format=sqlite") - if err != nil { - t.Fatalf("open upgraded db: %v", err) - } - defer verifyDB.Close() - - var version string - if err := verifyDB.QueryRow(`SELECT value FROM metadata WHERE key = 'bd_version'`).Scan(&version); err != nil { - t.Fatalf("read upgraded version: %v", err) - } - if version != Version { - t.Fatalf("expected upgraded version %s, got %s", Version, version) - } - - var specIDCount int - if err := verifyDB.QueryRow(`SELECT COUNT(*) FROM pragma_table_info('issues') WHERE name = 'spec_id'`).Scan(&specIDCount); err != nil { - t.Fatalf("check spec_id column: %v", err) - } - if specIDCount != 1 { - t.Fatalf("expected spec_id column to exist, count=%d", specIDCount) - } - - var specIDIndexCount int - if err := verifyDB.QueryRow(`SELECT COUNT(*) FROM pragma_index_list('issues') WHERE name = 'idx_issues_spec_id'`).Scan(&specIDIndexCount); err != nil { - t.Fatalf("check spec_id index: %v", err) - } - if specIDIndexCount != 1 { - t.Fatalf("expected idx_issues_spec_id to exist, count=%d", specIDIndexCount) - } + // This test created a legacy SQLite database with pre-spec_id schema and verified + // that doctor --fix upgrades it. Dolt uses its own schema management (schema.go) + // and doesn't have SQLite migration paths. + t.Skip("SQLite legacy schema migration test; Dolt uses server-side schema management (bd-o0u)") } diff --git a/cmd/bd/doctor_repair_chaos_test.go b/cmd/bd/doctor_repair_chaos_test.go index 3a7f80d6f..ad66cb83a 100644 --- a/cmd/bd/doctor_repair_chaos_test.go +++ b/cmd/bd/doctor_repair_chaos_test.go @@ -5,7 +5,6 @@ package main import ( "bytes" "context" - "database/sql" "io" "os" "os/exec" @@ -13,314 +12,34 @@ import ( "strings" "testing" "time" - - _ "github.com/ncruces/go-sqlite3/driver" ) func TestDoctorRepair_CorruptDatabase_NotADatabase_RebuildFromJSONL(t *testing.T) { - requireTestGuardDisabled(t) - bdExe := buildBDForTest(t) - ws := mkTmpDirInTmp(t, "bd-doctor-chaos-*") - dbPath := filepath.Join(ws, ".beads", "beads.db") - jsonlPath := filepath.Join(ws, ".beads", "issues.jsonl") - - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "init", "--prefix", "chaos", "--quiet"); err != nil { - t.Fatalf("bd init failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "create", "Chaos issue", "-p", "1"); err != nil { - t.Fatalf("bd create failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "export", "-o", jsonlPath, "--force"); err != nil { - t.Fatalf("bd export failed: %v", err) - } - - // Make the DB unreadable. - if err := os.WriteFile(dbPath, []byte("not a database"), 0644); err != nil { - t.Fatalf("corrupt db: %v", err) - } - - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "doctor", "--fix", "--yes"); err != nil { - t.Fatalf("bd doctor --fix failed: %v", err) - } - - if out, err := runBDSideDB(t, bdExe, ws, dbPath, "doctor"); err != nil { - t.Fatalf("bd doctor after fix failed: %v\n%s", err, out) - } + t.Skip("SQLite file corruption chaos test; not applicable to Dolt backend (bd-o0u)") } func TestDoctorRepair_CorruptDatabase_NoJSONL_FixFails(t *testing.T) { - requireTestGuardDisabled(t) - bdExe := buildBDForTest(t) - ws := mkTmpDirInTmp(t, "bd-doctor-chaos-nojsonl-*") - dbPath := filepath.Join(ws, ".beads", "beads.db") - - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "init", "--prefix", "chaos", "--quiet"); err != nil { - t.Fatalf("bd init failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "create", "Chaos issue", "-p", "1"); err != nil { - t.Fatalf("bd create failed: %v", err) - } - - // Some workflows keep JSONL in sync automatically; force it to be missing. - _ = os.Remove(filepath.Join(ws, ".beads", "issues.jsonl")) - _ = os.Remove(filepath.Join(ws, ".beads", "beads.jsonl")) - - // Corrupt without providing JSONL source-of-truth. - if err := os.Truncate(dbPath, 64); err != nil { - t.Fatalf("truncate db: %v", err) - } - - out, err := runBDSideDB(t, bdExe, ws, dbPath, "doctor", "--fix", "--yes") - if err == nil { - t.Fatalf("expected bd doctor --fix to fail without JSONL") - } - if !strings.Contains(out, "cannot auto-recover") { - t.Fatalf("expected auto-recover error, got:\n%s", out) - } - - // Ensure metadata.json doesn't reference system files during failure recovery. - metadata, readErr := os.ReadFile(filepath.Join(ws, ".beads", "metadata.json")) - if readErr == nil { - if strings.Contains(string(metadata), "interactions.jsonl") { - t.Fatalf("unexpected system file reference in metadata.json:\n%s", string(metadata)) - } - } + t.Skip("SQLite file corruption chaos test; not applicable to Dolt backend (bd-o0u)") } func TestDoctorRepair_CorruptDatabase_BacksUpSidecars(t *testing.T) { - requireTestGuardDisabled(t) - bdExe := buildBDForTest(t) - ws := mkTmpDirInTmp(t, "bd-doctor-chaos-sidecars-*") - dbPath := filepath.Join(ws, ".beads", "beads.db") - jsonlPath := filepath.Join(ws, ".beads", "issues.jsonl") - - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "init", "--prefix", "chaos", "--quiet"); err != nil { - t.Fatalf("bd init failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "create", "Chaos issue", "-p", "1"); err != nil { - t.Fatalf("bd create failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "export", "-o", jsonlPath, "--force"); err != nil { - t.Fatalf("bd export failed: %v", err) - } - - // Ensure sidecars exist so we can verify they get moved with the backup. - for _, suffix := range []string{"-wal", "-shm", "-journal"} { - if err := os.WriteFile(dbPath+suffix, []byte("x"), 0644); err != nil { - t.Fatalf("write sidecar %s: %v", suffix, err) - } - } - if err := os.Truncate(dbPath, 64); err != nil { - t.Fatalf("truncate db: %v", err) - } - - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "doctor", "--fix", "--yes"); err != nil { - t.Fatalf("bd doctor --fix failed: %v", err) - } - - // Verify a backup exists, and at least one sidecar got moved. - entries, err := os.ReadDir(filepath.Join(ws, ".beads")) - if err != nil { - t.Fatalf("readdir: %v", err) - } - var backup string - for _, e := range entries { - if strings.Contains(e.Name(), ".corrupt.backup.db") { - backup = filepath.Join(ws, ".beads", e.Name()) - break - } - } - if backup == "" { - t.Fatalf("expected backup db in .beads, found none") - } - - wal := backup + "-wal" - if _, err := os.Stat(wal); err != nil { - // At minimum, the backup DB itself should exist; sidecar backup is best-effort. - if _, err2 := os.Stat(backup); err2 != nil { - t.Fatalf("backup db missing: %v", err2) - } - } + t.Skip("SQLite sidecar (-wal/-shm/-journal) backup test; Dolt has no sidecars (bd-o0u)") } func TestDoctorRepair_CorruptDatabase_WithRunningDaemon_FixSucceeds(t *testing.T) { - requireTestGuardDisabled(t) - bdExe := buildBDForTest(t) - ws := mkTmpDirInTmp(t, "bd-doctor-chaos-daemon-*") - dbPath := filepath.Join(ws, ".beads", "beads.db") - jsonlPath := filepath.Join(ws, ".beads", "issues.jsonl") - - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "init", "--prefix", "chaos", "--quiet"); err != nil { - t.Fatalf("bd init failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "create", "Chaos issue", "-p", "1"); err != nil { - t.Fatalf("bd create failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "export", "-o", jsonlPath, "--force"); err != nil { - t.Fatalf("bd export failed: %v", err) - } - - cmd := startDaemonForChaosTest(t, bdExe, ws, dbPath) - defer func() { - if cmd.Process != nil && (cmd.ProcessState == nil || !cmd.ProcessState.Exited()) { - _ = cmd.Process.Kill() - _, _ = cmd.Process.Wait() - } - }() - - // Corrupt the DB. - if err := os.WriteFile(dbPath, []byte("not a database"), 0644); err != nil { - t.Fatalf("corrupt db: %v", err) - } - - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "doctor", "--fix", "--yes"); err != nil { - t.Fatalf("bd doctor --fix failed: %v", err) - } - - // Ensure we can cleanly stop the daemon afterwards (repair shouldn't wedge it). - if cmd.Process != nil { - _ = cmd.Process.Kill() - done := make(chan error, 1) - go func() { done <- cmd.Wait() }() - select { - case <-time.After(3 * time.Second): - t.Fatalf("expected daemon to exit when killed") - case <-done: - // ok - } - } + t.Skip("SQLite file corruption with daemon test; not applicable to Dolt backend (bd-o0u)") } func TestDoctorRepair_JSONLIntegrity_MalformedLine_ReexportFromDB(t *testing.T) { - requireTestGuardDisabled(t) - bdExe := buildBDForTest(t) - ws := mkTmpDirInTmp(t, "bd-doctor-chaos-jsonl-*") - dbPath := filepath.Join(ws, ".beads", "beads.db") - jsonlPath := filepath.Join(ws, ".beads", "issues.jsonl") - - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "init", "--prefix", "chaos", "--quiet"); err != nil { - t.Fatalf("bd init failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "create", "Chaos issue", "-p", "1"); err != nil { - t.Fatalf("bd create failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "export", "-o", jsonlPath, "--force"); err != nil { - t.Fatalf("bd export failed: %v", err) - } - - // Corrupt JSONL (leave DB intact). - f, err := os.OpenFile(jsonlPath, os.O_APPEND|os.O_WRONLY, 0644) - if err != nil { - t.Fatalf("open jsonl: %v", err) - } - if _, err := f.WriteString("{not json}\n"); err != nil { - _ = f.Close() - t.Fatalf("append corrupt jsonl: %v", err) - } - _ = f.Close() - - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "doctor", "--fix", "--yes"); err != nil { - t.Fatalf("bd doctor --fix failed: %v", err) - } - - data, err := os.ReadFile(jsonlPath) - if err != nil { - t.Fatalf("read jsonl: %v", err) - } - if strings.Contains(string(data), "{not json}") { - t.Fatalf("expected JSONL to be regenerated without corrupt line") - } + t.Skip("SQLite JSONL re-export chaos test; not applicable to Dolt backend (bd-o0u)") } func TestDoctorRepair_DatabaseIntegrity_DBWriteLocked_ImportFailsFast(t *testing.T) { - requireTestGuardDisabled(t) - bdExe := buildBDForTest(t) - ws := mkTmpDirInTmp(t, "bd-doctor-chaos-db-locked-*") - dbPath := filepath.Join(ws, ".beads", "beads.db") - jsonlPath := filepath.Join(ws, ".beads", "issues.jsonl") - - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "init", "--prefix", "chaos", "--quiet"); err != nil { - t.Fatalf("bd init failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "create", "Chaos issue", "-p", "1"); err != nil { - t.Fatalf("bd create failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "export", "-o", jsonlPath, "--force"); err != nil { - t.Fatalf("bd export failed: %v", err) - } - - // Lock the DB for writes in-process. - db, err := sql.Open("sqlite3", dbPath) - if err != nil { - t.Fatalf("open db: %v", err) - } - defer db.Close() - tx, err := db.Begin() - if err != nil { - t.Fatalf("begin tx: %v", err) - } - if _, err := tx.Exec("INSERT INTO issues (id, title, status) VALUES ('lock-test', 'Lock Test', 'open')"); err != nil { - _ = tx.Rollback() - t.Fatalf("insert lock row: %v", err) - } - defer func() { _ = tx.Rollback() }() - - ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) - defer cancel() - out, err := runBDWithEnv(ctx, bdExe, ws, dbPath, map[string]string{ - "BD_LOCK_TIMEOUT": "200ms", - }, "import", "-i", jsonlPath, "--force", "--skip-existing", "--no-git-history") - if err == nil { - t.Fatalf("expected bd import to fail under DB write lock") - } - if ctx.Err() == context.DeadlineExceeded { - t.Fatalf("import exceeded timeout (likely hung); output:\n%s", out) - } - low := strings.ToLower(out) - if !strings.Contains(low, "locked") && !strings.Contains(low, "busy") && !strings.Contains(low, "timeout") { - t.Fatalf("expected lock/busy/timeout error, got:\n%s", out) - } + t.Skip("SQLite write-lock chaos test; Dolt uses server connections, not file locks (bd-o0u)") } func TestDoctorRepair_CorruptDatabase_ReadOnlyBeadsDir_PermissionsFixMakesWritable(t *testing.T) { - requireTestGuardDisabled(t) - bdExe := buildBDForTest(t) - ws := mkTmpDirInTmp(t, "bd-doctor-chaos-readonly-*") - beadsDir := filepath.Join(ws, ".beads") - dbPath := filepath.Join(beadsDir, "beads.db") - jsonlPath := filepath.Join(beadsDir, "issues.jsonl") - - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "init", "--prefix", "chaos", "--quiet"); err != nil { - t.Fatalf("bd init failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "create", "Chaos issue", "-p", "1"); err != nil { - t.Fatalf("bd create failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "export", "-o", jsonlPath, "--force"); err != nil { - t.Fatalf("bd export failed: %v", err) - } - - // Corrupt the DB. - if err := os.Truncate(dbPath, 64); err != nil { - t.Fatalf("truncate db: %v", err) - } - - // Make .beads read-only; the Permissions fix should make it writable again. - if err := os.Chmod(beadsDir, 0555); err != nil { - t.Fatalf("chmod beads dir: %v", err) - } - t.Cleanup(func() { _ = os.Chmod(beadsDir, 0755) }) - - if out, err := runBDSideDB(t, bdExe, ws, dbPath, "doctor", "--fix", "--yes"); err != nil { - t.Fatalf("expected bd doctor --fix to succeed (permissions auto-fix), got: %v\n%s", err, out) - } - info, err := os.Stat(beadsDir) - if err != nil { - t.Fatalf("stat beads dir: %v", err) - } - if info.Mode().Perm()&0200 == 0 { - t.Fatalf("expected .beads to be writable after permissions fix, mode=%v", info.Mode().Perm()) - } + t.Skip("SQLite file corruption + read-only dir chaos test; not applicable to Dolt backend (bd-o0u)") } func startDaemonForChaosTest(t *testing.T, bdExe, ws, dbPath string) *exec.Cmd { diff --git a/cmd/bd/doctor_repair_test.go b/cmd/bd/doctor_repair_test.go index bc8fd73f7..f77c1e964 100644 --- a/cmd/bd/doctor_repair_test.go +++ b/cmd/bd/doctor_repair_test.go @@ -1,12 +1,10 @@ package main import ( - "encoding/json" "os" "os/exec" "path/filepath" "runtime" - "strings" "testing" ) @@ -57,94 +55,7 @@ func runBDSideDB(t *testing.T, exe, dir, dbPath string, args ...string) (string, } func TestDoctorRepair_CorruptDatabase_RebuildFromJSONL(t *testing.T) { - requireTestGuardDisabled(t) - - if testing.Short() { - t.Skip("skipping slow repair test in short mode") - } - - bdExe := buildBDForTest(t) - ws := mkTmpDirInTmp(t, "bd-doctor-repair-*") - dbPath := filepath.Join(ws, ".beads", "beads.db") - jsonlPath := filepath.Join(ws, ".beads", "issues.jsonl") - - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "init", "--prefix", "chaos", "--quiet"); err != nil { - t.Fatalf("bd init failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "create", "Chaos issue", "-p", "1"); err != nil { - t.Fatalf("bd create failed: %v", err) - } - if _, err := runBDSideDB(t, bdExe, ws, dbPath, "export", "-o", jsonlPath, "--force"); err != nil { - t.Fatalf("bd export failed: %v", err) - } - - // Corrupt the SQLite file (truncate) and verify doctor reports an integrity error. - if err := os.Truncate(dbPath, 128); err != nil { - t.Fatalf("truncate db: %v", err) - } - - out, err := runBDSideDB(t, bdExe, ws, dbPath, "doctor", "--json") - if err == nil { - t.Fatalf("expected bd doctor to fail on corrupt db") - } - jsonStart := strings.Index(out, "{") - if jsonStart < 0 { - t.Fatalf("doctor output missing JSON: %s", out) - } - var before doctorResult - if err := json.Unmarshal([]byte(out[jsonStart:]), &before); err != nil { - t.Fatalf("unmarshal doctor json: %v\n%s", err, out) - } - var foundIntegrity bool - for _, c := range before.Checks { - if c.Name == "Database Integrity" { - foundIntegrity = true - if c.Status != statusError { - t.Fatalf("Database Integrity status=%q want %q", c.Status, statusError) - } - } - } - if !foundIntegrity { - t.Fatalf("Database Integrity check not found") - } - - // Attempt auto-repair. - out, err = runBDSideDB(t, bdExe, ws, dbPath, "doctor", "--fix", "--yes") - if err != nil { - t.Fatalf("bd doctor --fix failed: %v\n%s", err, out) - } - - // Doctor should now pass. - out, err = runBDSideDB(t, bdExe, ws, dbPath, "doctor", "--json") - if err != nil { - t.Fatalf("bd doctor after fix failed: %v\n%s", err, out) - } - jsonStart = strings.Index(out, "{") - if jsonStart < 0 { - t.Fatalf("doctor output missing JSON: %s", out) - } - var after doctorResult - if err := json.Unmarshal([]byte(out[jsonStart:]), &after); err != nil { - t.Fatalf("unmarshal doctor json: %v\n%s", err, out) - } - if !after.OverallOK { - t.Fatalf("expected overall_ok=true after repair") - } - - // Data should still be present. - out, err = runBDSideDB(t, bdExe, ws, dbPath, "list", "--json") - if err != nil { - t.Fatalf("bd list failed after repair: %v\n%s", err, out) - } - jsonStart = strings.Index(out, "[") - if jsonStart < 0 { - t.Fatalf("list output missing JSON array: %s", out) - } - var issues []map[string]any - if err := json.Unmarshal([]byte(out[jsonStart:]), &issues); err != nil { - t.Fatalf("unmarshal list json: %v\n%s", err, out) - } - if len(issues) != 1 { - t.Fatalf("expected 1 issue after repair, got %d", len(issues)) - } + // SQLite file corruption repair test. Dolt backend uses server connections, + // not .db files, so corruption/repair scenarios are fundamentally different. + t.Skip("SQLite file corruption repair; not applicable to Dolt backend (bd-o0u)") } diff --git a/cmd/bd/doctor_test.go b/cmd/bd/doctor_test.go index fbc4e3fb8..4b7574de2 100644 --- a/cmd/bd/doctor_test.go +++ b/cmd/bd/doctor_test.go @@ -3,9 +3,7 @@ package main import ( - "database/sql" "encoding/json" - "fmt" "os" "path/filepath" "strings" @@ -104,248 +102,15 @@ func TestDoctorJSONOutput(t *testing.T) { } func TestDetectHashBasedIDs(t *testing.T) { - tests := []struct { - name string - sampleIDs []string - hasTable bool - expected bool - }{ - { - name: "hash IDs with letters", - sampleIDs: []string{"bd-a3f8e9", "bd-b2c4d6"}, - hasTable: false, - expected: true, - }, - { - name: "hash IDs with mixed alphanumeric", - sampleIDs: []string{"bd-0134cc5a", "bd-abc123"}, - hasTable: false, - expected: true, - }, - { - name: "hash IDs all numeric with variable length", - sampleIDs: []string{"bd-0088", "bd-0134cc5a", "bd-02a4"}, - hasTable: false, - expected: true, // Variable length indicates hash IDs - }, - { - name: "hash IDs with leading zeros", - sampleIDs: []string{"bd-0088", "bd-02a4", "bd-05a1"}, - hasTable: false, - expected: true, // Leading zeros indicate hash IDs - }, - { - name: "hash IDs all numeric non-sequential", - sampleIDs: []string{"bd-0088", "bd-2312", "bd-0458"}, - hasTable: false, - expected: true, // Non-sequential pattern - }, - { - name: "sequential IDs", - sampleIDs: []string{"bd-1", "bd-2", "bd-3", "bd-4"}, - hasTable: false, - expected: false, // Sequential pattern - }, - { - name: "sequential IDs with gaps", - sampleIDs: []string{"bd-1", "bd-5", "bd-10", "bd-15"}, - hasTable: false, - expected: false, // Still sequential pattern (small gaps allowed) - }, - { - name: "database with child_counters table", - sampleIDs: []string{"bd-1", "bd-2"}, - hasTable: true, - expected: true, // child_counters table indicates hash IDs - }, - { - name: "hash IDs with hierarchical children", - sampleIDs: []string{"bd-a3f8e9.1", "bd-a3f8e9.2", "bd-b2c4d6"}, - hasTable: false, - expected: true, // Base IDs have letters - }, - { - name: "edge case: single ID with letters", - sampleIDs: []string{"bd-abc"}, - hasTable: false, - expected: true, - }, - { - name: "edge case: single sequential ID", - sampleIDs: []string{"bd-1"}, - hasTable: false, - expected: false, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Create temporary database - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - - // Open database and create schema - db, err := sql.Open("sqlite3", dbPath) - if err != nil { - t.Fatalf("Failed to open database: %v", err) - } - defer db.Close() - - // Create issues table - _, err = db.Exec(` - CREATE TABLE IF NOT EXISTS issues ( - id TEXT PRIMARY KEY, - title TEXT, - created_at TIMESTAMP - ) - `) - if err != nil { - t.Fatalf("Failed to create issues table: %v", err) - } - - // Create child_counters table if test requires it - if tt.hasTable { - _, err = db.Exec(` - CREATE TABLE IF NOT EXISTS child_counters ( - parent_id TEXT PRIMARY KEY, - last_child INTEGER NOT NULL DEFAULT 0 - ) - `) - if err != nil { - t.Fatalf("Failed to create child_counters table: %v", err) - } - } - - // Insert sample issues - for _, id := range tt.sampleIDs { - _, err = db.Exec("INSERT INTO issues (id, title, created_at) VALUES (?, ?, datetime('now'))", - id, "Test issue") - if err != nil { - t.Fatalf("Failed to insert issue %s: %v", id, err) - } - } - - // Test detection - result := doctor.DetectHashBasedIDs(db, tt.sampleIDs) - if result != tt.expected { - t.Errorf("detectHashBasedIDs() = %v, want %v", result, tt.expected) - } - }) - } + // Dolt schema always includes child_counters table, so DetectHashBasedIDs + // always returns true at heuristic 1. The sequential-ID heuristics (hasTable=false) + // are only exercised on legacy SQLite databases without child_counters. + // This test will be removed when DetectHashBasedIDs is removed (bd-o0u.5). + t.Skip("Dolt always has child_counters table; DetectHashBasedIDs always returns true") } func TestCheckIDFormat(t *testing.T) { t.Skip("SQLite-specific: creates SQLite database directly; Dolt backend can't read it") - tests := []struct { - name string - issueIDs []string - createTable bool // create child_counters table - expectedStatus string - }{ - { - name: "hash IDs with letters", - issueIDs: []string{"bd-a3f8e9", "bd-b2c4d6", "bd-xyz123"}, - createTable: false, - expectedStatus: doctor.StatusOK, - }, - { - name: "hash IDs all numeric with leading zeros", - issueIDs: []string{"bd-0088", "bd-02a4", "bd-05a1", "bd-0458"}, - createTable: false, - expectedStatus: doctor.StatusOK, - }, - { - name: "hash IDs with child_counters table", - issueIDs: []string{"bd-123", "bd-456"}, - createTable: true, - expectedStatus: doctor.StatusOK, - }, - { - name: "sequential IDs", - issueIDs: []string{"bd-1", "bd-2", "bd-3", "bd-4"}, - createTable: false, - expectedStatus: doctor.StatusWarning, - }, - { - name: "mixed: mostly hash IDs", - issueIDs: []string{"bd-0088", "bd-0134cc5a", "bd-02a4"}, - createTable: false, - expectedStatus: doctor.StatusOK, // Variable length = hash IDs - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Create temporary workspace - tmpDir := t.TempDir() - beadsDir := filepath.Join(tmpDir, ".beads") - if err := os.Mkdir(beadsDir, 0750); err != nil { - t.Fatal(err) - } - - // Create database - dbPath := filepath.Join(beadsDir, "beads.db") - db, err := sql.Open("sqlite3", dbPath) - if err != nil { - t.Fatalf("Failed to open database: %v", err) - } - defer db.Close() - - // Create schema - _, err = db.Exec(` - CREATE TABLE IF NOT EXISTS issues ( - id TEXT PRIMARY KEY, - title TEXT NOT NULL, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP - ) - `) - if err != nil { - t.Fatalf("Failed to create issues table: %v", err) - } - - if tt.createTable { - _, err = db.Exec(` - CREATE TABLE IF NOT EXISTS child_counters ( - parent_id TEXT PRIMARY KEY, - last_child INTEGER NOT NULL DEFAULT 0 - ) - `) - if err != nil { - t.Fatalf("Failed to create child_counters table: %v", err) - } - } - - // Insert test issues - for i, id := range tt.issueIDs { - _, err = db.Exec( - "INSERT INTO issues (id, title, created_at) VALUES (?, ?, datetime('now', ?||' seconds'))", - id, "Test issue "+id, fmt.Sprintf("+%d", i)) - if err != nil { - t.Fatalf("Failed to insert issue %s: %v", id, err) - } - } - db.Close() - - // Run check - check := doctor.CheckIDFormat(tmpDir) - - if check.Status != tt.expectedStatus { - t.Errorf("Expected status %s, got %s (message: %s)", tt.expectedStatus, check.Status, check.Message) - } - - if tt.expectedStatus == doctor.StatusOK && check.Status == doctor.StatusOK { - if !strings.Contains(check.Message, "hash-based") { - t.Errorf("Expected hash-based message, got: %s", check.Message) - } - } - - if tt.expectedStatus == doctor.StatusWarning && check.Status == doctor.StatusWarning { - if check.Fix == "" { - t.Error("Expected fix message for sequential IDs") - } - } - }) - } } func TestCheckInstallation(t *testing.T) { diff --git a/cmd/bd/gate_test.go b/cmd/bd/gate_test.go index 04d56840e..3367f6d69 100644 --- a/cmd/bd/gate_test.go +++ b/cmd/bd/gate_test.go @@ -2,14 +2,9 @@ package main import ( "context" - "database/sql" "os" - "path/filepath" "testing" - "time" - _ "github.com/ncruces/go-sqlite3/driver" - _ "github.com/ncruces/go-sqlite3/embed" "github.com/steveyegge/beads/internal/types" ) @@ -142,61 +137,9 @@ func TestCheckBeadGate_RigNotFound(t *testing.T) { } func TestCheckBeadGate_TargetClosed(t *testing.T) { - // Create a temporary database that simulates a target rig - tmpDir, err := os.MkdirTemp("", "bead_gate_test") - if err != nil { - t.Fatal(err) - } - defer os.RemoveAll(tmpDir) - - // Create a minimal database with a closed issue - dbPath := filepath.Join(tmpDir, "beads.db") - db, err := sql.Open("sqlite3", dbPath) - if err != nil { - t.Fatal(err) - } - - // Create minimal schema - _, err = db.Exec(` - CREATE TABLE issues ( - id TEXT PRIMARY KEY, - status TEXT, - title TEXT, - created_at TEXT, - updated_at TEXT - ) - `) - if err != nil { - t.Fatal(err) - } - - // Insert a closed issue - now := time.Now().Format(time.RFC3339) - _, err = db.Exec(` - INSERT INTO issues (id, status, title, created_at, updated_at) - VALUES (?, ?, ?, ?, ?) - `, "gt-test123", string(types.StatusClosed), "Test Issue", now, now) - if err != nil { - t.Fatal(err) - } - - // Insert an open issue - _, err = db.Exec(` - INSERT INTO issues (id, status, title, created_at, updated_at) - VALUES (?, ?, ?, ?, ?) - `, "gt-open456", string(types.StatusOpen), "Open Issue", now, now) - if err != nil { - t.Fatal(err) - } - - db.Close() - - // Note: This test can't fully exercise checkBeadGate because it relies on - // routing.ResolveBeadsDirForRig which needs a proper routes.jsonl setup. - // The full integration test would need the town/rig infrastructure. - // For now, we just verify the function signature and basic error handling. - t.Log("Database created with closed issue gt-test123 and open issue gt-open456") - t.Log("Full integration testing requires routes.jsonl setup") + // This test previously created a SQLite DB but never passed it to checkBeadGate. + // Full integration testing requires routes.jsonl + town/rig infrastructure. + t.Skip("Requires routes.jsonl integration setup; SQLite fixture removed in bd-o0u.1") } func TestIsNumericID(t *testing.T) {