test(conflicts): cover the conclude command path (wy-ghg0d)

This commit is contained in:
Steve Yegge 2026-07-25 16:52:33 -07:00
commit ef06abb517
5 changed files with 283 additions and 24 deletions

View file

@ -480,11 +480,6 @@ func concludeResolvedMerge(ctx context.Context) error {
if err != nil {
return HandleErrorRespectJSON("failed to read conflicts: %v", err)
}
// Short-circuit before the blocker read: with rows still conflicted the
// blockers cannot change the answer, and there is nothing to diagnose yet.
if remaining > 0 {
return HandleErrorRespectJSON("%d conflict(s) are still live; resolve them first (bd conflicts list)", remaining)
}
blockers, blockerErr := mergeBlockers(ctx)
if blockerErr != nil {
// The blocker read is diagnosis, never a gate — but a caller that
@ -637,7 +632,11 @@ func writeMergeBlockers(w io.Writer, b storage.MergeBlockers) {
}
if len(b.ConstraintViolations) > 0 {
fmt.Fprintln(w, " Constraint violations: inspect dolt_constraint_violations_<table>, delete the offending rows,")
fmt.Fprintln(w, " then conclude with: bd conflicts resolve --conclude")
if len(b.SchemaConflictTables) > 0 {
fmt.Fprintln(w, " then re-inspect after aborting and re-merging the schema change")
} else {
fmt.Fprintln(w, " then conclude with: bd conflicts resolve --conclude")
}
}
}

View file

@ -0,0 +1,260 @@
//go:build cgo
package main
import (
"bytes"
"context"
"encoding/json"
"errors"
"os"
"path/filepath"
"sort"
"strings"
"testing"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/types"
)
// concludeProbeStore keeps the real Dolt store underneath the command while
// making two otherwise hard-to-reproduce edges deterministic: a failed
// diagnostic read, and a commit implementation that silently leaves the merge
// open. It deliberately does not implement storage.Unwrapper, so the optional
// MergeBlockerInspector methods below remain visible to mergeBlockers.
type concludeProbeStore struct {
storage.DoltStorage
blockers *storage.MergeBlockers
blockerErr error
noOpCommit bool
commitErr error
}
func (s *concludeProbeStore) GetMergeBlockers(ctx context.Context) (storage.MergeBlockers, error) {
if s.blockers != nil || s.blockerErr != nil {
if s.blockers == nil {
return storage.MergeBlockers{}, s.blockerErr
}
return *s.blockers, s.blockerErr
}
return s.DoltStorage.(storage.MergeBlockerInspector).GetMergeBlockers(ctx)
}
func (s *concludeProbeStore) CommitMergeResolution(ctx context.Context, message string) error {
if s.commitErr != nil {
return s.commitErr
}
if s.noOpCommit {
return nil
}
return s.DoltStorage.CommitMergeResolution(ctx, message)
}
func wedgeResolvedConcludeMerge(t *testing.T) storage.DoltStorage {
t.Helper()
ctx := context.Background()
raw := newTestStore(t, filepath.Join(t.TempDir(), ".beads", "beads.db"))
db := raw.DB()
const issueID = "conclude-command-1"
if err := raw.CreateIssue(ctx, &types.Issue{
ID: issueID, Title: "base", Status: types.StatusOpen,
Priority: 2, IssueType: types.TypeTask,
}, "test"); err != nil {
t.Fatalf("create seed issue: %v", err)
}
if err := raw.Commit(ctx, "seed conclude command test"); err != nil {
t.Fatalf("commit seed issue: %v", err)
}
var currentBranch string
if err := db.QueryRowContext(ctx, "SELECT active_branch()").Scan(&currentBranch); err != nil {
t.Fatalf("read current branch: %v", err)
}
peerBranch := currentBranch + "_conclude_peer"
if err := raw.Branch(ctx, peerBranch); err != nil {
t.Fatalf("create peer branch: %v", err)
}
t.Cleanup(func() {
cleanupCtx := context.Background()
_, _ = db.ExecContext(cleanupCtx, "CALL DOLT_MERGE('--abort')")
_, _ = db.ExecContext(cleanupCtx, "CALL DOLT_CHECKOUT(?)", currentBranch)
_, _ = db.ExecContext(cleanupCtx, "CALL DOLT_BRANCH('-Df', ?)", peerBranch)
})
if _, err := db.ExecContext(ctx, "UPDATE issues SET title = 'ours' WHERE id = ?", issueID); err != nil {
t.Fatalf("update ours: %v", err)
}
if err := raw.Commit(ctx, "our conclude title"); err != nil {
t.Fatalf("commit ours: %v", err)
}
if err := raw.Checkout(ctx, peerBranch); err != nil {
t.Fatalf("checkout peer: %v", err)
}
if _, err := db.ExecContext(ctx, "UPDATE issues SET title = 'theirs' WHERE id = ?", issueID); err != nil {
t.Fatalf("update theirs: %v", err)
}
if err := raw.Commit(ctx, "their conclude title"); err != nil {
t.Fatalf("commit theirs: %v", err)
}
if err := raw.Checkout(ctx, currentBranch); err != nil {
t.Fatalf("checkout current: %v", err)
}
for _, stmt := range []string{
"SET @@dolt_allow_commit_conflicts = 1",
"SET @@dolt_force_transaction_commit = 1",
} {
if _, err := db.ExecContext(ctx, stmt); err != nil {
t.Fatalf("%s: %v", stmt, err)
}
}
if _, err := db.ExecContext(ctx, "CALL DOLT_MERGE(?)", peerBranch); err != nil {
t.Logf("DOLT_MERGE returned: %v", err)
}
rows, err := raw.GetConflictRows(ctx, "issues")
if err != nil || len(rows) != 1 {
t.Fatalf("wedge live conflict: rows=%d err=%v", len(rows), err)
}
return raw
}
func runConcludeCommand(t *testing.T, commandStore storage.DoltStorage, asJSON bool) (string, string, error) {
t.Helper()
stdioMutex.Lock()
defer stdioMutex.Unlock()
oldStdout, oldStderr := os.Stdout, os.Stderr
oldStore, oldRootCtx, oldJSON := store, rootCtx, jsonOutput
oldConclude := conflictsConclude
rOut, wOut, err := os.Pipe()
if err != nil {
t.Fatal(err)
}
rErr, wErr, err := os.Pipe()
if err != nil {
t.Fatal(err)
}
os.Stdout, os.Stderr = wOut, wErr
store, rootCtx, jsonOutput = commandStore, context.Background(), asJSON
conflictsConclude = true
commandErr := conflictsResolveCmd.RunE(conflictsResolveCmd, nil)
_ = wOut.Close()
_ = wErr.Close()
os.Stdout, os.Stderr = oldStdout, oldStderr
store, rootCtx, jsonOutput = oldStore, oldRootCtx, oldJSON
conflictsConclude = oldConclude
var stdout, stderr bytes.Buffer
_, _ = stdout.ReadFrom(rOut)
_, _ = stderr.ReadFrom(rErr)
_ = rOut.Close()
_ = rErr.Close()
return stdout.String(), stderr.String(), commandErr
}
func requireExitOne(t *testing.T, err error) {
t.Helper()
if code, ok := exitCodeFromError(err); !ok || code != 1 {
t.Fatalf("command error = %v, want exit code 1", err)
}
}
func decodeConcludePayload(t *testing.T, out string) map[string]interface{} {
t.Helper()
var payload map[string]interface{}
if err := json.Unmarshal([]byte(out), &payload); err != nil {
t.Fatalf("decode conclude JSON %q: %v", out, err)
}
return payload
}
func requireConcludeKeys(t *testing.T, payload map[string]interface{}) {
t.Helper()
got := make([]string, 0, len(payload))
for key := range payload {
got = append(got, key)
}
sort.Strings(got)
want := []string{"blockers", "committed", "merging", "remaining", "schema_version"}
if strings.Join(got, ",") != strings.Join(want, ",") {
t.Fatalf("conclude JSON keys = %v, want %v", got, want)
}
}
// TestConcludeResolvedMergeCommand drives the actual resolve command handler
// over a real Dolt merge. It pins every branch that planConclude's unit tests
// cannot: JSON's non-zero error, warning emission, haveStatus dispatch, stable
// success/no-op payloads, the real merge commit, and the post-commit guard.
func TestConcludeResolvedMergeCommand(t *testing.T) {
raw := wedgeResolvedConcludeMerge(t)
ctx := context.Background()
t.Run("live conflicts fail in JSON mode", func(t *testing.T) {
out, _, err := runConcludeCommand(t, raw, true)
requireExitOne(t, err)
payload := decodeConcludePayload(t, out)
if !strings.Contains(payload["error"].(string), "still live") {
t.Fatalf("live-conflict JSON = %v", payload)
}
})
inspector := raw.(storage.ConflictInspector)
if n, err := inspector.ResolveConflictRows(ctx, "issues", []string{"conclude-command-1"}, "ours"); err != nil || n != 1 {
t.Fatalf("resolve conflict without concluding: n=%d err=%v", n, err)
}
t.Run("blockers fail in JSON mode", func(t *testing.T) {
blocked := storage.MergeBlockers{Merging: true, SchemaConflictTables: []string{"issues"}}
out, _, err := runConcludeCommand(t, &concludeProbeStore{DoltStorage: raw, blockers: &blocked}, true)
requireExitOne(t, err)
payload := decodeConcludePayload(t, out)
if !strings.Contains(payload["error"].(string), "merge not concluded") {
t.Fatalf("blocked JSON = %v", payload)
}
})
t.Run("blocker read warning is visible", func(t *testing.T) {
probeErr := errors.New("probe blocker read failed")
_, stderr, err := runConcludeCommand(t, &concludeProbeStore{
DoltStorage: raw, blockerErr: probeErr, commitErr: errors.New("stop after warning"),
}, false)
requireExitOne(t, err)
if !strings.Contains(stderr, "Warning: could not read") || !strings.Contains(stderr, probeErr.Error()) {
t.Fatalf("stderr missing blocker warning: %q", stderr)
}
})
t.Run("silent no-op commit is rejected", func(t *testing.T) {
_, stderr, err := runConcludeCommand(t, &concludeProbeStore{DoltStorage: raw, noOpCommit: true}, false)
requireExitOne(t, err)
if !strings.Contains(stderr, "commit did not conclude the merge") {
t.Fatalf("stderr missing post-commit guard: %q", stderr)
}
})
t.Run("real commit has stable JSON payload", func(t *testing.T) {
out, _, err := runConcludeCommand(t, raw, true)
if err != nil {
t.Fatalf("conclude real merge: %v; output=%s", err, out)
}
payload := decodeConcludePayload(t, out)
requireConcludeKeys(t, payload)
if payload["committed"] != true || payload["remaining"] != float64(0) || payload["merging"] != false {
t.Fatalf("committed payload = %v", payload)
}
})
t.Run("nothing to conclude uses the same JSON shape", func(t *testing.T) {
out, _, err := runConcludeCommand(t, raw, true)
if err != nil {
t.Fatalf("conclude closed merge: %v; output=%s", err, out)
}
payload := decodeConcludePayload(t, out)
requireConcludeKeys(t, payload)
if payload["committed"] != false || payload["remaining"] != float64(0) || payload["merging"] != false {
t.Fatalf("no-op payload = %v", payload)
}
})
}

View file

@ -7,14 +7,10 @@ import (
"github.com/steveyegge/beads/internal/storage"
)
// Coverage for `bd conflicts resolve --conclude` and the BLOCKING merge state
// (wy-36ilm F12) — the paths wy-wrq9o F5 found untested. The three decisions
// they turn on are pure functions of the merge state (planConclude,
// shouldCommitResolution, concludeFlagConflict) plus the remedy text
// (writeMergeBlockers), so a Blocked() inversion, a dropped merge-status
// check, or a remedy pointing back at the dolt command that always errors
// (adversarial review F1) is caught with no dolt and no Docker. The real
// system-table column names are guarded separately, dolt-backed, in
// Pure-logic coverage for `bd conflicts resolve --conclude` and the BLOCKING
// merge state (wy-36ilm F12). Command wiring, JSON output and real merge
// transitions are covered, dolt-backed, in conflicts_conclude_integration_test.go.
// The real system-table column names are guarded separately in
// internal/storage/dolt/conflicts_integration_test.go.
func schemaBlockers(tables ...string) storage.MergeBlockers {
@ -240,6 +236,9 @@ func TestWriteMergeBlockersRemedies(t *testing.T) {
if !strings.Contains(out, "Schema conflicts:") || !strings.Contains(out, "Constraint violations:") {
t.Errorf("both classes outstanding must show both remedies:\n%s", out)
}
if strings.Contains(out, "bd conflicts resolve --conclude") {
t.Errorf("must not recommend --conclude while a schema conflict makes it refuse:\n%s", out)
}
})
}

