cd8cb8b86a
This commit addresses critical code review findings from bd-dvd and bd-ymj fixes: ## Completed Tasks ### bd-ar2.1: Extract duplicated metadata update code - Created `updateExportMetadata()` helper function - Eliminated 22-line duplication between createExportFunc and createSyncFunc - Single source of truth for metadata updates ### bd-ar2.2: Add multi-repo support to export metadata updates - Added per-repo metadata key tracking with keySuffix parameter - Both export and sync functions now update metadata for all repos ### bd-ar2.3: Fix tests to use actual daemon functions - TestExportUpdatesMetadata now calls updateExportMetadata() directly - Added TestUpdateExportMetadataMultiRepo() for multi-repo testing - Fixed export_mtime_test.go tests to call updateExportMetadata() ### bd-ar2.9: Fix variable shadowing in GetNextChildID - Changed `err` to `resurrectErr` to avoid shadowing - Improves code clarity and passes linter checks ### bd-ar2.10: Fix hasJSONLChanged to support per-repo keys - Updated hasJSONLChanged() to accept keySuffix parameter - Reads metadata with correct per-repo keys - All callers updated (validatePreExport, daemon import, sync command) ### bd-ar2.11: Use stable repo identifiers instead of paths - Added getRepoKeyForPath() helper function - Uses stable identifiers like ".", "../frontend" instead of absolute paths - Metadata keys now portable across machines and clones - Prevents orphaned metadata when repos are moved ## Files Changed - cmd/bd/daemon_sync.go: Helper functions, metadata updates - cmd/bd/integrity.go: hasJSONLChanged() with keySuffix support - cmd/bd/sync.go: Updated to use getRepoKeyForPath() - cmd/bd/*_test.go: Tests updated for new signatures - internal/storage/sqlite/hash_ids.go: Fixed variable shadowing ## Testing All export, sync, and integrity tests pass. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
498 lines
14 KiB
Go
498 lines
14 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/steveyegge/beads/internal/storage/sqlite"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
)
|
|
|
|
func TestExportToJSONLWithStore(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
dbPath := filepath.Join(tmpDir, ".beads", "beads.db")
|
|
jsonlPath := filepath.Join(tmpDir, ".beads", "issues.jsonl")
|
|
|
|
// Create storage
|
|
store, err := sqlite.New(context.Background(), dbPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to create store: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
ctx := context.Background()
|
|
|
|
// Set issue_prefix to prevent "database not initialized" errors
|
|
if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("failed to set issue_prefix: %v", err)
|
|
}
|
|
|
|
// Create test issue
|
|
issue := &types.Issue{
|
|
ID: "test-1",
|
|
Title: "Test Issue",
|
|
Description: "Test description",
|
|
IssueType: types.TypeBug,
|
|
Priority: 1,
|
|
Status: types.StatusOpen,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
}
|
|
|
|
if err := store.CreateIssue(ctx, issue, "test"); err != nil {
|
|
t.Fatalf("failed to create issue: %v", err)
|
|
}
|
|
|
|
// Export to JSONL
|
|
if err := exportToJSONLWithStore(ctx, store, jsonlPath); err != nil {
|
|
t.Fatalf("exportToJSONLWithStore failed: %v", err)
|
|
}
|
|
|
|
// Verify file exists
|
|
if _, err := os.Stat(jsonlPath); os.IsNotExist(err) {
|
|
t.Fatal("JSONL file was not created")
|
|
}
|
|
|
|
// Read and verify content
|
|
data, err := os.ReadFile(jsonlPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to read JSONL: %v", err)
|
|
}
|
|
|
|
var exported types.Issue
|
|
if err := json.Unmarshal(data, &exported); err != nil {
|
|
t.Fatalf("failed to unmarshal JSONL: %v", err)
|
|
}
|
|
|
|
if exported.ID != "test-1" {
|
|
t.Errorf("expected ID 'test-1', got %s", exported.ID)
|
|
}
|
|
if exported.Title != "Test Issue" {
|
|
t.Errorf("expected title 'Test Issue', got %s", exported.Title)
|
|
}
|
|
}
|
|
|
|
func TestExportToJSONLWithStore_EmptyDatabase(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
dbPath := filepath.Join(tmpDir, ".beads", "beads.db")
|
|
jsonlPath := filepath.Join(tmpDir, ".beads", "issues.jsonl")
|
|
|
|
// Create storage (empty)
|
|
store, err := sqlite.New(context.Background(), dbPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to create store: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
ctx := context.Background()
|
|
|
|
// Create existing JSONL with content
|
|
if err := os.MkdirAll(filepath.Dir(jsonlPath), 0755); err != nil {
|
|
t.Fatalf("failed to create directory: %v", err)
|
|
}
|
|
|
|
existingIssue := &types.Issue{
|
|
ID: "existing-1",
|
|
Title: "Existing",
|
|
Status: types.StatusOpen,
|
|
Priority: 1,
|
|
IssueType: types.TypeBug,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
}
|
|
data, _ := json.Marshal(existingIssue)
|
|
if err := os.WriteFile(jsonlPath, append(data, '\n'), 0644); err != nil {
|
|
t.Fatalf("failed to write existing JSONL: %v", err)
|
|
}
|
|
|
|
// Should refuse to export empty DB over non-empty JSONL
|
|
err = exportToJSONLWithStore(ctx, store, jsonlPath)
|
|
if err == nil {
|
|
t.Fatal("expected error when exporting empty DB over non-empty JSONL")
|
|
}
|
|
}
|
|
|
|
func TestImportToJSONLWithStore(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
dbPath := filepath.Join(tmpDir, ".beads", "beads.db")
|
|
jsonlPath := filepath.Join(tmpDir, ".beads", "issues.jsonl")
|
|
|
|
// Create storage first to initialize database
|
|
store, err := sqlite.New(context.Background(), dbPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to create store: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
ctx := context.Background()
|
|
|
|
// Set issue_prefix to prevent "database not initialized" errors
|
|
if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("failed to set issue_prefix: %v", err)
|
|
}
|
|
|
|
// Create JSONL with test data
|
|
if err := os.MkdirAll(filepath.Dir(jsonlPath), 0755); err != nil {
|
|
t.Fatalf("failed to create directory: %v", err)
|
|
}
|
|
|
|
issue := &types.Issue{
|
|
ID: "test-1",
|
|
Title: "Test Issue",
|
|
Description: "Test description",
|
|
IssueType: types.TypeBug,
|
|
Priority: 1,
|
|
Status: types.StatusOpen,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
}
|
|
|
|
data, _ := json.Marshal(issue)
|
|
if err := os.WriteFile(jsonlPath, append(data, '\n'), 0644); err != nil {
|
|
t.Fatalf("failed to write JSONL: %v", err)
|
|
}
|
|
|
|
// Import from JSONL
|
|
if err := importToJSONLWithStore(ctx, store, jsonlPath); err != nil {
|
|
t.Fatalf("importToJSONLWithStore failed: %v", err)
|
|
}
|
|
|
|
// Verify issue was imported
|
|
imported, err := store.GetIssue(ctx, "test-1")
|
|
if err != nil {
|
|
t.Fatalf("failed to get imported issue: %v", err)
|
|
}
|
|
|
|
if imported.Title != "Test Issue" {
|
|
t.Errorf("expected title 'Test Issue', got %s", imported.Title)
|
|
}
|
|
}
|
|
|
|
func TestExportImportRoundTrip(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
dbPath := filepath.Join(tmpDir, ".beads", "beads.db")
|
|
jsonlPath := filepath.Join(tmpDir, ".beads", "issues.jsonl")
|
|
|
|
// Create storage and add issues
|
|
store, err := sqlite.New(context.Background(), dbPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to create store: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
ctx := context.Background()
|
|
|
|
// Set issue_prefix to prevent "database not initialized" errors
|
|
if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("failed to set issue_prefix: %v", err)
|
|
}
|
|
|
|
// Create multiple issues with dependencies
|
|
issue1 := &types.Issue{
|
|
ID: "test-1",
|
|
Title: "Issue 1",
|
|
Status: types.StatusOpen,
|
|
Priority: 1,
|
|
IssueType: types.TypeBug,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
}
|
|
issue2 := &types.Issue{
|
|
ID: "test-2",
|
|
Title: "Issue 2",
|
|
Status: types.StatusOpen,
|
|
Priority: 2,
|
|
IssueType: types.TypeFeature,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
}
|
|
|
|
if err := store.CreateIssue(ctx, issue1, "test"); err != nil {
|
|
t.Fatalf("failed to create issue1: %v", err)
|
|
}
|
|
if err := store.CreateIssue(ctx, issue2, "test"); err != nil {
|
|
t.Fatalf("failed to create issue2: %v", err)
|
|
}
|
|
|
|
// Add dependency
|
|
dep := &types.Dependency{
|
|
IssueID: "test-2",
|
|
DependsOnID: "test-1",
|
|
Type: types.DepBlocks,
|
|
}
|
|
if err := store.AddDependency(ctx, dep, "test"); err != nil {
|
|
t.Fatalf("failed to add dependency: %v", err)
|
|
}
|
|
|
|
// Add labels
|
|
if err := store.AddLabel(ctx, "test-1", "bug", "test"); err != nil {
|
|
t.Fatalf("failed to add label: %v", err)
|
|
}
|
|
|
|
// Export
|
|
if err := exportToJSONLWithStore(ctx, store, jsonlPath); err != nil {
|
|
t.Fatalf("export failed: %v", err)
|
|
}
|
|
|
|
// Create new database
|
|
dbPath2 := filepath.Join(tmpDir, ".beads", "beads2.db")
|
|
store2, err := sqlite.New(context.Background(), dbPath2)
|
|
if err != nil {
|
|
t.Fatalf("failed to create store2: %v", err)
|
|
}
|
|
defer store2.Close()
|
|
|
|
// Set issue_prefix for second database
|
|
if err := store2.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("failed to set issue_prefix for store2: %v", err)
|
|
}
|
|
|
|
// Import
|
|
if err := importToJSONLWithStore(ctx, store2, jsonlPath); err != nil {
|
|
t.Fatalf("import failed: %v", err)
|
|
}
|
|
|
|
// Verify issues
|
|
imported1, err := store2.GetIssue(ctx, "test-1")
|
|
if err != nil {
|
|
t.Fatalf("failed to get imported issue1: %v", err)
|
|
}
|
|
if imported1.Title != "Issue 1" {
|
|
t.Errorf("expected title 'Issue 1', got %s", imported1.Title)
|
|
}
|
|
|
|
imported2, err := store2.GetIssue(ctx, "test-2")
|
|
if err != nil {
|
|
t.Fatalf("failed to get imported issue2: %v", err)
|
|
}
|
|
if imported2.Title != "Issue 2" {
|
|
t.Errorf("expected title 'Issue 2', got %s", imported2.Title)
|
|
}
|
|
|
|
// Verify dependency
|
|
deps, err := store2.GetDependencies(ctx, "test-2")
|
|
if err != nil {
|
|
t.Fatalf("failed to get dependencies: %v", err)
|
|
}
|
|
if len(deps) != 1 || deps[0].ID != "test-1" {
|
|
t.Errorf("expected dependency test-2 -> test-1, got %v", deps)
|
|
}
|
|
|
|
// Verify labels
|
|
labels, err := store2.GetLabels(ctx, "test-1")
|
|
if err != nil {
|
|
t.Fatalf("failed to get labels: %v", err)
|
|
}
|
|
if len(labels) != 1 || labels[0] != "bug" {
|
|
t.Errorf("expected label 'bug', got %v", labels)
|
|
}
|
|
}
|
|
|
|
// TestExportUpdatesMetadata verifies that export updates last_import_hash metadata (bd-ymj fix)
|
|
func TestExportUpdatesMetadata(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
dbPath := filepath.Join(tmpDir, ".beads", "beads.db")
|
|
jsonlPath := filepath.Join(tmpDir, ".beads", "issues.jsonl")
|
|
|
|
// Create storage
|
|
store, err := sqlite.New(context.Background(), dbPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to create store: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
ctx := context.Background()
|
|
|
|
// Set issue_prefix
|
|
if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("failed to set issue_prefix: %v", err)
|
|
}
|
|
|
|
// Create test issue
|
|
issue := &types.Issue{
|
|
ID: "test-1",
|
|
Title: "Test Issue",
|
|
Description: "Test description",
|
|
IssueType: types.TypeBug,
|
|
Priority: 1,
|
|
Status: types.StatusOpen,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
}
|
|
|
|
if err := store.CreateIssue(ctx, issue, "test"); err != nil {
|
|
t.Fatalf("failed to create issue: %v", err)
|
|
}
|
|
|
|
// First export
|
|
if err := exportToJSONLWithStore(ctx, store, jsonlPath); err != nil {
|
|
t.Fatalf("first export failed: %v", err)
|
|
}
|
|
|
|
// Update metadata using the actual daemon helper function (bd-ar2.3 fix)
|
|
// This verifies that updateExportMetadata (used by createExportFunc and createSyncFunc) works correctly
|
|
mockLogger := daemonLogger{
|
|
logFunc: func(format string, args ...interface{}) {
|
|
t.Logf(format, args...)
|
|
},
|
|
}
|
|
updateExportMetadata(ctx, store, jsonlPath, mockLogger, "")
|
|
|
|
// Verify metadata was set
|
|
lastHash, err := store.GetMetadata(ctx, "last_import_hash")
|
|
if err != nil {
|
|
t.Fatalf("failed to get last_import_hash: %v", err)
|
|
}
|
|
if lastHash == "" {
|
|
t.Error("expected last_import_hash to be set after export")
|
|
}
|
|
|
|
lastTime, err := store.GetMetadata(ctx, "last_import_time")
|
|
if err != nil {
|
|
t.Fatalf("failed to get last_import_time: %v", err)
|
|
}
|
|
if lastTime == "" {
|
|
t.Error("expected last_import_time to be set after export")
|
|
}
|
|
|
|
// Second export should succeed without "content has changed" error
|
|
if err := exportToJSONLWithStore(ctx, store, jsonlPath); err != nil {
|
|
t.Fatalf("second export failed (metadata not updated properly): %v", err)
|
|
}
|
|
|
|
// Verify validatePreExport doesn't fail with "content has changed"
|
|
if err := validatePreExport(ctx, store, jsonlPath); err != nil {
|
|
t.Fatalf("validatePreExport failed after metadata update: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestUpdateExportMetadataMultiRepo(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
dbPath := filepath.Join(tmpDir, ".beads", "beads.db")
|
|
jsonlPath1 := filepath.Join(tmpDir, "repo1", ".beads", "issues.jsonl")
|
|
jsonlPath2 := filepath.Join(tmpDir, "repo2", ".beads", "issues.jsonl")
|
|
|
|
// Create storage
|
|
store, err := sqlite.New(context.Background(), dbPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to create store: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
ctx := context.Background()
|
|
|
|
// Set issue_prefix
|
|
if err := store.SetConfig(ctx, "issue_prefix", "test"); err != nil {
|
|
t.Fatalf("failed to set issue_prefix: %v", err)
|
|
}
|
|
|
|
// Create test issues for each repo
|
|
issue1 := &types.Issue{
|
|
ID: "test-1",
|
|
Title: "Test Issue 1",
|
|
Description: "Repo 1 issue",
|
|
IssueType: types.TypeBug,
|
|
Priority: 1,
|
|
Status: types.StatusOpen,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
SourceRepo: "repo1",
|
|
}
|
|
issue2 := &types.Issue{
|
|
ID: "test-2",
|
|
Title: "Test Issue 2",
|
|
Description: "Repo 2 issue",
|
|
IssueType: types.TypeBug,
|
|
Priority: 1,
|
|
Status: types.StatusOpen,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
SourceRepo: "repo2",
|
|
}
|
|
|
|
if err := store.CreateIssue(ctx, issue1, "test"); err != nil {
|
|
t.Fatalf("failed to create issue1: %v", err)
|
|
}
|
|
if err := store.CreateIssue(ctx, issue2, "test"); err != nil {
|
|
t.Fatalf("failed to create issue2: %v", err)
|
|
}
|
|
|
|
// Create directories for JSONL files
|
|
if err := os.MkdirAll(filepath.Dir(jsonlPath1), 0755); err != nil {
|
|
t.Fatalf("failed to create dir for jsonlPath1: %v", err)
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(jsonlPath2), 0755); err != nil {
|
|
t.Fatalf("failed to create dir for jsonlPath2: %v", err)
|
|
}
|
|
|
|
// Export issues to JSONL files
|
|
if err := exportToJSONLWithStore(ctx, store, jsonlPath1); err != nil {
|
|
t.Fatalf("failed to export to jsonlPath1: %v", err)
|
|
}
|
|
if err := exportToJSONLWithStore(ctx, store, jsonlPath2); err != nil {
|
|
t.Fatalf("failed to export to jsonlPath2: %v", err)
|
|
}
|
|
|
|
// Create mock logger
|
|
mockLogger := daemonLogger{
|
|
logFunc: func(format string, args ...interface{}) {
|
|
t.Logf(format, args...)
|
|
},
|
|
}
|
|
|
|
// Update metadata for each repo with different keys (bd-ar2.2 multi-repo support)
|
|
updateExportMetadata(ctx, store, jsonlPath1, mockLogger, jsonlPath1)
|
|
updateExportMetadata(ctx, store, jsonlPath2, mockLogger, jsonlPath2)
|
|
|
|
// Verify per-repo metadata was set with correct keys
|
|
hash1Key := "last_import_hash:" + jsonlPath1
|
|
hash1, err := store.GetMetadata(ctx, hash1Key)
|
|
if err != nil {
|
|
t.Fatalf("failed to get %s: %v", hash1Key, err)
|
|
}
|
|
if hash1 == "" {
|
|
t.Errorf("expected %s to be set", hash1Key)
|
|
}
|
|
|
|
hash2Key := "last_import_hash:" + jsonlPath2
|
|
hash2, err := store.GetMetadata(ctx, hash2Key)
|
|
if err != nil {
|
|
t.Fatalf("failed to get %s: %v", hash2Key, err)
|
|
}
|
|
if hash2 == "" {
|
|
t.Errorf("expected %s to be set", hash2Key)
|
|
}
|
|
|
|
// Verify that single-repo metadata key is NOT set (we're using per-repo keys)
|
|
globalHash, err := store.GetMetadata(ctx, "last_import_hash")
|
|
if err != nil {
|
|
t.Fatalf("failed to get last_import_hash: %v", err)
|
|
}
|
|
if globalHash != "" {
|
|
t.Error("expected global last_import_hash to not be set when using per-repo keys")
|
|
}
|
|
|
|
// Verify mtime metadata was also set per-repo
|
|
mtime1Key := "last_import_mtime:" + jsonlPath1
|
|
mtime1, err := store.GetMetadata(ctx, mtime1Key)
|
|
if err != nil {
|
|
t.Fatalf("failed to get %s: %v", mtime1Key, err)
|
|
}
|
|
if mtime1 == "" {
|
|
t.Errorf("expected %s to be set", mtime1Key)
|
|
}
|
|
|
|
mtime2Key := "last_import_mtime:" + jsonlPath2
|
|
mtime2, err := store.GetMetadata(ctx, mtime2Key)
|
|
if err != nil {
|
|
t.Fatalf("failed to get %s: %v", mtime2Key, err)
|
|
}
|
|
if mtime2 == "" {
|
|
t.Errorf("expected %s to be set", mtime2Key)
|
|
}
|
|
}
|