diff --git a/cmd/bd/conflicts.go b/cmd/bd/conflicts.go index 274a38fe1..77c3c74c7 100644 --- a/cmd/bd/conflicts.go +++ b/cmd/bd/conflicts.go @@ -382,13 +382,15 @@ func commitMergeResolution(ctx context.Context, msg, preHead string) error { return fmt.Errorf("commit failed: %w", err) } // Same unwrap rule as conflictInspector: RecomputeBlockedAfterMerge lives - // on the concrete Dolt store, not on DoltStorage. - if rs, ok := storage.UnwrapStore(store).(interface { - RecomputeBlockedAfterMerge(ctx context.Context, fromCommit string) error - }); ok { + // on the concrete Dolt store, not on DoltStorage. Route through the shared + // helper (cmd/bd/vc.go) so the package has one declaration of the optional + // interface, and never skip silently (bd vc merge's else branch, wy-163oy). + if rs, ok := blockedAfterMergeRecomputerFor(store); ok { if err := rs.RecomputeBlockedAfterMerge(ctx, preHead); err != nil { return fmt.Errorf("is_blocked recompute failed: %w", err) } + } else { + fmt.Fprintf(os.Stderr, "Warning: storage backend %T cannot recompute is_blocked after a merge; 'bd ready' may be stale until 'bd recompute-blocked' runs\n", storage.UnwrapStore(store)) } // The store's merge-conclusion path can no-op silently (an unreadable // dolt_merge_status degrades to "nothing to commit"), and reporting diff --git a/cmd/bd/vc.go b/cmd/bd/vc.go index 571a25101..d72027340 100644 --- a/cmd/bd/vc.go +++ b/cmd/bd/vc.go @@ -58,6 +58,48 @@ func blockedAfterMergeRecomputerFor(st storage.DoltStorage) (blockedAfterMergeRe return rs, ok } +// resolveMergeConflictsAndRecompute concludes a merge whose conflicts were +// resolved with an explicit --strategy: applies the strategy to every +// conflicted table, commits the resolution, and repairs is_blocked for the +// rows the merge brought in. Factored out of vcMergeCmd's RunE so the +// recompute call site — same helper + warn-not-skip contract as +// conflicts.go's commitMergeResolution — is reachable by a test against a +// fake store, without needing store.Merge to produce a live conflict (F4, +// wy-9k58l). +func resolveMergeConflictsAndRecompute(ctx context.Context, branchName string, conflicts []storage.Conflict, strategy, preHead string) error { + for _, conflict := range conflicts { + table := conflict.Field + if table == "" { + table = "issues" + } + if err := store.ResolveConflicts(ctx, table, strategy); err != nil { + return fmt.Errorf("failed to resolve conflicts: %w", err) + } + } + // Conclude the merge: an unresolved-then-resolved working set stays + // uncommitted otherwise, and the merged-in writes bypassed every + // is_blocked hook (bd-578h9.11). Use CommitMergeResolution, not Commit: + // server-mode Commit excludes config (GH#2455), so a resolved config + // conflict — routine now that kv.* user data syncs through config — + // would be silently dropped, leaving the merge unconcluded and + // re-wedging the next pull/sync (GH#2474). + if err := store.CommitMergeResolution(ctx, fmt.Sprintf("Resolve merge conflicts from %s using %s strategy", branchName, strategy)); err != nil { + return fmt.Errorf("conflicts resolved but commit failed: %w", err) + } + if rs, ok := blockedAfterMergeRecomputerFor(store); ok { + if err := rs.RecomputeBlockedAfterMerge(ctx, preHead); err != nil { + return fmt.Errorf("conflicts resolved but is_blocked recompute failed: %w", err) + } + } else { + // Never silent: a skipped recompute leaves 'bd ready' stale for + // every dependency edge the merge brought in, and the old `if ok` + // with no else is exactly how this went unnoticed for the whole + // life of the decorator chain. + fmt.Fprintf(os.Stderr, "Warning: storage backend %T cannot recompute is_blocked after a merge; 'bd ready' may be stale until 'bd recompute-blocked' runs\n", storage.UnwrapStore(store)) + } + return nil +} + var vcMergeCmd = &cobra.Command{ Use: "merge ", Short: "Merge a branch into the current branch", @@ -99,36 +141,8 @@ Examples: if len(conflicts) > 0 { if vcMergeStrategy != "" { - for _, conflict := range conflicts { - table := conflict.Field - if table == "" { - table = "issues" - } - if err := store.ResolveConflicts(ctx, table, vcMergeStrategy); err != nil { - return HandleErrorRespectJSON("failed to resolve conflicts: %v", err) - } - } - // Conclude the merge: an unresolved-then-resolved working set - // stays uncommitted otherwise, and the merged-in writes - // bypassed every is_blocked hook (bd-578h9.11). Use - // CommitMergeResolution, not Commit: server-mode Commit excludes - // config (GH#2455), so a resolved config conflict — routine now - // that kv.* user data syncs through config — would be silently - // dropped, leaving the merge unconcluded and re-wedging the next - // pull/sync (GH#2474). - if err := store.CommitMergeResolution(ctx, fmt.Sprintf("Resolve merge conflicts from %s using %s strategy", branchName, vcMergeStrategy)); err != nil { - return HandleErrorRespectJSON("conflicts resolved but commit failed: %v", err) - } - if rs, ok := blockedAfterMergeRecomputerFor(store); ok { - if err := rs.RecomputeBlockedAfterMerge(ctx, preHead); err != nil { - return HandleErrorRespectJSON("conflicts resolved but is_blocked recompute failed: %v", err) - } - } else { - // Never silent: a skipped recompute leaves 'bd ready' stale - // for every dependency edge the merge brought in, and the - // old `if ok` with no else is exactly how this went - // unnoticed for the whole life of the decorator chain. - fmt.Fprintf(os.Stderr, "Warning: storage backend %T cannot recompute is_blocked after a merge; 'bd ready' may be stale until 'bd recompute-blocked' runs\n", storage.UnwrapStore(store)) + if err := resolveMergeConflictsAndRecompute(ctx, branchName, conflicts, vcMergeStrategy, preHead); err != nil { + return HandleErrorRespectJSON("%v", err) } if jsonOutput { return outputJSON(map[string]interface{}{ diff --git a/cmd/bd/vc_merge_recompute_test.go b/cmd/bd/vc_merge_recompute_test.go new file mode 100644 index 000000000..1be985c49 --- /dev/null +++ b/cmd/bd/vc_merge_recompute_test.go @@ -0,0 +1,142 @@ +package main + +import ( + "context" + "errors" + "strings" + "testing" + + "github.com/steveyegge/beads/internal/storage" +) + +func containsAll(s string, substrs ...string) bool { + for _, sub := range substrs { + if !strings.Contains(s, sub) { + return false + } + } + return true +} + +// mergeRecomputeFakeStore is a bare fake for the resolve-then-recompute seam +// (resolveMergeConflictsAndRecompute): only the methods that seam calls are +// implemented, everything else panics via the nil embedded DoltStorage if +// ever reached. +type mergeRecomputeFakeStore struct { + storage.DoltStorage + resolveErr error + commitErr error + recompute *fakeRecomputer // nil => backend does not support recompute + resolved []string + committed string +} + +// fakeRecomputer is the optional RecomputeBlockedAfterMerge surface, kept +// separate from mergeRecomputeFakeStore so storage.UnwrapStore's assertion +// only finds it when the test wires it in — proving the unsupported-backend +// branch is reachable with a store that has no recompute method at all. +type fakeRecomputer struct { + err error + calls []string +} + +func (r *fakeRecomputer) RecomputeBlockedAfterMerge(_ context.Context, fromCommit string) error { + r.calls = append(r.calls, fromCommit) + return r.err +} + +type mergeRecomputeFakeStoreWithRecompute struct { + *mergeRecomputeFakeStore + *fakeRecomputer +} + +func (s *mergeRecomputeFakeStore) ResolveConflicts(_ context.Context, table, _ string) error { + if s.resolveErr != nil { + return s.resolveErr + } + s.resolved = append(s.resolved, table) + return nil +} + +func (s *mergeRecomputeFakeStore) CommitMergeResolution(_ context.Context, message string) error { + if s.commitErr != nil { + return s.commitErr + } + s.committed = message + return nil +} + +func withMergeRecomputeStore(t *testing.T, st storage.DoltStorage) { + t.Helper() + old := store + store = st + t.Cleanup(func() { store = old }) +} + +// The regression this pins: reverting resolveMergeConflictsAndRecompute's +// call site back to an inline assertion straight on `store` (skipping +// blockedAfterMergeRecomputerFor's UnwrapStore) makes this fail exactly like +// vc_recompute_test.go's decorated-chain cases, and dropping the else branch +// makes the warning assertion below fail silently instead (F4, wy-9k58l). +func TestResolveMergeConflictsAndRecompute_CallsRecomputeThroughHelper(t *testing.T) { + rec := &fakeRecomputer{} + fake := &mergeRecomputeFakeStore{} + withMergeRecomputeStore(t, &mergeRecomputeFakeStoreWithRecompute{fake, rec}) + + conflicts := []storage.Conflict{{IssueID: "wy-1", Field: "title"}, {IssueID: "wy-2"}} + if err := resolveMergeConflictsAndRecompute(context.Background(), "feature", conflicts, "ours", "deadbeef"); err != nil { + t.Fatalf("resolveMergeConflictsAndRecompute: %v", err) + } + if want := []string{"title", "issues"}; len(fake.resolved) != len(want) || fake.resolved[0] != want[0] || fake.resolved[1] != want[1] { + t.Errorf("resolved tables = %v, want %v (empty Field defaults to \"issues\")", fake.resolved, want) + } + if fake.committed == "" { + t.Errorf("CommitMergeResolution was not called") + } + if len(rec.calls) != 1 || rec.calls[0] != "deadbeef" { + t.Errorf("recompute calls = %v, want one call with fromCommit \"deadbeef\"", rec.calls) + } +} + +// A store without the optional interface must warn on stderr, not skip in +// silence — the old `if ok` with no else (F4/F6, wy-9k58l). +func TestResolveMergeConflictsAndRecompute_UnsupportedBackendWarns(t *testing.T) { + fake := &mergeRecomputeFakeStore{} + withMergeRecomputeStore(t, fake) + + stderr := captureStderr(t, func() { + if err := resolveMergeConflictsAndRecompute(context.Background(), "feature", []storage.Conflict{{Field: "title"}}, "ours", "deadbeef"); err != nil { + t.Fatalf("resolveMergeConflictsAndRecompute: %v", err) + } + }) + if !containsAll(stderr, "Warning:", "cannot recompute is_blocked", "recompute-blocked") { + t.Fatalf("stderr = %q; want the unsupported-backend warning", stderr) + } +} + +// A resolve failure must stop before commit and before recompute. +func TestResolveMergeConflictsAndRecompute_ResolveErrorStopsEarly(t *testing.T) { + rec := &fakeRecomputer{} + fake := &mergeRecomputeFakeStore{resolveErr: errors.New("resolve boom")} + withMergeRecomputeStore(t, &mergeRecomputeFakeStoreWithRecompute{fake, rec}) + + err := resolveMergeConflictsAndRecompute(context.Background(), "feature", []storage.Conflict{{Field: "title"}}, "ours", "deadbeef") + if err == nil { + t.Fatal("expected an error") + } + if fake.committed != "" || len(rec.calls) != 0 { + t.Fatalf("resolve failed but commit=%q recompute calls=%v", fake.committed, rec.calls) + } +} + +// A recompute failure must surface as an error, not a swallowed warning. +func TestResolveMergeConflictsAndRecompute_RecomputeErrorPropagates(t *testing.T) { + rec := &fakeRecomputer{err: errors.New("recompute boom")} + fake := &mergeRecomputeFakeStore{} + withMergeRecomputeStore(t, &mergeRecomputeFakeStoreWithRecompute{fake, rec}) + + err := resolveMergeConflictsAndRecompute(context.Background(), "feature", []storage.Conflict{{Field: "title"}}, "ours", "deadbeef") + if err == nil || !containsAll(err.Error(), "recompute boom") { + t.Fatalf("err = %v, want it to wrap the recompute error", err) + } +}