cmd/bd: consolidate post-merge is_blocked recompute onto one helper (wy-9k58l)
F6: conflicts.go's commitMergeResolution declared its own inline anonymous RecomputeBlockedAfterMerge interface assertion instead of routing through blockedAfterMergeRecomputerFor (cmd/bd/vc.go, wy-163oy) — correct today only because it already did storage.UnwrapStore first, but leaving two declarations of the same optional interface in the package invites drift. Switch the call site to the shared helper and add the same stderr warning on the unsupported-backend branch that vc.go's merge path already has. F4: nothing pinned vc.go's call site to the helper — reverting just that line back to an inline assertion left vc_recompute_test.go green. Factor vcMergeCmd's resolve-then-recompute step into resolveMergeConflictsAndRecompute so a fake store can drive it directly, and cover the happy path, the unsupported-backend warn, a resolve error, and a recompute error in cmd/bd/vc_merge_recompute_test.go. Follow-up NITs from the wy-163oy adversarial pass (F4, F6); neither is a live bug.
This commit is contained in:
parent
29d7c5a8ac
commit
eb957bbd51
3 changed files with 192 additions and 34 deletions
|
|
@ -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
|
||||
|
|
|
|||
74
cmd/bd/vc.go
74
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 <branch>",
|
||||
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{}{
|
||||
|
|
|
|||
142
cmd/bd/vc_merge_recompute_test.go
Normal file
142
cmd/bd/vc_merge_recompute_test.go
Normal file
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue