Steve Yegge
2a6191e49b
Replace fetchAndRebaseInWorktree with contentMergeRecovery in pushFromWorktree. The problem: When push fails due to non-fast-forward, the old code used git rebase to recover. But git rebase is text-level and does not invoke the JSONL merge driver. This could resurrect tombstones - if remote had a tombstone and local had closed, the rebase would overwrite the tombstone. The fix: Use the same content-level merge algorithm that PullFromSyncBranch uses. This respects tombstone semantics - recent tombstones always win over live issues. Changes: - Add contentMergeRecovery() that does content-level merge instead of rebase - Update pushFromWorktree to call contentMergeRecovery - Mark fetchAndRebaseInWorktree as deprecated (kept for reference) - Add tests for tombstone preservation during merge recovery 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
798 lines
26 KiB
Go
798 lines
26 KiB
Go
package syncbranch
|
||
|
||
import (
|
||
"context"
|
||
"os"
|
||
"os/exec"
|
||
"path/filepath"
|
||
"strconv"
|
||
"strings"
|
||
"testing"
|
||
)
|
||
|
||
// TestGetDivergence tests the divergence detection function
|
||
func TestGetDivergence(t *testing.T) {
|
||
if testing.Short() {
|
||
t.Skip("skipping integration test in short mode")
|
||
}
|
||
|
||
ctx := context.Background()
|
||
|
||
t.Run("no divergence when synced", func(t *testing.T) {
|
||
// Create a test repo with a branch
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
|
||
// Create and checkout test branch
|
||
runGit(t, repoDir, "checkout", "-b", "test-branch")
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), `{"id":"test-1"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "initial commit")
|
||
|
||
// Simulate remote by creating a local ref
|
||
runGit(t, repoDir, "update-ref", "refs/remotes/origin/test-branch", "HEAD")
|
||
|
||
localAhead, remoteAhead, err := getDivergence(ctx, repoDir, "test-branch", "origin")
|
||
if err != nil {
|
||
t.Fatalf("getDivergence() error = %v", err)
|
||
}
|
||
if localAhead != 0 || remoteAhead != 0 {
|
||
t.Errorf("getDivergence() = (%d, %d), want (0, 0)", localAhead, remoteAhead)
|
||
}
|
||
})
|
||
|
||
t.Run("local ahead of remote", func(t *testing.T) {
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
|
||
runGit(t, repoDir, "checkout", "-b", "test-branch")
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), `{"id":"test-1"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "initial commit")
|
||
|
||
// Set remote ref to current HEAD
|
||
runGit(t, repoDir, "update-ref", "refs/remotes/origin/test-branch", "HEAD")
|
||
|
||
// Add more local commits
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), `{"id":"test-1"}
|
||
{"id":"test-2"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "second commit")
|
||
|
||
localAhead, remoteAhead, err := getDivergence(ctx, repoDir, "test-branch", "origin")
|
||
if err != nil {
|
||
t.Fatalf("getDivergence() error = %v", err)
|
||
}
|
||
if localAhead != 1 || remoteAhead != 0 {
|
||
t.Errorf("getDivergence() = (%d, %d), want (1, 0)", localAhead, remoteAhead)
|
||
}
|
||
})
|
||
|
||
t.Run("remote ahead of local", func(t *testing.T) {
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
|
||
runGit(t, repoDir, "checkout", "-b", "test-branch")
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), `{"id":"test-1"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "initial commit")
|
||
|
||
// Save current HEAD as "local"
|
||
localHead := strings.TrimSpace(getGitOutput(t, repoDir, "rev-parse", "HEAD"))
|
||
|
||
// Create more commits and set as remote
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), `{"id":"test-1"}
|
||
{"id":"test-2"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "remote commit")
|
||
runGit(t, repoDir, "update-ref", "refs/remotes/origin/test-branch", "HEAD")
|
||
|
||
// Reset local to previous commit
|
||
runGit(t, repoDir, "reset", "--hard", localHead)
|
||
|
||
localAhead, remoteAhead, err := getDivergence(ctx, repoDir, "test-branch", "origin")
|
||
if err != nil {
|
||
t.Fatalf("getDivergence() error = %v", err)
|
||
}
|
||
if localAhead != 0 || remoteAhead != 1 {
|
||
t.Errorf("getDivergence() = (%d, %d), want (0, 1)", localAhead, remoteAhead)
|
||
}
|
||
})
|
||
|
||
t.Run("diverged histories", func(t *testing.T) {
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
|
||
runGit(t, repoDir, "checkout", "-b", "test-branch")
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), `{"id":"test-1"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "base commit")
|
||
|
||
// Save base commit
|
||
baseCommit := strings.TrimSpace(getGitOutput(t, repoDir, "rev-parse", "HEAD"))
|
||
|
||
// Create local commit
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), `{"id":"test-1"}
|
||
{"id":"local-2"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "local commit")
|
||
localHead := strings.TrimSpace(getGitOutput(t, repoDir, "rev-parse", "HEAD"))
|
||
|
||
// Create remote commit from base
|
||
runGit(t, repoDir, "checkout", baseCommit)
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), `{"id":"test-1"}
|
||
{"id":"remote-2"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "remote commit")
|
||
runGit(t, repoDir, "update-ref", "refs/remotes/origin/test-branch", "HEAD")
|
||
|
||
// Go back to local branch
|
||
runGit(t, repoDir, "checkout", "-B", "test-branch", localHead)
|
||
|
||
localAhead, remoteAhead, err := getDivergence(ctx, repoDir, "test-branch", "origin")
|
||
if err != nil {
|
||
t.Fatalf("getDivergence() error = %v", err)
|
||
}
|
||
if localAhead != 1 || remoteAhead != 1 {
|
||
t.Errorf("getDivergence() = (%d, %d), want (1, 1)", localAhead, remoteAhead)
|
||
}
|
||
})
|
||
}
|
||
|
||
// TestExtractJSONLFromCommit tests extracting JSONL content from git commits
|
||
func TestExtractJSONLFromCommit(t *testing.T) {
|
||
if testing.Short() {
|
||
t.Skip("skipping integration test in short mode")
|
||
}
|
||
|
||
ctx := context.Background()
|
||
|
||
t.Run("extracts file from HEAD", func(t *testing.T) {
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
|
||
content := `{"id":"test-1","title":"Test Issue"}`
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), content)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "test commit")
|
||
|
||
extracted, err := extractJSONLFromCommit(ctx, repoDir, "HEAD", ".beads/issues.jsonl")
|
||
if err != nil {
|
||
t.Fatalf("extractJSONLFromCommit() error = %v", err)
|
||
}
|
||
if strings.TrimSpace(string(extracted)) != content {
|
||
t.Errorf("extractJSONLFromCommit() = %q, want %q", extracted, content)
|
||
}
|
||
})
|
||
|
||
t.Run("extracts file from specific commit", func(t *testing.T) {
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
|
||
// First commit
|
||
content1 := `{"id":"test-1"}`
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), content1)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "first commit")
|
||
firstCommit := strings.TrimSpace(getGitOutput(t, repoDir, "rev-parse", "HEAD"))
|
||
|
||
// Second commit
|
||
content2 := `{"id":"test-1"}
|
||
{"id":"test-2"}`
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), content2)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "second commit")
|
||
|
||
// Extract from first commit
|
||
extracted, err := extractJSONLFromCommit(ctx, repoDir, firstCommit, ".beads/issues.jsonl")
|
||
if err != nil {
|
||
t.Fatalf("extractJSONLFromCommit() error = %v", err)
|
||
}
|
||
if strings.TrimSpace(string(extracted)) != content1 {
|
||
t.Errorf("extractJSONLFromCommit() = %q, want %q", extracted, content1)
|
||
}
|
||
})
|
||
|
||
t.Run("returns error for nonexistent file", func(t *testing.T) {
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
|
||
writeFile(t, filepath.Join(repoDir, "dummy.txt"), "dummy")
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "test commit")
|
||
|
||
_, err := extractJSONLFromCommit(ctx, repoDir, "HEAD", ".beads/issues.jsonl")
|
||
if err == nil {
|
||
t.Error("extractJSONLFromCommit() expected error for nonexistent file")
|
||
}
|
||
})
|
||
}
|
||
|
||
// TestPerformContentMerge tests the content-based merge function
|
||
func TestPerformContentMerge(t *testing.T) {
|
||
if testing.Short() {
|
||
t.Skip("skipping integration test in short mode")
|
||
}
|
||
|
||
ctx := context.Background()
|
||
|
||
t.Run("merges diverged content", func(t *testing.T) {
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
|
||
runGit(t, repoDir, "checkout", "-b", "test-branch")
|
||
|
||
// Base content
|
||
baseContent := `{"id":"test-1","title":"Base","created_at":"2024-01-01T00:00:00Z","created_by":"user1"}`
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), baseContent)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "base commit")
|
||
baseCommit := strings.TrimSpace(getGitOutput(t, repoDir, "rev-parse", "HEAD"))
|
||
|
||
// Create local changes (add issue)
|
||
localContent := `{"id":"test-1","title":"Base","created_at":"2024-01-01T00:00:00Z","created_by":"user1"}
|
||
{"id":"local-1","title":"Local Issue","created_at":"2024-01-02T00:00:00Z","created_by":"user1"}`
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), localContent)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "local commit")
|
||
localHead := strings.TrimSpace(getGitOutput(t, repoDir, "rev-parse", "HEAD"))
|
||
|
||
// Create remote changes from base (add different issue)
|
||
runGit(t, repoDir, "checkout", baseCommit)
|
||
remoteContent := `{"id":"test-1","title":"Base","created_at":"2024-01-01T00:00:00Z","created_by":"user1"}
|
||
{"id":"remote-1","title":"Remote Issue","created_at":"2024-01-02T00:00:00Z","created_by":"user2"}`
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), remoteContent)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "remote commit")
|
||
runGit(t, repoDir, "update-ref", "refs/remotes/origin/test-branch", "HEAD")
|
||
|
||
// Go back to local
|
||
runGit(t, repoDir, "checkout", "-B", "test-branch", localHead)
|
||
|
||
// Perform merge
|
||
merged, err := performContentMerge(ctx, repoDir, "test-branch", "origin", ".beads/issues.jsonl")
|
||
if err != nil {
|
||
t.Fatalf("performContentMerge() error = %v", err)
|
||
}
|
||
|
||
// Check that merged content contains all three issues
|
||
mergedStr := string(merged)
|
||
if !strings.Contains(mergedStr, "test-1") {
|
||
t.Error("merged content missing base issue test-1")
|
||
}
|
||
if !strings.Contains(mergedStr, "local-1") {
|
||
t.Error("merged content missing local issue local-1")
|
||
}
|
||
if !strings.Contains(mergedStr, "remote-1") {
|
||
t.Error("merged content missing remote issue remote-1")
|
||
}
|
||
})
|
||
|
||
t.Run("handles deletion correctly", func(t *testing.T) {
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
|
||
runGit(t, repoDir, "checkout", "-b", "test-branch")
|
||
|
||
// Base content with two issues
|
||
baseContent := `{"id":"test-1","title":"Issue 1","created_at":"2024-01-01T00:00:00Z","created_by":"user1"}
|
||
{"id":"test-2","title":"Issue 2","created_at":"2024-01-01T00:00:00Z","created_by":"user1"}`
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), baseContent)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "base commit")
|
||
baseCommit := strings.TrimSpace(getGitOutput(t, repoDir, "rev-parse", "HEAD"))
|
||
|
||
// Local keeps both
|
||
localHead := baseCommit
|
||
|
||
// Remote deletes test-2
|
||
runGit(t, repoDir, "checkout", baseCommit)
|
||
remoteContent := `{"id":"test-1","title":"Issue 1","created_at":"2024-01-01T00:00:00Z","created_by":"user1"}`
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), remoteContent)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "remote delete")
|
||
runGit(t, repoDir, "update-ref", "refs/remotes/origin/test-branch", "HEAD")
|
||
|
||
// Go back to local
|
||
runGit(t, repoDir, "checkout", "-B", "test-branch", localHead)
|
||
|
||
// Perform merge
|
||
merged, err := performContentMerge(ctx, repoDir, "test-branch", "origin", ".beads/issues.jsonl")
|
||
if err != nil {
|
||
t.Fatalf("performContentMerge() error = %v", err)
|
||
}
|
||
|
||
// Deletion should win - test-2 should be gone
|
||
mergedStr := string(merged)
|
||
if !strings.Contains(mergedStr, "test-1") {
|
||
t.Error("merged content missing issue test-1")
|
||
}
|
||
if strings.Contains(mergedStr, "test-2") {
|
||
t.Error("merged content still contains deleted issue test-2")
|
||
}
|
||
})
|
||
}
|
||
|
||
// Helper functions
|
||
|
||
func setupTestRepo(t *testing.T) string {
|
||
t.Helper()
|
||
|
||
tmpDir, err := os.MkdirTemp("", "bd-test-repo-*")
|
||
if err != nil {
|
||
t.Fatalf("Failed to create temp dir: %v", err)
|
||
}
|
||
|
||
// Initialize git repo
|
||
runGit(t, tmpDir, "init")
|
||
runGit(t, tmpDir, "config", "user.email", "test@test.com")
|
||
runGit(t, tmpDir, "config", "user.name", "Test User")
|
||
|
||
// Create .beads directory
|
||
beadsDir := filepath.Join(tmpDir, ".beads")
|
||
if err := os.MkdirAll(beadsDir, 0750); err != nil {
|
||
os.RemoveAll(tmpDir)
|
||
t.Fatalf("Failed to create .beads dir: %v", err)
|
||
}
|
||
|
||
return tmpDir
|
||
}
|
||
|
||
func runGit(t *testing.T, dir string, args ...string) {
|
||
t.Helper()
|
||
cmd := exec.Command("git", args...)
|
||
cmd.Dir = dir
|
||
output, err := cmd.CombinedOutput()
|
||
if err != nil {
|
||
t.Fatalf("git %v failed: %v\n%s", args, err, output)
|
||
}
|
||
}
|
||
|
||
func getGitOutput(t *testing.T, dir string, args ...string) string {
|
||
t.Helper()
|
||
cmd := exec.Command("git", args...)
|
||
cmd.Dir = dir
|
||
output, err := cmd.Output()
|
||
if err != nil {
|
||
t.Fatalf("git %v failed: %v", args, err)
|
||
}
|
||
return string(output)
|
||
}
|
||
|
||
func writeFile(t *testing.T, path, content string) {
|
||
t.Helper()
|
||
dir := filepath.Dir(path)
|
||
if err := os.MkdirAll(dir, 0750); err != nil {
|
||
t.Fatalf("Failed to create directory %s: %v", dir, err)
|
||
}
|
||
if err := os.WriteFile(path, []byte(content), 0644); err != nil {
|
||
t.Fatalf("Failed to write file %s: %v", path, err)
|
||
}
|
||
}
|
||
|
||
// TestParseIssuesFromContent tests the issue parsing helper function (bd-lsa)
|
||
func TestParseIssuesFromContent(t *testing.T) {
|
||
tests := []struct {
|
||
name string
|
||
content []byte
|
||
wantIDs []string
|
||
}{
|
||
{
|
||
name: "empty content",
|
||
content: []byte{},
|
||
wantIDs: []string{},
|
||
},
|
||
{
|
||
name: "nil content",
|
||
content: nil,
|
||
wantIDs: []string{},
|
||
},
|
||
{
|
||
name: "single issue",
|
||
content: []byte(`{"id":"test-1","title":"Test Issue"}`),
|
||
wantIDs: []string{"test-1"},
|
||
},
|
||
{
|
||
name: "multiple issues",
|
||
content: []byte(`{"id":"test-1","title":"Issue 1"}` + "\n" + `{"id":"test-2","title":"Issue 2"}`),
|
||
wantIDs: []string{"test-1", "test-2"},
|
||
},
|
||
{
|
||
name: "malformed line skipped",
|
||
content: []byte(`{"id":"test-1","title":"Valid"}` + "\n" + `invalid json` + "\n" + `{"id":"test-2","title":"Also Valid"}`),
|
||
wantIDs: []string{"test-1", "test-2"},
|
||
},
|
||
{
|
||
name: "empty id skipped",
|
||
content: []byte(`{"id":"","title":"No ID"}` + "\n" + `{"id":"test-1","title":"Has ID"}`),
|
||
wantIDs: []string{"test-1"},
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
got := parseIssuesFromContent(tt.content)
|
||
if len(got) != len(tt.wantIDs) {
|
||
t.Errorf("parseIssuesFromContent() returned %d issues, want %d", len(got), len(tt.wantIDs))
|
||
return
|
||
}
|
||
for _, wantID := range tt.wantIDs {
|
||
if _, exists := got[wantID]; !exists {
|
||
t.Errorf("parseIssuesFromContent() missing expected ID %q", wantID)
|
||
}
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestSafetyCheckMassDeletion tests the safety check behavior for mass deletions (bd-cnn)
|
||
func TestSafetyCheckMassDeletion(t *testing.T) {
|
||
if testing.Short() {
|
||
t.Skip("skipping integration test in short mode")
|
||
}
|
||
|
||
t.Run("safety check triggers when >50% issues vanish and >5 existed", func(t *testing.T) {
|
||
// Test the countIssuesInContent and formatVanishedIssues functions
|
||
// Create local content with 10 issues
|
||
// bd-c5m: Use strconv.Itoa instead of string(rune()) which only works for single digits
|
||
var localLines []string
|
||
for i := 1; i <= 10; i++ {
|
||
localLines = append(localLines, `{"id":"test-`+strconv.Itoa(i)+`","title":"Issue `+strconv.Itoa(i)+`"}`)
|
||
}
|
||
localContent := []byte(strings.Join(localLines, "\n"))
|
||
|
||
// Create merged content with only 4 issues (60% vanished)
|
||
mergedContent := []byte(`{"id":"test-1","title":"Issue 1"}
|
||
{"id":"test-2","title":"Issue 2"}
|
||
{"id":"test-3","title":"Issue 3"}
|
||
{"id":"test-4","title":"Issue 4"}`)
|
||
|
||
localCount := countIssuesInContent(localContent)
|
||
mergedCount := countIssuesInContent(mergedContent)
|
||
|
||
if localCount != 10 {
|
||
t.Errorf("localCount = %d, want 10", localCount)
|
||
}
|
||
if mergedCount != 4 {
|
||
t.Errorf("mergedCount = %d, want 4", mergedCount)
|
||
}
|
||
|
||
// Verify safety check would trigger: >50% vanished AND >5 existed
|
||
if localCount <= 5 {
|
||
t.Error("localCount should be > 5 for safety check to apply")
|
||
}
|
||
vanishedPercent := float64(localCount-mergedCount) / float64(localCount) * 100
|
||
if vanishedPercent <= 50 {
|
||
t.Errorf("vanishedPercent = %.0f%%, want > 50%%", vanishedPercent)
|
||
}
|
||
|
||
// Verify forensic info can be generated
|
||
localIssues := parseIssuesFromContent(localContent)
|
||
mergedIssues := parseIssuesFromContent(mergedContent)
|
||
forensicLines := formatVanishedIssues(localIssues, mergedIssues, localCount, mergedCount)
|
||
if len(forensicLines) == 0 {
|
||
t.Error("formatVanishedIssues returned empty lines")
|
||
}
|
||
|
||
// bd-8uk: Verify SafetyWarnings would be populated correctly
|
||
// Simulate what PullFromSyncBranch does when safety check triggers
|
||
var safetyWarnings []string
|
||
safetyWarnings = append(safetyWarnings,
|
||
"⚠️ Warning: "+strconv.FormatFloat(vanishedPercent, 'f', 0, 64)+"% of issues vanished during merge ("+
|
||
strconv.Itoa(localCount)+" → "+strconv.Itoa(mergedCount)+" issues)")
|
||
safetyWarnings = append(safetyWarnings, forensicLines...)
|
||
|
||
// Verify warnings contains expected content
|
||
if len(safetyWarnings) < 2 {
|
||
t.Errorf("SafetyWarnings should have at least 2 entries (warning + forensics), got %d", len(safetyWarnings))
|
||
}
|
||
if !strings.Contains(safetyWarnings[0], "Warning") {
|
||
t.Error("First SafetyWarning should contain 'Warning'")
|
||
}
|
||
if !strings.Contains(safetyWarnings[0], "60%") {
|
||
t.Errorf("First SafetyWarning should contain '60%%', got: %s", safetyWarnings[0])
|
||
}
|
||
})
|
||
|
||
t.Run("safety check does NOT trigger when <50% issues vanish", func(t *testing.T) {
|
||
// 10 issues, 6 remain = 40% vanished (should NOT trigger)
|
||
// bd-c5m: Use strconv.Itoa instead of string(rune()) which only works for single digits
|
||
var localLines []string
|
||
for i := 1; i <= 10; i++ {
|
||
localLines = append(localLines, `{"id":"test-`+strconv.Itoa(i)+`"}`)
|
||
}
|
||
localContent := []byte(strings.Join(localLines, "\n"))
|
||
|
||
// 6 issues remain (40% vanished)
|
||
var mergedLines []string
|
||
for i := 1; i <= 6; i++ {
|
||
mergedLines = append(mergedLines, `{"id":"test-`+strconv.Itoa(i)+`"}`)
|
||
}
|
||
mergedContent := []byte(strings.Join(mergedLines, "\n"))
|
||
|
||
localCount := countIssuesInContent(localContent)
|
||
mergedCount := countIssuesInContent(mergedContent)
|
||
|
||
vanishedPercent := float64(localCount-mergedCount) / float64(localCount) * 100
|
||
if vanishedPercent > 50 {
|
||
t.Errorf("vanishedPercent = %.0f%%, want <= 50%%", vanishedPercent)
|
||
}
|
||
})
|
||
|
||
t.Run("safety check does NOT trigger when <5 issues existed", func(t *testing.T) {
|
||
// 4 issues, 1 remains = 75% vanished, but only 4 existed (should NOT trigger)
|
||
localContent := []byte(`{"id":"test-1"}
|
||
{"id":"test-2"}
|
||
{"id":"test-3"}
|
||
{"id":"test-4"}`)
|
||
|
||
mergedContent := []byte(`{"id":"test-1"}`)
|
||
|
||
localCount := countIssuesInContent(localContent)
|
||
mergedCount := countIssuesInContent(mergedContent)
|
||
|
||
if localCount != 4 {
|
||
t.Errorf("localCount = %d, want 4", localCount)
|
||
}
|
||
if mergedCount != 1 {
|
||
t.Errorf("mergedCount = %d, want 1", mergedCount)
|
||
}
|
||
|
||
// localCount > 5 is false, so safety check should NOT trigger
|
||
if localCount > 5 {
|
||
t.Error("localCount should be <= 5 for this test case")
|
||
}
|
||
})
|
||
}
|
||
|
||
// TestCountIssuesInContent tests the issue counting helper function (bd-7ch)
|
||
func TestCountIssuesInContent(t *testing.T) {
|
||
tests := []struct {
|
||
name string
|
||
content []byte
|
||
want int
|
||
}{
|
||
{
|
||
name: "empty content",
|
||
content: []byte{},
|
||
want: 0,
|
||
},
|
||
{
|
||
name: "nil content",
|
||
content: nil,
|
||
want: 0,
|
||
},
|
||
{
|
||
name: "single issue",
|
||
content: []byte(`{"id":"test-1"}`),
|
||
want: 1,
|
||
},
|
||
{
|
||
name: "multiple issues",
|
||
content: []byte(`{"id":"test-1"}` + "\n" + `{"id":"test-2"}` + "\n" + `{"id":"test-3"}`),
|
||
want: 3,
|
||
},
|
||
{
|
||
name: "trailing newline",
|
||
content: []byte(`{"id":"test-1"}` + "\n" + `{"id":"test-2"}` + "\n"),
|
||
want: 2,
|
||
},
|
||
{
|
||
name: "empty lines ignored",
|
||
content: []byte(`{"id":"test-1"}` + "\n" + "\n" + `{"id":"test-2"}` + "\n" + " " + "\n"),
|
||
want: 2,
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
got := countIssuesInContent(tt.content)
|
||
if got != tt.want {
|
||
t.Errorf("countIssuesInContent() = %d, want %d", got, tt.want)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestIsSyncBranchSameAsCurrent tests detection of sync.branch == current branch (GH#519)
|
||
func TestIsSyncBranchSameAsCurrent(t *testing.T) {
|
||
if testing.Short() {
|
||
t.Skip("skipping integration test in short mode")
|
||
}
|
||
|
||
ctx := context.Background()
|
||
|
||
t.Run("returns true when sync branch equals current branch", func(t *testing.T) {
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
|
||
// Create initial commit so we can get current branch
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), `{"id":"test-1"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "initial commit")
|
||
|
||
// Get current branch name
|
||
currentBranch := strings.TrimSpace(getGitOutput(t, repoDir, "symbolic-ref", "--short", "HEAD"))
|
||
|
||
// Save original dir and change to test repo
|
||
origDir, _ := os.Getwd()
|
||
os.Chdir(repoDir)
|
||
defer os.Chdir(origDir)
|
||
|
||
// Should return true when sync branch == current branch
|
||
if !IsSyncBranchSameAsCurrent(ctx, currentBranch) {
|
||
t.Errorf("IsSyncBranchSameAsCurrent(%q) = false, want true", currentBranch)
|
||
}
|
||
})
|
||
|
||
t.Run("returns false when sync branch differs from current branch", func(t *testing.T) {
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
|
||
// Create initial commit
|
||
writeFile(t, filepath.Join(repoDir, ".beads", "issues.jsonl"), `{"id":"test-1"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "initial commit")
|
||
|
||
// Save original dir and change to test repo
|
||
origDir, _ := os.Getwd()
|
||
os.Chdir(repoDir)
|
||
defer os.Chdir(origDir)
|
||
|
||
// Should return false when sync branch != current branch
|
||
if IsSyncBranchSameAsCurrent(ctx, "beads-sync") {
|
||
t.Error("IsSyncBranchSameAsCurrent(\"beads-sync\") = true, want false")
|
||
}
|
||
})
|
||
|
||
t.Run("returns false on error getting current branch", func(t *testing.T) {
|
||
// Test in a non-git directory
|
||
tmpDir, _ := os.MkdirTemp("", "non-git-*")
|
||
defer os.RemoveAll(tmpDir)
|
||
|
||
origDir, _ := os.Getwd()
|
||
os.Chdir(tmpDir)
|
||
defer os.Chdir(origDir)
|
||
|
||
// Should return false when not in a git repo
|
||
if IsSyncBranchSameAsCurrent(ctx, "any-branch") {
|
||
t.Error("IsSyncBranchSameAsCurrent in non-git dir = true, want false")
|
||
}
|
||
})
|
||
}
|
||
|
||
// TestContentMergeRecoveryPreservesTombstones tests that contentMergeRecovery
|
||
// uses content-level merge which properly preserves tombstones.
|
||
// This is the fix for bd-kpy: Sync race where rebase-based divergence recovery
|
||
// resurrects tombstones.
|
||
func TestContentMergeRecoveryPreservesTombstones(t *testing.T) {
|
||
if testing.Short() {
|
||
t.Skip("skipping integration test in short mode")
|
||
}
|
||
|
||
ctx := context.Background()
|
||
|
||
t.Run("tombstone is preserved during merge recovery", func(t *testing.T) {
|
||
// This test simulates the race condition described in bd-kpy:
|
||
// 1. Repo A deletes issue (creates tombstone), pushes successfully
|
||
// 2. Repo B (with 'closed' status) tries to push, fails (non-fast-forward)
|
||
// 3. Repo B uses contentMergeRecovery
|
||
// 4. Verify tombstone from A is preserved, not overwritten by B's 'closed'
|
||
|
||
// Create a bare remote repo
|
||
remoteDir, err := os.MkdirTemp("", "bd-test-remote-*")
|
||
if err != nil {
|
||
t.Fatalf("Failed to create remote dir: %v", err)
|
||
}
|
||
defer os.RemoveAll(remoteDir)
|
||
runGit(t, remoteDir, "init", "--bare")
|
||
|
||
// Create local repo
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
runGit(t, repoDir, "remote", "add", "origin", remoteDir)
|
||
|
||
syncBranch := "beads-sync"
|
||
jsonlPath := filepath.Join(repoDir, ".beads", "issues.jsonl")
|
||
|
||
// Create base commit: issue with status="closed"
|
||
runGit(t, repoDir, "checkout", "-b", syncBranch)
|
||
writeFile(t, jsonlPath, `{"id":"test-1","status":"closed","title":"Test Issue"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "base: issue closed")
|
||
|
||
// Push base to remote
|
||
runGit(t, repoDir, "push", "-u", "origin", syncBranch)
|
||
baseCommit := strings.TrimSpace(getGitOutput(t, repoDir, "rev-parse", "HEAD"))
|
||
|
||
// Create tombstone commit (simulating what Repo A did)
|
||
writeFile(t, jsonlPath, `{"id":"test-1","status":"tombstone","title":"Test Issue"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "remote: issue tombstoned")
|
||
|
||
// Push tombstone to remote (simulating Repo A's successful push)
|
||
runGit(t, repoDir, "push", "origin", syncBranch)
|
||
|
||
// Now simulate Repo B: reset to base and make different changes
|
||
runGit(t, repoDir, "reset", "--hard", baseCommit)
|
||
writeFile(t, jsonlPath, `{"id":"test-1","status":"closed","title":"Test Issue","notes":"local change"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "local: added notes")
|
||
|
||
// Now local has diverged from remote:
|
||
// - Local HEAD: status=closed with notes
|
||
// - Remote origin/beads-sync: status=tombstone
|
||
// - Common ancestor (base): status=closed
|
||
|
||
// Run contentMergeRecovery - this should use content-level merge
|
||
err = contentMergeRecovery(ctx, repoDir, syncBranch, "origin")
|
||
if err != nil {
|
||
t.Fatalf("contentMergeRecovery() error = %v", err)
|
||
}
|
||
|
||
// Read the merged content
|
||
mergedData, err := os.ReadFile(jsonlPath)
|
||
if err != nil {
|
||
t.Fatalf("Failed to read merged JSONL: %v", err)
|
||
}
|
||
merged := string(mergedData)
|
||
|
||
// The tombstone should be preserved!
|
||
// The 3-way merge should see:
|
||
// base: status=closed
|
||
// local: status=closed (unchanged)
|
||
// remote: status=tombstone (changed)
|
||
// Result: status=tombstone (remote wins because it changed)
|
||
if !strings.Contains(merged, `"status":"tombstone"`) {
|
||
t.Errorf("contentMergeRecovery() did not preserve tombstone.\nGot: %s\nWant: status=tombstone", merged)
|
||
}
|
||
})
|
||
|
||
t.Run("both sides tombstone results in tombstone", func(t *testing.T) {
|
||
// Create a bare remote repo
|
||
remoteDir, err := os.MkdirTemp("", "bd-test-remote-*")
|
||
if err != nil {
|
||
t.Fatalf("Failed to create remote dir: %v", err)
|
||
}
|
||
defer os.RemoveAll(remoteDir)
|
||
runGit(t, remoteDir, "init", "--bare")
|
||
|
||
repoDir := setupTestRepo(t)
|
||
defer os.RemoveAll(repoDir)
|
||
runGit(t, repoDir, "remote", "add", "origin", remoteDir)
|
||
|
||
syncBranch := "beads-sync"
|
||
jsonlPath := filepath.Join(repoDir, ".beads", "issues.jsonl")
|
||
|
||
// Create base: issue open
|
||
runGit(t, repoDir, "checkout", "-b", syncBranch)
|
||
writeFile(t, jsonlPath, `{"id":"test-1","status":"open","title":"Test"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "base")
|
||
runGit(t, repoDir, "push", "-u", "origin", syncBranch)
|
||
baseCommit := strings.TrimSpace(getGitOutput(t, repoDir, "rev-parse", "HEAD"))
|
||
|
||
// Remote: tombstone (push to remote)
|
||
writeFile(t, jsonlPath, `{"id":"test-1","status":"tombstone","title":"Test"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "remote tombstone")
|
||
runGit(t, repoDir, "push", "origin", syncBranch)
|
||
|
||
// Local: reset and also tombstone (both deleted independently)
|
||
runGit(t, repoDir, "reset", "--hard", baseCommit)
|
||
writeFile(t, jsonlPath, `{"id":"test-1","status":"tombstone","title":"Test"}`)
|
||
runGit(t, repoDir, "add", ".")
|
||
runGit(t, repoDir, "commit", "-m", "local tombstone")
|
||
|
||
err = contentMergeRecovery(ctx, repoDir, syncBranch, "origin")
|
||
if err != nil {
|
||
t.Fatalf("contentMergeRecovery() error = %v", err)
|
||
}
|
||
|
||
mergedData, _ := os.ReadFile(jsonlPath)
|
||
if !strings.Contains(string(mergedData), `"status":"tombstone"`) {
|
||
t.Errorf("Expected tombstone to be preserved, got: %s", mergedData)
|
||
}
|
||
})
|
||
}
|