beads/cmd/bd/graph_apply_execution_test.go
Julian Knutsen d8d8bf587b
feat(cli): bd create --graph via one atomic BatchApplier request; --if-revision on bd reopen (#7209)
* feat(cli): bd create --graph via BatchApplier (spawner_id, thread_id)

Reapplies S11's graph-batch-apply half onto origin/main's post-#7203
state: `bd create --graph` now builds its plan through
issueops.BatchApplier instead of the removed buildDomainGraphPlan path
(create_proxied_server.go shrinks accordingly), spawner_id is stamped
only when a node names a spawner (RunBatchApplyStampsSpawnerIDOnlyWhenNamed
conformance case), and thread_id survives translation into
issueops.DepAddItem alongside the rest of GraphApplyEdge/GraphApplyNodeDep.

Entirely independent of #7203's --if-revision work: no file in this
commit overlaps #7203's or #7205's changed files.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(cli): extend #7203's --if-revision guard to bd reopen

#7203 (37acca96d) added --if-revision to update/close/assign/delete but
not reopen, even though issueops.ReopenRequest.ExpectedVersion already
existed upstream. Wire reopen.go and reopen_proxied_server.go through
the same parseIfRevisionFlag / requireSingleIfRevisionID /
reportIfRevisionFailure / ifRevisionFlagHelp helpers #7203 introduced,
so reopen gets identical one-id-only, exit-13-on-mismatch, gascity-
compatible-body behavior as the other four verbs, with no new helper
surface of its own.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* test(cli): gc-matcher decode pin and proxied-server --if-revision coverage

#7203 never ran its mismatch body through gc's actual decode logic (only
through bd's own JSON assertions), and it only exercises --if-revision
through the embedded/direct route -- the proxied-server path
(*_proxied_server.go's uow-backed preflight/apply) had no coverage at
all on either side.

- if_revision_gc_matcher_test.go: a faithful port of gc's
  bdstore_conditional.go decode logic, run against a real built bd for
  all five guarded verbs (including reopen). Confirms against #7203's
  actual numeric-only body that no decimal-string twins are needed:
  encoding/json decodes a JSON number straight into an int64 struct
  field with no float64 intermediate, so there is no precision loss for
  gc's matcher to lose above 2^53 the way there would be decoding into
  an untyped interface{}.
- if_revision_proxied_integration_test.go: proxied-server-leg coverage
  for all five verbs (update/close/reopen/delete/assign), using a
  numeric-only proxiedPreconditionBody matching #7203's shape exactly
  (no _str fields, since the matcher test above shows none are needed).
  reopen's case is its only --if-revision coverage on the proxied route
  at all, since #7203 did not add the flag to reopen.

Both verified for real: TestGCConditionalMatcherDecode via
BEADS_TEST_EMBEDDED_DOLT=1, the five TestIfRevisionGuardProxied* tests
via BEADS_TEST_PROXIED_SERVER=1 BEADS_TEST_DOLT_SERVER=local against the
pinned dolt 2.2.0 binary (no Docker needed).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* docs(changelog): document graph-batch-apply and if-revision-reopen deltas

Neither #7203 (--if-revision) nor #7205 (batch create/import perf)
touched CHANGELOG.md, so document this branch's two deltas on top of
them directly: bd create --graph via BatchApplier (spawner_id/thread_id,
field-survival test, real-store hierarchy/cycle scenarios), and
--if-revision's extension to bd reopen plus its gc-matcher decode pin
and new proxied-server coverage.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(cli): adapt reopen's reportIfRevisionFailure call to #7216's signature

#7216 (merged to main, landed in this rebase) added a fourth ifRevision
*int64 parameter to reportIfRevisionFailure for reassign-fence
disambiguation. Pass bd reopen's own declared --if-revision value at both
call sites (direct and proxied-server paths) to match.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* build(bazel): auto-sync BUILD files

Applied from the bazel-sync-patch artifact of https://github.com/gastownhall/beads/actions/runs/37290168028
(`make bazel-sync`: gazelle, tools/bazel/go_srcs.py, bazel mod tidy).
Only BUILD.bazel, MODULE.bazel and MODULE.bazel.lock are ever pushed; see
scripts/bazel-autofix-push.sh.

* fix(cli): evaluate reopen's --if-revision guard before the already-open short-circuit

bd reopen's direct route checked issue.Status == StatusOpen before ever
calling ops.Reopen, so a stale --if-revision guard against an
already-open issue silently returned the "already open" no-op (exit 0)
instead of the precondition_failed refusal (exit 13) every other guarded
verb gives for a stale token. ops.Reopen itself already evaluates
ExpectedVersion first (ExecuteReopen -> CheckVersionInTx) on both the
dolt and embeddeddolt backends, and the proxied-server route already
called through unconditionally -- only the direct route's pre-check
bypassed it.

Fix: skip the already-open pre-check when --if-revision is set, letting
ops.Reopen evaluate the revision guard first. Without --if-revision,
today's behavior for already-open issues is unchanged.

Tests:
- if_revision_reopen_embedded_test.go (new): direct route, all four
  combinations (already-open/closed x stale/matching revision). Verified
  live that already_open_mismatch_refuses fails against the pre-fix
  ordering and passes against the fix.
- if_revision_proxied_integration_test.go: added the same already-open
  coverage to TestIfRevisionGuardProxiedReopen to confirm the
  proxied-server route already behaved correctly and keeps doing so.

Also documents in CHANGELOG.md that a `bd create --graph` plan over
issueops.MaxApplyBatchItems (1000) is refused outright with
GraphApplyTooLargeError (non-blocking review item).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(cli): put guard tests in CI lanes; fence unguarded reopen errors

Maintainer fixup for #7209, review loop iteration 1. It replays the prior
adoption's stranded fixup (f71ac4f66) on top of the contributor's own fix
for the direct-route reopen guard (266cacfca1). The contributor's fence
and tests are kept, and the fixup's overlapping reopen fence and
open-issue pins are dropped.

CI lanes: seven env-gated tests matched no lane's discovery pattern, so
no CI job ran them, including the reopen fix's own pin. The proxied tests
are now TestProxiedServerIfRevisionGuard{Update,Close,Reopen,Delete,
Assign}. The gc matcher test moves to
if_revision_gc_matcher_embedded_test.go as
TestEmbeddedGCConditionalMatcherDecode, and the direct reopen test is
TestEmbeddedIfRevisionReopenGuardDirect. BUILD.bazel and both shard
manifests are regenerated, and each renamed test is selected by exactly
one shard of every lane.

bd reopen:
- reportIfRevisionFailure now runs only when --if-revision is set, on
  both routes, as update, assign and delete already do. Since #7256 the
  classifier maps storage.ErrNotFound to precondition_failed, so an
  unguarded reopen that lost a race with a delete reported a guard
  refusal (exit 13) for a command that carried no guard.
- The gc matcher test gains a reopen_open row: a stale guard on an open
  issue gets the same refusal body. The matching-guard no-op subtest now
  also checks the "already open" line and that the revision did not move.

bd create --graph:
- A node naming both a plan-local parent and a parent_id is parented under
  the plan key again, as both legs did before the BatchApplier translation
  and as the dry-run preview and the local cycle check assume
  (TestBuildGraphApplyBatchRequestParentKeyWinsOverParentID).
- Removed dead code: graphApplyParentDepPairs, graphApplyDepPairKey and
  GraphApplyUnsupportedFieldError, with the helper-only test.
- A path from a node's parent to the node through a waits-for hop is now
  stored, as bd dep add and bd batch apply already store it, because the
  shared end gate walks the scheduling edges only. That shape can stall
  ready work once the spawner has an open child. The acceptance is
  documented in the CHANGELOG and the buildGraphApplyBatchRequest comment
  and pinned by TestExecuteGraphApplyAcceptsParentToChildPathThroughWaitsFor.
  Refusing the shape belongs in the shared role (types.IsSchedulingEdge),
  for every front door at once; that is a follow-up.
- The deleted fake-store rejection scenarios are ported to real-store
  tests: reverse parent-to-child blocking edges, a reverse parent-child
  edge cycle, and the end gate alone with SkipPerEdgeCycleCheck set.
- The graphApplyEdgeBatchMetadata comment names the real
  issueops.StampWaitsForSpawnerID.

CHANGELOG: the spawner stamp is described as a waits-for edge's
metadata.spawner_id, and the reopen entry says a guarded reopen of an
open issue is judged against the guard on both routes.

Agent-Signature: claude-code-claude-opus-5-5-max on behalf of Gas City Adopt-PR
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(cli): name #7292 in the waits-for acceptance marker

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Eddie the Engineer <adopt-pr@gascity.com>
2026-10-07 07:53:35 +00:00

857 lines
32 KiB
Go

//go:build cgo
package main
import (
"context"
"database/sql"
"path/filepath"
"strings"
"testing"
"github.com/steveyegge/beads/internal/types"
)
func withGraphApplyTestStore(t *testing.T) (context.Context, *sql.DB) {
t.Helper()
ctx := context.Background()
testStore := newTestStoreWithPrefix(t, filepath.Join(t.TempDir(), ".beads", "beads.db"), "ga")
oldStore, oldCtx, oldActor := store, rootCtx, actor
store, rootCtx, actor = testStore, ctx, "graph-apply-test"
t.Cleanup(func() {
store, rootCtx, actor = oldStore, oldCtx, oldActor
})
return ctx, testStore.DB()
}
func TestExecuteGraphApplyEphemeralAndNoHistoryRouteToWisps(t *testing.T) {
ctx, db := withGraphApplyTestStore(t)
tests := []struct {
name string
opts GraphApplyOptions
}{
{name: "ephemeral", opts: GraphApplyOptions{Ephemeral: true}},
{name: "no history", opts: GraphApplyOptions{NoHistory: true}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{{Key: "a", Title: "A", Type: "task"}},
}
result, err := executeGraphApply(ctx, plan, tt.opts)
if err != nil {
t.Fatalf("executeGraphApply: %v", err)
}
id := result.IDs["a"]
got, err := store.GetIssue(ctx, id)
if err != nil {
t.Fatalf("GetIssue(%s): %v", id, err)
}
if got.Ephemeral != tt.opts.Ephemeral {
t.Fatalf("Ephemeral = %v, want %v", got.Ephemeral, tt.opts.Ephemeral)
}
if got.NoHistory != tt.opts.NoHistory {
t.Fatalf("NoHistory = %v, want %v", got.NoHistory, tt.opts.NoHistory)
}
var count int
if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM wisps WHERE id = ?", id).Scan(&count); err != nil {
t.Fatalf("query wisps for %s: %v", id, err)
}
if count != 1 {
t.Fatalf("wisps row count for %s = %d, want 1", id, count)
}
if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM issues WHERE id = ?", id).Scan(&count); err != nil {
t.Fatalf("query issues for %s: %v", id, err)
}
if count != 0 {
t.Fatalf("issues row count for %s = %d, want 0", id, count)
}
})
}
}
func TestExecuteGraphApplyRejectsMixedLocalExternalBlockingCycle(t *testing.T) {
ctx, _ := withGraphApplyTestStore(t)
existing := &types.Issue{
ID: "ga-existing",
Title: "Existing",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeTask,
}
if err := store.CreateIssue(ctx, existing, actor); err != nil {
t.Fatalf("CreateIssue(existing): %v", err)
}
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "a", Title: "A", Type: "task"},
{Key: "b", Title: "B", Type: "task"},
},
Edges: []GraphApplyEdge{
{FromID: existing.ID, ToKey: "a", Type: "blocks"},
{FromKey: "b", ToID: existing.ID, Type: "blocks"},
{FromKey: "a", ToKey: "b", Type: "blocks"},
},
}
if err := validateGraphApplyPlan(plan, nil, nil, GraphApplyOptions{}); err != nil {
t.Fatalf("validateGraphApplyPlan: %v", err)
}
_, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err == nil {
t.Fatal("expected mixed local/external blocking cycle to be rejected")
}
if !strings.Contains(err.Error(), "cycle") {
t.Fatalf("error = %q, want cycle rejection", err.Error())
}
}
func TestExecuteGraphApplyRejectsStoredPrefixParentBlockingPath(t *testing.T) {
ctx, db := withGraphApplyTestStore(t)
parent := &types.Issue{
ID: "ga-parent",
Title: "Existing Parent",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeTask,
}
mid := &types.Issue{
ID: "ga-existing-mid",
Title: "Existing Middle",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeTask,
}
for _, issue := range []*types.Issue{parent, mid} {
if err := store.CreateIssue(ctx, issue, actor); err != nil {
t.Fatalf("CreateIssue(%s): %v", issue.ID, err)
}
}
if err := store.AddDependency(ctx, &types.Dependency{
IssueID: parent.ID,
DependsOnID: mid.ID,
Type: types.DepBlocks,
}, actor); err != nil {
t.Fatalf("AddDependency(parent -> mid): %v", err)
}
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "child", Title: "Child", Type: "task", ParentID: parent.ID},
},
Edges: []GraphApplyEdge{
{FromID: mid.ID, ToKey: "child", Type: "blocks"},
},
}
_, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err == nil {
t.Fatal("expected stored-prefix parent blocking path to be rejected")
}
// Confirmed against a real Dolt test server (2026-10 coordinator
// follow-up): the engine's own cycle detector catches this before any
// more specific "path from parent" wording would apply, so the
// observed refusal reads "...would create a cycle", not a parent-path
// phrase this test originally (and wrongly, since it had never
// actually run against a real store) assumed.
if got, want := err.Error(), "cycle"; !strings.Contains(got, want) {
t.Fatalf("error = %q, want to contain %q", got, want)
}
var count int
if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM issues WHERE title = 'Child'").Scan(&count); err != nil {
t.Fatalf("query child rows: %v", err)
}
if count != 0 {
t.Fatalf("child issue rows after failed transaction = %d, want 0", count)
}
}
func TestExecuteGraphApplyAllowsExplicitParentChildDuplicate(t *testing.T) {
ctx, _ := withGraphApplyTestStore(t)
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "root", Title: "Root", Type: "epic"},
{Key: "child", Title: "Child", Type: "task", ParentKey: "root"},
},
Edges: []GraphApplyEdge{
{FromKey: "child", ToKey: "root", Type: string(types.DepParentChild)},
},
}
result, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err != nil {
t.Fatalf("executeGraphApply: %v", err)
}
deps, err := store.GetDependenciesWithMetadata(ctx, result.IDs["child"])
if err != nil {
t.Fatalf("GetDependenciesWithMetadata(child): %v", err)
}
if len(deps) != 1 {
t.Fatalf("dependency count = %d, want 1", len(deps))
}
if deps[0].ID != result.IDs["root"] {
t.Fatalf("dependency target = %s, want %s", deps[0].ID, result.IDs["root"])
}
if deps[0].DependencyType != types.DepParentChild {
t.Fatalf("dependency type = %s, want %s", deps[0].DependencyType, types.DepParentChild)
}
}
func TestExecuteGraphApplyRejectsBlockingChildToParentDuplicate(t *testing.T) {
ctx, _ := withGraphApplyTestStore(t)
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "root", Title: "Root", Type: "epic"},
{Key: "child", Title: "Child", Type: "task", ParentKey: "root"},
},
Edges: []GraphApplyEdge{
{FromKey: "child", ToKey: "root"},
},
}
_, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err == nil {
t.Fatal("expected default blocking child-to-parent duplicate to be rejected")
}
// Confirmed against a real Dolt test server (2026-10 coordinator
// follow-up): CheckBlockingHierarchyInTx refuses this as an ancestor
// being blocked by its own descendant, not as a literal "parent-child"
// duplicate-edge rejection this test originally (and wrongly, since it
// had never actually run against a real store) assumed.
if !strings.Contains(err.Error(), "cannot be blocked by its ancestor") {
t.Fatalf("error = %q, want ancestor-blocking rejection", err.Error())
}
}
// TestExecuteGraphApplyRejectsReverseParentToChildBlockingEdgeExternalParent
// restores the one subcase of the deleted graph_apply_execution_unit_test.go's
// fake-store TestExecuteGraphApplyUnitRejectsReverseParentToChildBlockingEdge
// that a pure plan-local check cannot see: the parent already exists as a
// stored issue (addressed by ParentID, not a plan key), so only a real store
// walk — now the BatchApplier end gate, reached through executeGraphApply —
// can catch a blocking edge running the wrong way across that hierarchy. The
// local-only variant (both ends are plan keys) is refused up front by
// TestValidateGraphApplyPlanRejectsImplicitParentChildReverseBlockingCycle in
// graph_apply_test.go, and by the end gate in
// TestExecuteGraphApplyRejectsReverseParentToChildBlockingEdge below.
func TestExecuteGraphApplyRejectsReverseParentToChildBlockingEdgeExternalParent(t *testing.T) {
for _, depType := range []string{"blocks", "conditional-blocks"} {
t.Run(depType, func(t *testing.T) {
ctx, _ := withGraphApplyTestStore(t)
parent := &types.Issue{
ID: "ga-reverse-parent",
Title: "Existing Parent",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeEpic,
}
if err := store.CreateIssue(ctx, parent, actor); err != nil {
t.Fatalf("CreateIssue(parent): %v", err)
}
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "child", Title: "Child", Type: "task", ParentID: parent.ID},
},
Edges: []GraphApplyEdge{
{FromID: parent.ID, ToKey: "child", Type: depType},
},
}
_, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err == nil {
t.Fatal("expected reverse parent-to-child blocking edge to be rejected")
}
// CheckBlockingHierarchyInTx (internal/storage/issueops/dependencies.go)
// is what actually catches this on the real BatchApplier path, via
// batch_apply.go's end-gate call -- NOT the old domain.GraphPlan
// applyGraph family (whose "parent-child relationship" wording lives in
// internal/storage/domain/issue.go and is no longer reachable from this
// CLI command). Its error is *issueops.DependencyHierarchyConflictError,
// which reads "<id> cannot be blocked by its ancestor/descendant <id>: ...".
if !strings.Contains(err.Error(), "cannot be blocked by its") {
t.Fatalf("error = %q, want a DependencyHierarchyConflictError rejection", err.Error())
}
})
}
}
// TestExecuteGraphApplyRejectsReverseParentToChildBlockingEdge restores the
// local arms of the deleted fake-store
// TestExecuteGraphApplyUnitRejectsReverseParentToChildBlockingEdge (its
// external arms are the test above): a blocking edge from a planned parent to
// its own planned child. validateGraphApplyLocalCycles refuses this plan
// before `bd create --graph` sends it; calling executeGraphApply directly
// pins that the role refuses it too (CheckBlockingHierarchyInTx: an ancestor
// cannot be blocked by its descendant), with nothing written.
func TestExecuteGraphApplyRejectsReverseParentToChildBlockingEdge(t *testing.T) {
for _, depType := range []string{"blocks", "conditional-blocks"} {
t.Run(depType, func(t *testing.T) {
ctx, db := withGraphApplyTestStore(t)
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "root", Title: "Root", Type: "epic"},
{Key: "child", Title: "Child", Type: "task", ParentKey: "root"},
},
Edges: []GraphApplyEdge{
{FromKey: "root", ToKey: "child", Type: depType},
},
}
_, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err == nil || !strings.Contains(err.Error(), "cannot be blocked by its descendant") {
t.Fatalf("error = %v, want descendant-blocking rejection", err)
}
var count int
if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM issues").Scan(&count); err != nil {
t.Fatalf("query issue rows: %v", err)
}
if count != 0 {
t.Fatalf("issue rows after rejected plan = %d, want 0", count)
}
})
}
}
// TestExecuteGraphApplyRejectsReverseParentChildEdgeCycle restores the
// deleted fake-store TestExecuteGraphApplyUnitRejectsReverseParentChildEdgeCycle:
// an explicit parent-child edge from a planned parent to its own planned child
// makes each node the other's parent. No local check sees it (a parent-child
// edge is not "cycle relevant" to validateGraphApplyLocalCycles), so the role
// is the only refusal. The old preflight worded it as a planned path from the
// parent; the role reports the cycle.
func TestExecuteGraphApplyRejectsReverseParentChildEdgeCycle(t *testing.T) {
ctx, db := withGraphApplyTestStore(t)
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "root", Title: "Root", Type: "epic"},
{Key: "child", Title: "Child", Type: "task", ParentKey: "root"},
},
Edges: []GraphApplyEdge{
{FromKey: "root", ToKey: "child", Type: string(types.DepParentChild)},
},
}
if err := validateGraphApplyPlan(plan, nil, nil, GraphApplyOptions{}); err != nil {
t.Fatalf("validateGraphApplyPlan: %v", err)
}
_, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err == nil || !strings.Contains(err.Error(), "cycle") {
t.Fatalf("error = %v, want reverse parent-child cycle rejection", err)
}
var count int
if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM issues").Scan(&count); err != nil {
t.Fatalf("query issue rows: %v", err)
}
if count != 0 {
t.Fatalf("issue rows after rejected plan = %d, want 0", count)
}
}
// TestExecuteGraphApplyAcceptsParentToChildPathThroughWaitsFor pins a
// deliberate change. The deleted in-transaction preflight
// (validateGraphApplyPlannedParentBlockingPaths) walked every AffectsReadyWork
// edge, so it refused a planned path from a parent to its own descendant that
// ran through a waits-for hop. The role's end gate walks the scheduling edges
// only (types.IsSchedulingEdge leaves waits-for out on purpose), the same gate
// `bd dep add` and `bd batch apply` go through, so `bd create --graph` now
// stores these plans as those commands do. The blocking twins, the same
// paths with the waits-for hop made a blocks edge, are still refused:
// TestExecuteGraphApplyRejectsReverseParentToChildBlockingEdge and
// TestExecuteGraphApplyRejectsExternalParentTransitiveBlockingPath.
//
// Accepting the shape is not the same as it being safe. Once the spawner has
// an open child, every issue in the shape stays blocked and none is ever
// ready: the parent waits on the spawner's children, and the path from the
// parent down to its own descendant keeps those children blocked for as long
// as the parent is. IsSchedulingEdge's "a waits-for edge cannot close a
// cycle" does not hold here, in either case below. Refusing the shape belongs
// in the shared role, for every front door at once (#7292); this test is the marker
// to flip when that lands.
func TestExecuteGraphApplyAcceptsParentToChildPathThroughWaitsFor(t *testing.T) {
// A waits-for edge's target is its spawner (validateGraphApplyPlan).
waitsFor := func(from, to string) GraphApplyEdge {
return GraphApplyEdge{FromKey: from, ToKey: to, Type: string(types.DepWaitsFor), SpawnerKey: to}
}
tests := []struct {
name string
nodes []GraphApplyNode
edges []GraphApplyEdge
// hop is the node the parent's waits-for edge lands on.
hop string
}{
{
name: "direct",
nodes: []GraphApplyNode{
{Key: "parent", Title: "Parent", Type: "epic"},
{Key: "child", Title: "Child", Type: "task", ParentKey: "parent"},
},
edges: []GraphApplyEdge{waitsFor("parent", "child")},
hop: "child",
},
{
name: "then a blocking edge",
nodes: []GraphApplyNode{
{Key: "parent", Title: "Parent", Type: "epic"},
{Key: "mid", Title: "Middle", Type: "task"},
{Key: "child", Title: "Child", Type: "task", ParentKey: "parent"},
},
edges: []GraphApplyEdge{
waitsFor("parent", "mid"),
{FromKey: "mid", ToKey: "child", Type: string(types.DepBlocks)},
},
hop: "mid",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ctx, _ := withGraphApplyTestStore(t)
plan := &GraphApplyPlan{Nodes: tt.nodes, Edges: tt.edges}
if err := validateGraphApplyPlan(plan, nil, nil, GraphApplyOptions{}); err != nil {
t.Fatalf("validateGraphApplyPlan: %v", err)
}
result, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err != nil {
t.Fatalf("executeGraphApply: %v", err)
}
deps, err := store.GetDependenciesWithMetadata(ctx, result.IDs["parent"])
if err != nil {
t.Fatalf("GetDependenciesWithMetadata(parent): %v", err)
}
if len(deps) != 1 || deps[0].ID != result.IDs[tt.hop] || deps[0].DependencyType != types.DepWaitsFor {
t.Fatalf("parent dependencies = %+v, want one waits-for edge to %s", deps, result.IDs[tt.hop])
}
})
}
}
// TestExecuteGraphApplyFinalGateCatchesCycleHiddenFromPerEdgeChecks restores
// the deleted fake-store
// TestExecuteGraphApplyUnitFinalGateCatchesCycleHiddenFromPerEdgeChecks. That
// test blinded the fake store's per-edge cycle probe; the real request has the
// same switch, SkipPerEdgeCycleCheck, which drops the per-edge probe but never
// the end gate. With it set, the plans TestExecuteGraphApplyRejectsCombinedSchedulingCycle
// and TestExecuteGraphApplyRejectsCycleHiddenInInlineDep send through
// executeGraphApply must still be refused, by the end gate alone.
func TestExecuteGraphApplyFinalGateCatchesCycleHiddenFromPerEdgeChecks(t *testing.T) {
tests := []struct {
name string
plan *GraphApplyPlan
}{
{
name: "explicit parent-child edge",
plan: &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "a", Title: "A", Type: "task"},
{Key: "b", Title: "B", Type: "task"},
{Key: "c", Title: "C", Type: "task"},
},
Edges: []GraphApplyEdge{
{FromKey: "a", ToKey: "b", Type: string(types.DepBlocks)},
{FromKey: "b", ToKey: "c", Type: string(types.DepParentChild)},
{FromKey: "c", ToKey: "a", Type: string(types.DepConditionalBlocks)},
},
},
},
{
name: "inline parent-child dependency",
plan: &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "a", Title: "A", Type: "task"},
{Key: "b", Title: "B", Type: "task", Deps: []GraphApplyNodeDep{{Type: string(types.DepParentChild), Target: "c"}}},
{Key: "c", Title: "C", Type: "task"},
},
Edges: []GraphApplyEdge{
{FromKey: "a", ToKey: "b", Type: string(types.DepBlocks)},
{FromKey: "c", ToKey: "a", Type: string(types.DepConditionalBlocks)},
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ctx, db := withGraphApplyTestStore(t)
req, err := buildGraphApplyBatchRequest(tt.plan, GraphApplyOptions{}, actor, "")
if err != nil {
t.Fatalf("buildGraphApplyBatchRequest: %v", err)
}
req.SkipPerEdgeCycleCheck = true
applier, err := store.BatchApplier()
if err != nil {
t.Fatalf("BatchApplier: %v", err)
}
_, err = applier.ApplyBatch(ctx, req)
// The end gate's own wording: the per-edge probe would have said
// "adding dependency would create a cycle" against one item.
if err == nil || !strings.Contains(err.Error(), "dependency cycle would be created") {
t.Fatalf("end gate error = %v, want the whole-graph cycle rejection", err)
}
var count int
if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM issues").Scan(&count); err != nil {
t.Fatalf("query issue rows: %v", err)
}
if count != 0 {
t.Fatalf("issue rows after rejected plan = %d, want 0", count)
}
})
}
}
// TestExecuteGraphApplyRejectsTransitiveParentChainBlockingCycle restores the
// deleted fake-store TestExecuteGraphApplyUnitRejectsTransitiveParentChainBlockingCycle
// against the real BatchApplier path: a plan-local parent chain (a's parent is
// plan-local b, b's parent is an existing external issue) plus a blocking edge
// from that external grandparent to the local leaf must be rejected even
// though no single parent-child hop is itself local-and-external at once —
// catching it requires walking the hierarchy against the store, which only
// the end gate executeGraphApply reaches can do.
func TestExecuteGraphApplyRejectsTransitiveParentChainBlockingCycle(t *testing.T) {
ctx, _ := withGraphApplyTestStore(t)
grandparent := &types.Issue{
ID: "ga-chain-grandparent",
Title: "Existing Grandparent",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeEpic,
}
if err := store.CreateIssue(ctx, grandparent, actor); err != nil {
t.Fatalf("CreateIssue(grandparent): %v", err)
}
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "a", Title: "A", Type: "task", ParentKey: "b"},
{Key: "b", Title: "B", Type: "task", ParentID: grandparent.ID},
},
Edges: []GraphApplyEdge{
{FromID: grandparent.ID, ToKey: "a", Type: "blocks"},
},
}
_, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err == nil {
t.Fatal("expected transitive parent-chain blocking cycle to be rejected")
}
// Same end gate and error family as the reverse-edge case above:
// CheckBlockingHierarchyInTx walks the full ancestor chain via a recursive
// CTE, so the external grandparent is still found even though the
// blocking edge itself only names the plan-local leaf.
if got, want := err.Error(), "cannot be blocked by its"; !strings.Contains(got, want) {
t.Fatalf("error = %q, want to contain %q", got, want)
}
}
// TestExecuteGraphApplyRejectsBlockingThroughExistingBlocking restores the
// deleted fake-store TestExecuteGraphApplyUnitRejectsBlockingThroughExistingBlocking
// against the real BatchApplier path: a planned blocking edge that would close
// a cycle through an EXISTING stored blocking dependency (not anything in the
// plan) must still be rejected, and must not add the new edge.
func TestExecuteGraphApplyRejectsBlockingThroughExistingBlocking(t *testing.T) {
ctx, _ := withGraphApplyTestStore(t)
for _, id := range []string{"ga-existing-x", "ga-existing-y"} {
if err := store.CreateIssue(ctx, &types.Issue{
ID: id, Title: id, Status: types.StatusOpen, Priority: 2, IssueType: types.TypeTask,
}, actor); err != nil {
t.Fatalf("CreateIssue(%s): %v", id, err)
}
}
// Existing blocking dep: ga-existing-y blocks ga-existing-x.
if err := store.AddDependency(ctx, &types.Dependency{
IssueID: "ga-existing-y",
DependsOnID: "ga-existing-x",
Type: types.DepBlocks,
}, actor); err != nil {
t.Fatalf("AddDependency(y -> x): %v", err)
}
plan := &GraphApplyPlan{
Edges: []GraphApplyEdge{
{FromID: "ga-existing-x", ToID: "ga-existing-y", Type: "blocks"},
},
}
_, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err == nil {
t.Fatal("expected blocking cycle through existing blocking dep to be rejected")
}
if !strings.Contains(err.Error(), "cycle") {
t.Fatalf("error = %q, want cycle rejection", err.Error())
}
deps, err := store.GetDependenciesWithMetadata(ctx, "ga-existing-y")
if err != nil {
t.Fatalf("GetDependenciesWithMetadata(ga-existing-y): %v", err)
}
if len(deps) != 1 {
t.Fatalf("ga-existing-y dependency count = %d, want 1 (only the pre-existing edge)", len(deps))
}
}
// TestExecuteGraphApplyRejectsExternalParentTransitiveBlockingPath restores
// the deleted fake-store
// TestExecuteGraphApplyUnitRejectsExternalParentTransitiveBlockingPath: a
// blocking edge from an existing issue to a plan-local middle node, chained
// with a second blocking edge from that middle node to a plan-local
// descendant of the existing issue, composes into a disallowed
// parent-to-descendant block even though no single edge in the plan touches
// the hierarchy directly.
func TestExecuteGraphApplyRejectsExternalParentTransitiveBlockingPath(t *testing.T) {
ctx, db := withGraphApplyTestStore(t)
parent := &types.Issue{
ID: "ga-transitive-parent",
Title: "Existing Parent",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeEpic,
}
if err := store.CreateIssue(ctx, parent, actor); err != nil {
t.Fatalf("CreateIssue(parent): %v", err)
}
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "mid", Title: "Middle", Type: "task"},
{Key: "child", Title: "Child", Type: "task", ParentID: parent.ID},
},
Edges: []GraphApplyEdge{
{FromID: parent.ID, ToKey: "mid", Type: "blocks"},
{FromKey: "mid", ToKey: "child", Type: "blocks"},
},
}
_, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err == nil {
t.Fatal("expected external parent transitive blocking path to be rejected")
}
// Confirmed against a real Dolt test server (2026-10 coordinator
// follow-up): see the sibling comment in
// TestExecuteGraphApplyRejectsStoredPrefixParentBlockingPath above for
// why this checks for "cycle" rather than a parent-path phrase.
if got, want := err.Error(), "cycle"; !strings.Contains(got, want) {
t.Fatalf("error = %q, want to contain %q", got, want)
}
var count int
if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM issues WHERE title IN ('Middle', 'Child')").Scan(&count); err != nil {
t.Fatalf("query plan issue rows: %v", err)
}
if count != 0 {
t.Fatalf("plan issue rows after rejected transitive path = %d, want 0", count)
}
}
// TestExecuteGraphApplyRejectsCombinedSchedulingCycle restores the deleted
// fake-store TestExecuteGraphApplyUnitRejectsCombinedSchedulingCycle: a cycle
// that mixes a blocking edge, an EXPLICIT (not implicit-via-parent_key)
// parent-child edge, and a conditional-blocks edge. The explicit
// parent-child leg is deliberately not a "cycle relevant" type for
// validateGraphApplyLocalCycles's plan-local preflight
// (graphApplyCycleRelevantDependencyType only treats blocks/
// conditional-blocks as such), so this cycle is invisible to that pure
// check and is caught only by the real apply path's whole-graph gate.
func TestExecuteGraphApplyRejectsCombinedSchedulingCycle(t *testing.T) {
ctx, db := withGraphApplyTestStore(t)
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "a", Title: "A", Type: "task"},
{Key: "b", Title: "B", Type: "task"},
{Key: "c", Title: "C", Type: "task"},
},
Edges: []GraphApplyEdge{
{FromKey: "a", ToKey: "b", Type: string(types.DepBlocks)},
{FromKey: "b", ToKey: "c", Type: string(types.DepParentChild)},
{FromKey: "c", ToKey: "a", Type: string(types.DepConditionalBlocks)},
},
}
_, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err == nil || !strings.Contains(err.Error(), "cycle") {
t.Fatalf("combined scheduling cycle error = %v, want rejection", err)
}
var count int
if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM issues WHERE title IN ('A', 'B', 'C')").Scan(&count); err != nil {
t.Fatalf("query issue rows: %v", err)
}
if count != 0 {
t.Fatalf("issue rows after rejected combined scheduling cycle = %d, want 0", count)
}
}
// TestExecuteGraphApplyRejectsCycleHiddenInInlineDep restores the deleted
// fake-store TestExecuteGraphApplyUnitFinalGateCatchesCycleHiddenFromPerEdgeChecks's
// "inline parent-child dependency" subcase: the cycle-closing parent-child
// hop is a per-node inline Dep (node.Deps), never a top-level plan Edge, so
// it is invisible to validateGraphApplyLocalCycles (which only walks
// plan.Edges) and to any check that only looks at explicit edges. Only the
// real apply path's final whole-graph gate, which sees every dependency the
// batch will write (inline or not), can catch it.
func TestExecuteGraphApplyRejectsCycleHiddenInInlineDep(t *testing.T) {
ctx, db := withGraphApplyTestStore(t)
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "a", Title: "A", Type: "task"},
{Key: "b", Title: "B", Type: "task", Deps: []GraphApplyNodeDep{{Type: string(types.DepParentChild), Target: "c"}}},
{Key: "c", Title: "C", Type: "task"},
},
Edges: []GraphApplyEdge{
{FromKey: "a", ToKey: "b", Type: string(types.DepBlocks)},
{FromKey: "c", ToKey: "a", Type: string(types.DepConditionalBlocks)},
},
}
_, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err == nil || !strings.Contains(err.Error(), "cycle") {
t.Fatalf("error = %v, want cycle rejection via the inline parent-child dep", err)
}
var count int
if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM issues WHERE title IN ('A', 'B', 'C')").Scan(&count); err != nil {
t.Fatalf("query issue rows: %v", err)
}
if count != 0 {
t.Fatalf("issue rows after rejected plan = %d, want 0", count)
}
}
// TestExecuteGraphApplyFinalGateIncludesImplicitNodeParent restores the
// deleted fake-store TestExecuteGraphApplyUnitFinalGateIncludesImplicitNodeParent,
// recast as a rejection: the old test introspected the fake store's captured
// cycle-check edge set directly, which has no real-store equivalent, so this
// pins the same claim (the final gate folds in a node's IMPLICIT
// parent-child edge, not only explicit plan edges) by constructing a cycle
// that closes ONLY through that implicit edge — b's parent is an existing
// external issue addressed by ParentID, which validateGraphApplyLocalCycles
// cannot see at all (it only models an implicit parent for a LOCAL,
// plan-key parent) — so a false negative here would mean the final gate
// silently dropped the implicit edge.
func TestExecuteGraphApplyFinalGateIncludesImplicitNodeParent(t *testing.T) {
ctx, db := withGraphApplyTestStore(t)
existingParent := &types.Issue{
ID: "ga-final-gate-parent",
Title: "Existing Parent",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeEpic,
}
if err := store.CreateIssue(ctx, existingParent, actor); err != nil {
t.Fatalf("CreateIssue(parent): %v", err)
}
plan := &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "a", Title: "A", Type: "task"},
{Key: "b", Title: "B", Type: "task", ParentID: existingParent.ID},
},
Edges: []GraphApplyEdge{
{FromID: existingParent.ID, ToKey: "a", Type: string(types.DepBlocks)},
{FromKey: "a", ToKey: "b", Type: string(types.DepBlocks)},
},
}
_, err := executeGraphApply(ctx, plan, GraphApplyOptions{})
if err == nil {
t.Fatal("expected cycle closed through b's implicit parent-child edge to be rejected")
}
if !strings.Contains(err.Error(), "cycle") {
t.Fatalf("error = %q, want cycle rejection", err.Error())
}
var count int
if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM issues WHERE title IN ('A', 'B')").Scan(&count); err != nil {
t.Fatalf("query issue rows: %v", err)
}
if count != 0 {
t.Fatalf("issue rows after rejected plan = %d, want 0", count)
}
}
// TestExecuteGraphApplyRejectsBlockingThroughPlannedHierarchyRegardlessOfOrder
// restores the deleted fake-store
// TestExecuteGraphApplyUnitRejectsBlockingThroughPlannedHierarchyRegardlessOfOrder:
// a blocking edge onto a planned ancestor must be rejected whether the
// hierarchy is stated as explicit parent-child plan edges or as per-node
// inline Deps, and regardless of which edge the plan lists first — the
// blocking edge deliberately comes before the parent-child edges/deps in
// both subcases, so a check that stops at the first-seen edge rather than
// resolving the whole planned hierarchy would miss it.
func TestExecuteGraphApplyRejectsBlockingThroughPlannedHierarchyRegardlessOfOrder(t *testing.T) {
tests := []struct {
name string
plan *GraphApplyPlan
}{
{
name: "explicit edges",
plan: &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "grand", Title: "Grand", Type: "task"},
{Key: "parent", Title: "Parent", Type: "task"},
{Key: "child", Title: "Child", Type: "task"},
},
Edges: []GraphApplyEdge{
{FromKey: "child", ToKey: "grand", Type: "conditional-blocks"}, // Deliberately first.
{FromKey: "child", ToKey: "parent", Type: "parent-child"},
{FromKey: "parent", ToKey: "grand", Type: "parent-child"},
},
},
},
{
name: "inline deps",
plan: &GraphApplyPlan{
Nodes: []GraphApplyNode{
{Key: "grand", Title: "Grand", Type: "task"},
{Key: "parent", Title: "Parent", Type: "task", Deps: []GraphApplyNodeDep{{Type: "parent-child", Target: "grand"}}},
{Key: "child", Title: "Child", Type: "task", Deps: []GraphApplyNodeDep{
{Type: "blocks", Target: "grand"}, // Deliberately first.
{Type: "parent-child", Target: "parent"},
}},
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ctx, db := withGraphApplyTestStore(t)
_, err := executeGraphApply(ctx, tt.plan, GraphApplyOptions{})
if err == nil || !strings.Contains(err.Error(), "cannot be blocked by its ancestor") {
t.Fatalf("error = %v, want planned-ancestor rejection", err)
}
var count int
if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM issues").Scan(&count); err != nil {
t.Fatalf("query issue rows: %v", err)
}
if count != 0 {
t.Fatalf("issue rows after rejected plan = %d, want 0", count)
}
})
}
}