test(conflicts): cover the conclude command path (wy-ghg0d)
This commit is contained in:
parent
4fd05a5748
commit
ef06abb517
5 changed files with 283 additions and 24 deletions
|
|
@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
260
cmd/bd/conflicts_conclude_integration_test.go
Normal file
260
cmd/bd/conflicts_conclude_integration_test.go
Normal 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(¤tBranch); 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)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
@ -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)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue