From 351d2239d66a7040b08ec00a12be7179d1bc5cee Mon Sep 17 00:00:00 2001 From: Steve Yegge Date: Fri, 21 Nov 2025 16:11:56 -0500 Subject: [PATCH] test: Refactor integrity_test.go to use shared DB pattern (bd-1rh P2) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CHANGES: - Reduced from 15 DB setups to 4 shared DBs - TestValidatePreExportSuite: 1 shared DB, 5 subtests - TestValidatePostImport: No DB needed, kept as-is - TestCountDBIssuesSuite: 1 shared DB, 1 subtest - TestHasJSONLChangedSuite: 1 shared DB, 7 subtests (with unique keySuffixes) - TestComputeJSONLHash: No DB needed, kept as-is - TestCheckOrphanedDepsSuite: 1 shared DB, 2 subtests PERFORMANCE: - Before: 0.455s avg (15 DB setups) - After: 0.373s avg (4 DB setups) - Speedup: 1.22x (18% faster) KEY LEARNINGS: - Used unique keySuffix values for hasJSONLChanged subtests to avoid metadata pollution - Metadata keys like last_import_hash are shared across subtests unless keySuffix is used - TestValidatePostImport and TestComputeJSONLHash do not need DB at all PATTERN: Following create_test.go and dep_test.go pattern with shared DB setup Part of Phase 2 test suite optimization (bd-1rh follow-up) 🤖 Generated with Claude Code Co-Authored-By: Claude --- cmd/bd/integrity_test.go | 303 ++++++++++++++++----------------------- 1 file changed, 125 insertions(+), 178 deletions(-) diff --git a/cmd/bd/integrity_test.go b/cmd/bd/integrity_test.go index 2fa46c15..a5a3c906 100644 --- a/cmd/bd/integrity_test.go +++ b/cmd/bd/integrity_test.go @@ -12,57 +12,51 @@ import ( "github.com/steveyegge/beads/internal/types" ) -func TestValidatePreExport(t *testing.T) { +func TestValidatePreExportSuite(t *testing.T) { + tmpDir := t.TempDir() + dbPath := filepath.Join(tmpDir, "test.db") + s := newTestStore(t, dbPath) ctx := context.Background() t.Run("empty DB over non-empty JSONL fails", func(t *testing.T) { - // Create temp directory - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - // Create empty database - store := newTestStore(t, dbPath) + // Create temp directory for JSONL + jsonlTmpDir := t.TempDir() + jsonlPath := filepath.Join(jsonlTmpDir, "issues.jsonl") // Create non-empty JSONL file - jsonlContent := `{"id":"bd-1","title":"Test","status":"open","priority":1} + jsonlContent := `{"id":"test-v1","title":"Test","status":"open","priority":1} ` if err := os.WriteFile(jsonlPath, []byte(jsonlContent), 0600); err != nil { t.Fatalf("Failed to write JSONL: %v", err) } // Should fail validation - err := validatePreExport(ctx, store, jsonlPath) + err := validatePreExport(ctx, s, jsonlPath) if err == nil { t.Error("Expected error for empty DB over non-empty JSONL, got nil") } }) t.Run("non-empty DB over non-empty JSONL succeeds", func(t *testing.T) { - // Create temp directory - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") + // Create temp directory for JSONL + jsonlTmpDir := t.TempDir() + jsonlPath := filepath.Join(jsonlTmpDir, "issues.jsonl") - // Create database with issues - store := newTestStoreWithPrefix(t, dbPath, "bd") - - // Add an issue - ctx := context.Background() + // Add an issue with unique ID prefix issue := &types.Issue{ - ID: "bd-1", + ID: "test-v2", Title: "Test", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, Description: "Test issue", } - if err := store.CreateIssue(ctx, issue, "test"); err != nil { + if err := s.CreateIssue(ctx, issue, "test"); err != nil { t.Fatalf("Failed to create issue: %v", err) } // Create JSONL file - jsonlContent := `{"id":"bd-1","title":"Test","status":"open","priority":1} + jsonlContent := `{"id":"test-v2","title":"Test","status":"open","priority":1} ` if err := os.WriteFile(jsonlPath, []byte(jsonlContent), 0600); err != nil { t.Fatalf("Failed to write JSONL: %v", err) @@ -73,84 +67,69 @@ func TestValidatePreExport(t *testing.T) { if err != nil { t.Fatalf("Failed to compute hash: %v", err) } - if err := store.SetMetadata(ctx, "last_import_hash", hash); err != nil { + if err := s.SetMetadata(ctx, "last_import_hash", hash); err != nil { t.Fatalf("Failed to set hash metadata: %v", err) } // Should pass validation - err = validatePreExport(ctx, store, jsonlPath) + err = validatePreExport(ctx, s, jsonlPath) if err != nil { t.Errorf("Expected no error, got: %v", err) } }) t.Run("empty DB over missing JSONL succeeds", func(t *testing.T) { - // Create temp directory - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - // Create empty database - store := newTestStore(t, dbPath) + // Create temp directory for JSONL + jsonlTmpDir := t.TempDir() + jsonlPath := filepath.Join(jsonlTmpDir, "issues.jsonl") // JSONL doesn't exist // Should pass validation (new repo scenario) - err := validatePreExport(ctx, store, jsonlPath) + err := validatePreExport(ctx, s, jsonlPath) if err != nil { t.Errorf("Expected no error for empty DB with no JSONL, got: %v", err) } }) t.Run("empty DB over unreadable JSONL fails", func(t *testing.T) { - // Create temp directory - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - // Create empty database - store := newTestStore(t, dbPath) + // Create temp directory for JSONL + jsonlTmpDir := t.TempDir() + jsonlPath := filepath.Join(jsonlTmpDir, "issues.jsonl") // Create corrupt/unreadable JSONL file with content - corruptContent := `{"id":"bd-1","title":INVALID JSON` + corruptContent := `{"id":"test-v4","title":INVALID JSON` if err := os.WriteFile(jsonlPath, []byte(corruptContent), 0600); err != nil { t.Fatalf("Failed to write corrupt JSONL: %v", err) } // Should fail validation (can't verify JSONL content, DB is empty, file has content) - err := validatePreExport(ctx, store, jsonlPath) + err := validatePreExport(ctx, s, jsonlPath) if err == nil { t.Error("Expected error for empty DB over unreadable non-empty JSONL, got nil") } }) t.Run("JSONL content changed fails", func(t *testing.T) { - // Create temp 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) - } - dbPath := filepath.Join(beadsDir, "beads.db") - jsonlPath := filepath.Join(beadsDir, "beads.jsonl") + // Create temp directory for JSONL + jsonlTmpDir := t.TempDir() + jsonlPath := filepath.Join(jsonlTmpDir, "issues.jsonl") - // Create database with issue - store := newTestStoreWithPrefix(t, dbPath, "bd") - ctx := context.Background() + // Create issue with unique ID prefix issue := &types.Issue{ - ID: "bd-1", + ID: "test-v5", Title: "Test", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, Description: "Test issue", } - if err := store.CreateIssue(ctx, issue, "test"); err != nil { + if err := s.CreateIssue(ctx, issue, "test"); err != nil { t.Fatalf("Failed to create issue: %v", err) } // Create initial JSONL file - jsonlContent := `{"id":"bd-1","title":"Test","status":"open","priority":1} + jsonlContent := `{"id":"test-v5","title":"Test","status":"open","priority":1} ` if err := os.WriteFile(jsonlPath, []byte(jsonlContent), 0600); err != nil { t.Fatalf("Failed to write JSONL: %v", err) @@ -161,19 +140,19 @@ func TestValidatePreExport(t *testing.T) { if err != nil { t.Fatalf("Failed to compute hash: %v", err) } - if err := store.SetMetadata(ctx, "last_import_hash", hash); err != nil { + if err := s.SetMetadata(ctx, "last_import_hash", hash); err != nil { t.Fatalf("Failed to set hash: %v", err) } // Modify JSONL content (simulates git pull that changed JSONL) - modifiedContent := `{"id":"bd-1","title":"Modified","status":"open","priority":1} + modifiedContent := `{"id":"test-v5","title":"Modified","status":"open","priority":1} ` if err := os.WriteFile(jsonlPath, []byte(modifiedContent), 0600); err != nil { t.Fatalf("Failed to write modified JSONL: %v", err) } // Should fail validation (JSONL content changed, must import first) - err = validatePreExport(ctx, store, jsonlPath) + err = validatePreExport(ctx, s, jsonlPath) if err == nil { t.Error("Expected error for changed JSONL content, got nil") } @@ -206,18 +185,15 @@ func TestValidatePostImport(t *testing.T) { }) } -func TestCountDBIssues(t *testing.T) { +func TestCountDBIssuesSuite(t *testing.T) { + tmpDir := t.TempDir() + dbPath := filepath.Join(tmpDir, "test.db") + s := newTestStoreWithPrefix(t, dbPath, "test") + ctx := context.Background() + t.Run("count issues in database", func(t *testing.T) { - // Create temp directory - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - - // Create database - store := newTestStoreWithPrefix(t, dbPath, "bd") - - ctx := context.Background() // Initially 0 - count, err := countDBIssues(ctx, store) + count, err := countDBIssues(ctx, s) if err != nil { t.Fatalf("Failed to count issues: %v", err) } @@ -225,23 +201,23 @@ func TestCountDBIssues(t *testing.T) { t.Errorf("Expected 0 issues, got %d", count) } - // Add issues + // Add issues with unique IDs for i := 1; i <= 3; i++ { issue := &types.Issue{ - ID: "bd-" + string(rune('0'+i)), + ID: fmt.Sprintf("test-count-%d", i), Title: "Test", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, Description: "Test issue", } - if err := store.CreateIssue(ctx, issue, "test"); err != nil { + if err := s.CreateIssue(ctx, issue, "test"); err != nil { t.Fatalf("Failed to create issue: %v", err) } } // Should be 3 - count, err = countDBIssues(ctx, store) + count, err = countDBIssues(ctx, s) if err != nil { t.Fatalf("Failed to count issues: %v", err) } @@ -251,19 +227,19 @@ func TestCountDBIssues(t *testing.T) { }) } -func TestHasJSONLChanged(t *testing.T) { +func TestHasJSONLChangedSuite(t *testing.T) { + tmpDir := t.TempDir() + dbPath := filepath.Join(tmpDir, "test.db") + s := newTestStore(t, dbPath) ctx := context.Background() t.Run("hash matches - no change", func(t *testing.T) { - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - // Create database - store := newTestStore(t, dbPath) + jsonlTmpDir := t.TempDir() + jsonlPath := filepath.Join(jsonlTmpDir, "issues.jsonl") + keySuffix := "h1" // Create JSONL file - jsonlContent := `{"id":"bd-1","title":"Test","status":"open","priority":1} + jsonlContent := `{"id":"test-h1","title":"Test","status":"open","priority":1} ` if err := os.WriteFile(jsonlPath, []byte(jsonlContent), 0600); err != nil { t.Fatalf("Failed to write JSONL: %v", err) @@ -274,34 +250,31 @@ func TestHasJSONLChanged(t *testing.T) { if err != nil { t.Fatalf("Failed to compute hash: %v", err) } - if err := store.SetMetadata(ctx, "last_import_hash", hash); err != nil { + if err := s.SetMetadata(ctx, "last_import_hash:"+keySuffix, hash); err != nil { t.Fatalf("Failed to set metadata: %v", err) } // Store mtime for fast-path if info, err := os.Stat(jsonlPath); err == nil { mtimeStr := fmt.Sprintf("%d", info.ModTime().Unix()) - if err := store.SetMetadata(ctx, "last_import_mtime", mtimeStr); err != nil { + if err := s.SetMetadata(ctx, "last_import_mtime:"+keySuffix, mtimeStr); err != nil { t.Fatalf("Failed to set mtime: %v", err) } } // Should return false (no change) - if hasJSONLChanged(ctx, store, jsonlPath, "") { + if hasJSONLChanged(ctx, s, jsonlPath, keySuffix) { t.Error("Expected hasJSONLChanged to return false for matching hash") } }) t.Run("hash differs - has changed", func(t *testing.T) { - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - // Create database - store := newTestStore(t, dbPath) + jsonlTmpDir := t.TempDir() + jsonlPath := filepath.Join(jsonlTmpDir, "issues.jsonl") + keySuffix := "h2" // Create initial JSONL file - jsonlContent := `{"id":"bd-1","title":"Test","status":"open","priority":1} + jsonlContent := `{"id":"test-h2","title":"Test","status":"open","priority":1} ` if err := os.WriteFile(jsonlPath, []byte(jsonlContent), 0600); err != nil { t.Fatalf("Failed to write JSONL: %v", err) @@ -312,30 +285,27 @@ func TestHasJSONLChanged(t *testing.T) { if err != nil { t.Fatalf("Failed to compute hash: %v", err) } - if err := store.SetMetadata(ctx, "last_import_hash", hash); err != nil { + if err := s.SetMetadata(ctx, "last_import_hash:"+keySuffix, hash); err != nil { t.Fatalf("Failed to set metadata: %v", err) } // Modify JSONL file - newContent := `{"id":"bd-1","title":"Modified","status":"open","priority":1} + newContent := `{"id":"test-h2","title":"Modified","status":"open","priority":1} ` if err := os.WriteFile(jsonlPath, []byte(newContent), 0600); err != nil { t.Fatalf("Failed to write modified JSONL: %v", err) } // Should return true (content changed) - if !hasJSONLChanged(ctx, store, jsonlPath, "") { + if !hasJSONLChanged(ctx, s, jsonlPath, keySuffix) { t.Error("Expected hasJSONLChanged to return true for different hash") } }) t.Run("empty file", func(t *testing.T) { - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - // Create database - store := newTestStore(t, dbPath) + jsonlTmpDir := t.TempDir() + jsonlPath := filepath.Join(jsonlTmpDir, "issues.jsonl") + keySuffix := "h3" // Create empty JSONL file if err := os.WriteFile(jsonlPath, []byte(""), 0600); err != nil { @@ -343,56 +313,47 @@ func TestHasJSONLChanged(t *testing.T) { } // Should return true (no previous hash, first run) - if !hasJSONLChanged(ctx, store, jsonlPath, "") { + if !hasJSONLChanged(ctx, s, jsonlPath, keySuffix) { t.Error("Expected hasJSONLChanged to return true for empty file with no metadata") } }) t.Run("missing metadata - first run", func(t *testing.T) { - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - // Create database - store := newTestStore(t, dbPath) + jsonlTmpDir := t.TempDir() + jsonlPath := filepath.Join(jsonlTmpDir, "issues.jsonl") + keySuffix := "h4" // Create JSONL file - jsonlContent := `{"id":"bd-1","title":"Test","status":"open","priority":1} + jsonlContent := `{"id":"test-h4","title":"Test","status":"open","priority":1} ` if err := os.WriteFile(jsonlPath, []byte(jsonlContent), 0600); err != nil { t.Fatalf("Failed to write JSONL: %v", err) } // No metadata stored - should return true (assume changed) - if !hasJSONLChanged(ctx, store, jsonlPath, "") { + if !hasJSONLChanged(ctx, s, jsonlPath, keySuffix) { t.Error("Expected hasJSONLChanged to return true when no metadata exists") } }) t.Run("file read error", func(t *testing.T) { - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - jsonlPath := filepath.Join(tmpDir, "nonexistent.jsonl") - - // Create database - store := newTestStore(t, dbPath) + jsonlTmpDir := t.TempDir() + jsonlPath := filepath.Join(jsonlTmpDir, "nonexistent.jsonl") + keySuffix := "h5" // File doesn't exist - should return false (don't auto-import broken files) - if hasJSONLChanged(ctx, store, jsonlPath, "") { + if hasJSONLChanged(ctx, s, jsonlPath, keySuffix) { t.Error("Expected hasJSONLChanged to return false for nonexistent file") } }) t.Run("mtime fast-path - unchanged", func(t *testing.T) { - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - // Create database - store := newTestStore(t, dbPath) + jsonlTmpDir := t.TempDir() + jsonlPath := filepath.Join(jsonlTmpDir, "issues.jsonl") + keySuffix := "h6" // Create JSONL file - jsonlContent := `{"id":"bd-1","title":"Test","status":"open","priority":1} + jsonlContent := `{"id":"test-h6","title":"Test","status":"open","priority":1} ` if err := os.WriteFile(jsonlPath, []byte(jsonlContent), 0600); err != nil { t.Fatalf("Failed to write JSONL: %v", err) @@ -409,31 +370,28 @@ func TestHasJSONLChanged(t *testing.T) { if err != nil { t.Fatalf("Failed to compute hash: %v", err) } - if err := store.SetMetadata(ctx, "last_import_hash", hash); err != nil { + if err := s.SetMetadata(ctx, "last_import_hash:"+keySuffix, hash); err != nil { t.Fatalf("Failed to set hash: %v", err) } mtimeStr := fmt.Sprintf("%d", info.ModTime().Unix()) - if err := store.SetMetadata(ctx, "last_import_mtime", mtimeStr); err != nil { + if err := s.SetMetadata(ctx, "last_import_mtime:"+keySuffix, mtimeStr); err != nil { t.Fatalf("Failed to set mtime: %v", err) } // Should return false using fast-path (mtime unchanged) - if hasJSONLChanged(ctx, store, jsonlPath, "") { + if hasJSONLChanged(ctx, s, jsonlPath, keySuffix) { t.Error("Expected hasJSONLChanged to return false using mtime fast-path") } }) t.Run("mtime changed but content same - git operation scenario", func(t *testing.T) { - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - - // Create database - store := newTestStore(t, dbPath) + jsonlTmpDir := t.TempDir() + jsonlPath := filepath.Join(jsonlTmpDir, "issues.jsonl") + keySuffix := "h7" // Create JSONL file - jsonlContent := `{"id":"bd-1","title":"Test","status":"open","priority":1} + jsonlContent := `{"id":"test-h7","title":"Test","status":"open","priority":1} ` if err := os.WriteFile(jsonlPath, []byte(jsonlContent), 0600); err != nil { t.Fatalf("Failed to write JSONL: %v", err) @@ -450,12 +408,12 @@ func TestHasJSONLChanged(t *testing.T) { if err != nil { t.Fatalf("Failed to compute hash: %v", err) } - if err := store.SetMetadata(ctx, "last_import_hash", hash); err != nil { + if err := s.SetMetadata(ctx, "last_import_hash:"+keySuffix, hash); err != nil { t.Fatalf("Failed to set hash: %v", err) } oldMtime := fmt.Sprintf("%d", initialInfo.ModTime().Unix()-1000) // Old mtime - if err := store.SetMetadata(ctx, "last_import_mtime", oldMtime); err != nil { + if err := s.SetMetadata(ctx, "last_import_mtime:"+keySuffix, oldMtime); err != nil { t.Fatalf("Failed to set old mtime: %v", err) } @@ -467,7 +425,7 @@ func TestHasJSONLChanged(t *testing.T) { } // Should return false (content hasn't changed despite new mtime) - if hasJSONLChanged(ctx, store, jsonlPath, "") { + if hasJSONLChanged(ctx, s, jsonlPath, keySuffix) { t.Error("Expected hasJSONLChanged to return false for git operation with same content") } }) @@ -478,7 +436,7 @@ func TestComputeJSONLHash(t *testing.T) { tmpDir := t.TempDir() jsonlPath := filepath.Join(tmpDir, "issues.jsonl") - jsonlContent := `{"id":"bd-1","title":"Test","status":"open","priority":1} + jsonlContent := `{"id":"test-ch1","title":"Test","status":"open","priority":1} ` if err := os.WriteFile(jsonlPath, []byte(jsonlContent), 0600); err != nil { t.Fatalf("Failed to write JSONL: %v", err) @@ -503,7 +461,7 @@ func TestComputeJSONLHash(t *testing.T) { jsonlPath1 := filepath.Join(tmpDir, "issues1.jsonl") jsonlPath2 := filepath.Join(tmpDir, "issues2.jsonl") - jsonlContent := `{"id":"bd-1","title":"Test","status":"open","priority":1} + jsonlContent := `{"id":"test-ch2","title":"Test","status":"open","priority":1} ` if err := os.WriteFile(jsonlPath1, []byte(jsonlContent), 0600); err != nil { t.Fatalf("Failed to write JSONL 1: %v", err) @@ -532,10 +490,10 @@ func TestComputeJSONLHash(t *testing.T) { jsonlPath1 := filepath.Join(tmpDir, "issues1.jsonl") jsonlPath2 := filepath.Join(tmpDir, "issues2.jsonl") - if err := os.WriteFile(jsonlPath1, []byte(`{"id":"bd-1"}`), 0600); err != nil { + if err := os.WriteFile(jsonlPath1, []byte(`{"id":"test-ch3a"}`), 0600); err != nil { t.Fatalf("Failed to write JSONL 1: %v", err) } - if err := os.WriteFile(jsonlPath2, []byte(`{"id":"bd-2"}`), 0600); err != nil { + if err := os.WriteFile(jsonlPath2, []byte(`{"id":"test-ch3b"}`), 0600); err != nil { t.Fatalf("Failed to write JSONL 2: %v", err) } @@ -565,55 +523,52 @@ func TestComputeJSONLHash(t *testing.T) { }) } -func TestCheckOrphanedDeps(t *testing.T) { +func TestCheckOrphanedDepsSuite(t *testing.T) { + tmpDir := t.TempDir() + dbPath := filepath.Join(tmpDir, "test.db") + s := newTestStoreWithPrefix(t, dbPath, "test") + ctx := context.Background() + t.Run("function executes without error", func(t *testing.T) { - // Create temp directory - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - - // Create database - store := newTestStoreWithPrefix(t, dbPath, "bd") - - ctx := context.Background() - // Create two issues + // Create two issues with unique IDs issue1 := &types.Issue{ - ID: "bd-1", + ID: "test-orphan-1", Title: "Test 1", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, Description: "Test issue 1", } - if err := store.CreateIssue(ctx, issue1, "test"); err != nil { + if err := s.CreateIssue(ctx, issue1, "test"); err != nil { t.Fatalf("Failed to create issue 1: %v", err) } issue2 := &types.Issue{ - ID: "bd-2", + ID: "test-orphan-2", Title: "Test 2", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, Description: "Test issue 2", } - if err := store.CreateIssue(ctx, issue2, "test"); err != nil { + if err := s.CreateIssue(ctx, issue2, "test"); err != nil { t.Fatalf("Failed to create issue 2: %v", err) } // Add dependency dep := &types.Dependency{ - IssueID: "bd-1", - DependsOnID: "bd-2", + IssueID: "test-orphan-1", + DependsOnID: "test-orphan-2", Type: types.DepBlocks, } - if err := store.AddDependency(ctx, dep, "test"); err != nil { + if err := s.AddDependency(ctx, dep, "test"); err != nil { t.Fatalf("Failed to add dependency: %v", err) } // Check for orphaned deps - should succeed without error // Note: Database maintains referential integrity, so we can't easily create orphaned deps in tests // This test verifies the function executes correctly - orphaned, err := checkOrphanedDeps(ctx, store) + orphaned, err := checkOrphanedDeps(ctx, s) if err != nil { t.Fatalf("Failed to check orphaned deps: %v", err) } @@ -625,51 +580,43 @@ func TestCheckOrphanedDeps(t *testing.T) { }) t.Run("no orphaned dependencies", func(t *testing.T) { - // Create temp directory - tmpDir := t.TempDir() - dbPath := filepath.Join(tmpDir, "test.db") - - // Create database - store := newTestStoreWithPrefix(t, dbPath, "bd") - - ctx := context.Background() - // Create two issues + // Create two issues with unique IDs issue1 := &types.Issue{ - ID: "bd-1", - Title: "Test 1", + ID: "test-orphan-3", + Title: "Test 3", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, - Description: "Test issue 1", + Description: "Test issue 3", } - if err := store.CreateIssue(ctx, issue1, "test"); err != nil { + if err := s.CreateIssue(ctx, issue1, "test"); err != nil { t.Fatalf("Failed to create issue 1: %v", err) } issue2 := &types.Issue{ - ID: "bd-2", - Title: "Test 2", + ID: "test-orphan-4", + Title: "Test 4", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, - Description: "Test issue 2", + Description: "Test issue 4", } - if err := store.CreateIssue(ctx, issue2, "test"); err != nil { + if err := s.CreateIssue(ctx, issue2, "test"); err != nil { t.Fatalf("Failed to create issue 2: %v", err) } // Add valid dependency dep := &types.Dependency{ - IssueID: "bd-1", - DependsOnID: "bd-2", + IssueID: "test-orphan-3", + DependsOnID: "test-orphan-4", Type: types.DepBlocks, } - if err := store.AddDependency(ctx, dep, "test"); err != nil { + if err := s.AddDependency(ctx, dep, "test"); err != nil { t.Fatalf("Failed to add dependency: %v", err) } // Check for orphaned deps - orphaned, err := checkOrphanedDeps(ctx, store) + orphaned, err := checkOrphanedDeps(ctx, s) if err != nil { t.Fatalf("Failed to check orphaned deps: %v", err) }