View file

@ -309,10 +309,9 @@ func TestConflictInspectorSurvivesTheStoreDecoratorChain(t *testing.T) {
// dolt_constraint_violations.(`table`, num_violations). wy-wrq9o F5: those
// reads had no test at all — a column rename, a dropped `WHERE num_violations
// > 0`, or a Blocked() inversion would have landed green. These reproduce
// both blocker classes for real and assert the whole gate behaves: blockers
// visible, Blocked() true, and the merge commit held rather than failing with
// a raw dolt error. The pure-logic half of the gate (planConclude,
// shouldCommitResolution, the remedy text) is in cmd/bd/conflicts_conclude_test.go.
// both blocker classes for real and assert the storage half of the gate:
// blockers are visible and Blocked() is true. The command-level commit hold
// and remedies are covered in cmd/bd/conflicts_conclude*_test.go.
// wedgeConstraintViolation leaves a real FK constraint violation in the
// working set: our branch deleted an issue, the peer added a child row
@ -422,10 +421,11 @@ func TestGetMergeBlockersSeesASchemaConflict(t *testing.T) {
if _, err := db.ExecContext(ctx, "CALL DOLT_BRANCH(?, 'HEAD')", peerBranch); err != nil {
t.Fatalf("create peer branch: %v", err)
}
t.Cleanup(func() {
db.ExecContext(ctx, "CALL DOLT_CHECKOUT(?)", currentBranch)
db.ExecContext(ctx, "CALL DOLT_BRANCH('-Df', ?)", peerBranch)
})
defer func() {
_, _ = db.ExecContext(context.Background(), "CALL DOLT_MERGE('--abort')")
_, _ = db.ExecContext(context.Background(), "CALL DOLT_CHECKOUT(?)", currentBranch)
_, _ = db.ExecContext(context.Background(), "CALL DOLT_BRANCH('-Df', ?)", peerBranch)
}()
// Divergent ALTER TABLE: same column name, incompatible types.
if _, err := db.ExecContext(ctx, "ALTER TABLE "+probeTable+" ADD COLUMN note VARCHAR(32)"); err != nil {

View file

@ -12,8 +12,9 @@ import (
// and the CLI reaches it through storage.UnwrapStore exactly as it reaches
// the server-mode one. The reads run against the embedded engine's own
// dolt_merge_status / dolt_schema_conflicts / dolt_constraint_violations, so
// a system table or column the embedded engine names differently (or does not
// expose at all) shows up here and nowhere else.
// a system table or column the embedded engine names differently is caught
// here. Missing optional system tables are intentionally tolerated and appear
// as empty blocker classes.
// TestEmbeddedGetMergeBlockersOnAQuietStore is the baseline every other
// caller depends on: with no merge open, GetMergeBlockers must report an