fix(issueops): enforce the dotted-child dependency rule on every leg (#7424)
* fix(issueops): enforce the dotted-child dependency rule on every leg The refusal of an explicit edge from a dotted-id child to its own ancestor (bd-abc.1 -> bd-abc; only the parent-child edge to the immediate dotted parent is allowed) lived only in cmd/bd (isDisallowedHierarchicalDependency). HTTP dependencies:add, batch:apply dep_add items and `bd create --graph`'s own edges skipped it. It is now one library rule, issueops.CheckDottedChildDependency, returning *issueops.DottedChildDependencyError (unwraps to ErrValidation, same message the CLI printed): - ValidateAddDependenciesRequest applies it, so DependencyEditor refuses on dolt, embedded, uow and the server behind httpapi (400 invalid_argument); - both BatchApplier bodies (issueops and uow) apply it to each dep_add item on the resolved ids, so a key bound to a minted dotted child is refused too; - the HTTP client checks it before the dial, as it does self-dependency, so the typed error survives the wire. cmd/bd keeps no copy: single-edge dep add / dep --blocks rely on the role; bd link (still on the store verb) and the --file bulk reporter call the library rule. CLI output is byte-identical (checked against origin/main). Conformance: RunDependencyEditorRefusesADottedChildGatedOnItsOwnParent and RunBatchApplyRefusesADottedChildGatedOnItsOwnParent wired on dolt, embedded, uow and http, plus a raw-wire served test past the client check and handler mapping cases. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(batch): refuse a dotted child gated on its own ancestor in bd batch Review fixup for PR #7424 (iterations 1 and 2). Major: a bd batch script line `dep add bd-abc.1 bd-abc` still wrote the edge this PR refuses everywhere else, on both backends. Neither batch dispatch writes through the DependencyEditor role that enforces the dotted-child rule: the classic arm calls storage.Transaction.AddDependency and the proxied arm the unit of work's AddDependencies verb. Both arms now build the edge with one helper, batchDepAddEdge, which keeps the default type and the arity and type errors, and asks publicops.CheckDottedChildDependency the way bd link does. A refused line rolls the whole batch back. Tests: TestBatchDepAddEdge (default and explicit types, arity and type errors, three refusals typed *DottedChildDependencyError matching ErrValidation, and the immediate parent-child edge allowed), and TestProxiedServerBatchDepAddRefusesADottedChildGatedOnItsParent (classic and proxied: the refusal names line 2, rolls back an earlier update line and writes no edge, and `dep add C P parent-child` still lands exactly one), registered in the proxied shard manifest. A mutant that drops the rule from the shared helper fails both; one that bypasses the helper in the proxied arm alone fails the proxied leg. Minors: - For a child whose parent-child edge is already stored (a `bd create --parent` child) the rule answers ahead of the hierarchy and type conflicts, so an HTTP caller now gets 400 invalid_argument where it got 409 dependency_cycle (blocking types) or dependency_exists (any other type). Documented in the DependencyEditor role doc, the CHANGELOG entry and the httpapi batch-apply test comment, and pinned by a stored-hierarchy phase in the DependencyEditor and BatchApplier dotted-child conformance contracts on every leg; a mutant that drops the rule gets the hierarchy conflict instead (409 dependency_cycle on the wire). - The bd create --graph dry-run note now says the live create may also refuse an edge that gates a dotted-id child on its own ancestor. - The DottedChildDependencyError comment says the message is kept verbatim and says "deadlock" whatever the type. Not changed: bd relate (relates-to does not schedule) and the edges a create writes with its issue (bd create --deps/--waits-for, and over HTTP an explicit dotted id with a non-immediate ParentID) still write through paths that skip the rule. The scheduling shapes need an explicit dotted id or a grandparent target. Follow-up bd-25s1wh tracks moving the rule down to the domain/store add verbs, with a structural bypass for reparent and template edges. Iteration 2 (minor): the CheckDottedChildDependency doc no longer implies bd link and bd batch are the only writers outside the roles. It names bd relate and the create edges as not applying the rule yet and cites bd-25s1wh. Complexity (cyclomatic/cognitive): runBatchOp 23/35 -> 21/31, runBatchOpUOW 28/48 -> 26/44, batchDepAddEdge 5/4. Touching them brings both pre-existing dispatch switches into the measured set; splitting them is out of scope here. 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> * docs(issueops,httpapi): document the dotted-child 400 and widen its gap list Review fixup for PR #7424 (relaunch, iteration 1, minors). - The OpenAPI spec now describes the wire change this PR makes. The dependencies:add and issues:batchApply 400 vocabularies name an edge from a dotted-id child to its own ancestor (anything but the parent-child edge to its immediate parent; param `edges` and `items`). dependencies:add says why that is request-intrinsic, and both 409s say it is never dependency_cycle or dependency_exists, even for a child whose parent-child edge is stored. Response descriptions only: the generated types and the wireshape digest are unchanged (make api-check). - The CheckDottedChildDependency doc no longer reads as a complete list of the writers that skip the rule. Besides bd relate and the create edges it names bd duplicate, bd supersede, bd duplicates --auto-merge (its related link and its reparenting) and the tracker engine's createDependencies, and says the molecule, template and swarm writers are unaudited. bd-25s1wh's notes carry the widened scope, including `bd duplicate bd-a.1 --of bd-a`. Declined (nit): unifying the root issueops import alias across the PR's cmd/bd files. batch.go is the one file that imports both issueops packages, so one of them needs an alias there; it uses publicops, the repo's usual alias for the root package, and aliasing the other side instead would rewrite base-owned lines. 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> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
7c47c3c0a9
commit
d15958a5eb
35 changed files with 669 additions and 239 deletions
|
|
@ -152,6 +152,7 @@
|
|||
40 3 TestCrossRecordInvariantContract
|
||||
40 3 TestDepRekeyMarkerStillInIgnoredSeries
|
||||
40 3 TestDoltCommitResponseLossIsIndeterminate
|
||||
40 3 TestEmbeddedDependencyEditorRefusesADottedChildGatedOnItsOwnParent
|
||||
40 3 TestEmbeddedDoltStoreIssueLifecycleBuildsOperations
|
||||
40 3 TestEmbeddedDoltStoreIssueLifecycleRejectsNilStore
|
||||
40 3 TestEmbeddedOpenReadOnly_FreshDatabaseNoWrites
|
||||
|
|
|
|||
1
.github/scripts/proxied-cmd-test-shards.txt
vendored
1
.github/scripts/proxied-cmd-test-shards.txt
vendored
|
|
@ -392,6 +392,7 @@
|
|||
34 20 TestProxiedServerWispGC
|
||||
34 20 TestServerModeSharedServeGlobalReportsTheServedDatabase
|
||||
|
||||
34 21 TestProxiedServerBatchDepAddRefusesADottedChildGatedOnItsParent
|
||||
34 21 TestProxiedServerConfig
|
||||
34 21 TestProxiedServerExternalPolicyDirectParity
|
||||
34 21 TestProxiedServerMoleculeFrontDoorDirectServerProxyParity
|
||||
|
|
|
|||
16
CHANGELOG.md
16
CHANGELOG.md
|
|
@ -263,6 +263,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
|||
`POST /v0/beads/issues/{id}:claim` (`issueops.Claimer`) still claims a
|
||||
template that a `PATCH` with `claim: true` refuses. Close's guards move to
|
||||
the role in their own change (#7425).
|
||||
- The dotted-id hierarchy refusal (a child such as `bd-abc.1` may not carry an
|
||||
explicit edge to its own ancestor, other than the parent-child edge to its
|
||||
immediate parent) moved from `cmd/bd` into the library as
|
||||
`issueops.CheckDottedChildDependency` / `*issueops.DottedChildDependencyError`
|
||||
(unwraps to `ErrValidation`). Every `DependencyEditor` (dolt, embedded,
|
||||
unit of work, HTTP) and every `BatchApplier` dep_add item now enforces it, so
|
||||
an HTTP `dependencies:add`, a `batch:apply` edge and `bd create --graph`'s own
|
||||
edges are refused like `bd dep add` (HTTP: 400 `invalid_argument`). `bd dep
|
||||
add`, `bd dep --blocks`, `bd link` and `bd dep add --file` print the same
|
||||
messages as before, and a `bd batch` script's `dep add` line, which neither
|
||||
backend checked, is now refused with that message and rolls the whole batch
|
||||
back. The refusal is decided from the two ids, ahead of every check that
|
||||
reads the stored graph, so for a child whose parent-child edge is already
|
||||
stored (a `bd create --parent` child) an HTTP caller now gets that 400 where
|
||||
it used to get 409 `dependency_cycle` (a blocking type) or
|
||||
`dependency_exists` (any other type).
|
||||
- **PRs based on `hotfix/**` branches now run full CI, not just
|
||||
cross-version historical smokes and triage labeling.** `pr.yml`,
|
||||
`pr-risk.yml`, `conformance.yml`, `cross-version-smoke.yml` and
|
||||
|
|
|
|||
|
|
@ -2657,3 +2657,80 @@ func RunBatchApplyCloseItemsAnswerToTheCloseGuards(t *testing.T, ctx context.Con
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
// RunBatchApplyRefusesADottedChildGatedOnItsOwnParent pins the dotted-id
|
||||
// hierarchy rule (publicops.CheckDottedChildDependency) on a dep_add item: an
|
||||
// edge from a dotted-id child to its own ancestor is refused with an
|
||||
// *ItemError naming the edge, and the whole request rolls back. The rule is
|
||||
// applied to the RESOLVED ids, so a key bound to a dotted child this request
|
||||
// creates — the `bd create --graph` shape — is refused like a stored id.
|
||||
//
|
||||
// POSITIVE HALF: the parent-child edge to the immediate dotted parent lands.
|
||||
//
|
||||
// WITH THE HIERARCHY STORED: once that edge exists (the shape `bd create
|
||||
// --parent` leaves), a blocking edge on the same pair is still this validation
|
||||
// refusal, not the hierarchy conflict the stored edge would raise (which does
|
||||
// not match ErrValidation) — the rule reads only the resolved ids, so it
|
||||
// answers first — and the stored edge survives.
|
||||
func RunBatchApplyRefusesADottedChildGatedOnItsOwnParent(t *testing.T, ctx context.Context, fixture BatchApplyFixture) {
|
||||
t.Helper()
|
||||
parent := fixture.IssuePrefix + "-dotted"
|
||||
child := parent + ".1"
|
||||
minted := parent + ".2"
|
||||
batchApplySeedIssue(t, ctx, fixture, parent, types.StatusOpen)
|
||||
batchApplySeedIssue(t, ctx, fixture, child, types.StatusOpen)
|
||||
|
||||
for _, refused := range []struct {
|
||||
name string
|
||||
items []publicops.ApplyItem
|
||||
index int
|
||||
}{
|
||||
{"a stored child blocking on its parent", []publicops.ApplyItem{
|
||||
batchApplyDepAdd(publicops.Ref{ID: child}, publicops.Ref{ID: parent}, publicops.DepBlocks, ""),
|
||||
}, 0},
|
||||
{"a child this request creates blocking on its parent", []publicops.ApplyItem{
|
||||
batchApplyCreate("child", batchApplyIssue(minted, "the new child")),
|
||||
batchApplyDepAdd(publicops.Ref{Key: "child"}, publicops.Ref{ID: parent}, publicops.DepBlocks, ""),
|
||||
}, 1},
|
||||
} {
|
||||
_, err := fixture.BatchApplier.ApplyBatch(ctx, publicops.ApplyBatchRequest{
|
||||
Actor: "apply-writer",
|
||||
ForceIDPrefix: true,
|
||||
Items: refused.items,
|
||||
})
|
||||
if !errors.Is(err, publicops.ErrValidation) {
|
||||
t.Errorf("%s: error = %v, want ErrValidation", refused.name, err)
|
||||
continue
|
||||
}
|
||||
var itemErr *publicops.ItemError
|
||||
if !errors.As(err, &itemErr) {
|
||||
t.Errorf("%s: error = %v, want an *ItemError naming the edge item", refused.name, err)
|
||||
continue
|
||||
}
|
||||
if itemErr.Index != refused.index || itemErr.Kind != publicops.ItemDepAdd {
|
||||
t.Errorf("%s: ItemError = %#v, want Index %d and Kind %q", refused.name, itemErr, refused.index, publicops.ItemDepAdd)
|
||||
}
|
||||
}
|
||||
assertBatchApplyEdgeCount(t, ctx, fixture, child, parent, 0)
|
||||
assertBatchApplyRowCount(t, ctx, fixture, "issues", minted, 0)
|
||||
|
||||
batchApplyMust(t, ctx, fixture, publicops.ApplyBatchRequest{
|
||||
Actor: "apply-writer",
|
||||
Items: []publicops.ApplyItem{
|
||||
batchApplyDepAdd(publicops.Ref{ID: child}, publicops.Ref{ID: parent}, publicops.DepParentChild, ""),
|
||||
},
|
||||
})
|
||||
assertBatchApplyEdgeCount(t, ctx, fixture, child, parent, 1)
|
||||
|
||||
_, err := fixture.BatchApplier.ApplyBatch(ctx, publicops.ApplyBatchRequest{
|
||||
Actor: "apply-writer",
|
||||
Items: []publicops.ApplyItem{
|
||||
batchApplyDepAdd(publicops.Ref{ID: child}, publicops.Ref{ID: parent}, publicops.DepBlocks, ""),
|
||||
},
|
||||
})
|
||||
var itemErr *publicops.ItemError
|
||||
if !errors.Is(err, publicops.ErrValidation) || !errors.As(err, &itemErr) {
|
||||
t.Errorf("blocks on a parent whose parent-child edge is stored: error = %v, want an *ItemError matching ErrValidation", err)
|
||||
}
|
||||
assertBatchApplyEdgeCount(t, ctx, fixture, child, parent, 1)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2631,3 +2631,82 @@ func dependencyEditorHistoryProbe(t *testing.T, ctx context.Context, fixture Dep
|
|||
assertDependencyEditorHistoryDelta(t, ctx, fixture, before, want, why)
|
||||
}
|
||||
}
|
||||
|
||||
// RunDependencyEditorRefusesADottedChildGatedOnItsOwnParent pins
|
||||
// publicops.CheckDottedChildDependency on the role: an explicit edge from a
|
||||
// dotted-id child to its own ancestor is refused as a
|
||||
// *DottedChildDependencyError (ErrValidation) on every leg, and nothing is
|
||||
// written. (It is decided before any per-edge probe, so the probe-skipped
|
||||
// spelling, which the wire does not publish, adds nothing here.) It used to be
|
||||
// enforced only by the CLI ahead of the role, so an HTTP or embedded caller
|
||||
// could gate bd-abc.1 on bd-abc.
|
||||
//
|
||||
// POSITIVE HALF: the hierarchy itself — a parent-child edge to the IMMEDIATE
|
||||
// dotted parent — is allowed, and so is an edge between siblings. A body that
|
||||
// refused every edge touching a dotted id would satisfy the refusals alone.
|
||||
//
|
||||
// WITH THE HIERARCHY STORED: once that parent-child edge exists (the shape
|
||||
// `bd create --parent` leaves), a blocking edge on the same pair is still this
|
||||
// refusal, not the type or hierarchy conflict the stored edge would raise — the
|
||||
// rule reads nothing, so it answers first — and the stored edge survives.
|
||||
func RunDependencyEditorRefusesADottedChildGatedOnItsOwnParent(t *testing.T, ctx context.Context, fixture DependencyEditorFixture) {
|
||||
t.Helper()
|
||||
parent := fixture.IssuePrefix + "-dotted"
|
||||
child := parent + ".1"
|
||||
grandchild := child + ".2"
|
||||
sibling := parent + ".3"
|
||||
for _, id := range []string{parent, child, grandchild, sibling} {
|
||||
seedDependencyEditorIssue(t, ctx, fixture, id)
|
||||
}
|
||||
|
||||
for _, refused := range []struct {
|
||||
name string
|
||||
edge publicops.DependencyEdge
|
||||
}{
|
||||
{"child blocks on its parent", publicops.DependencyEdge{IssueID: child, DependsOnID: parent, Type: publicops.DepBlocks}},
|
||||
{"grandchild blocks on its grandparent", publicops.DependencyEdge{IssueID: grandchild, DependsOnID: parent, Type: publicops.DepBlocks}},
|
||||
{"grandchild parent-child to its grandparent", publicops.DependencyEdge{IssueID: grandchild, DependsOnID: parent, Type: publicops.DepParentChild}},
|
||||
{"child relates to its parent", publicops.DependencyEdge{IssueID: child, DependsOnID: parent, Type: publicops.DepRelated}},
|
||||
} {
|
||||
_, err := fixture.Editor.AddDependencies(ctx, publicops.AddDependenciesRequest{
|
||||
Actor: "writer",
|
||||
Edges: []publicops.DependencyEdge{refused.edge},
|
||||
})
|
||||
var dotted *publicops.DottedChildDependencyError
|
||||
if !errors.As(err, &dotted) {
|
||||
t.Errorf("%s: error = %v, want *DottedChildDependencyError", refused.name, err)
|
||||
continue
|
||||
}
|
||||
if !errors.Is(err, publicops.ErrValidation) {
|
||||
t.Errorf("%s: error = %v, want it to match ErrValidation", refused.name, err)
|
||||
}
|
||||
if dotted.IssueID != refused.edge.IssueID || dotted.DependsOnID != refused.edge.DependsOnID {
|
||||
t.Errorf("%s: refusal names %s -> %s, want %s -> %s", refused.name,
|
||||
dotted.IssueID, dotted.DependsOnID, refused.edge.IssueID, refused.edge.DependsOnID)
|
||||
}
|
||||
}
|
||||
assertDependencyEditorNoEdgesFrom(t, ctx, fixture, child, grandchild)
|
||||
|
||||
if _, err := fixture.Editor.AddDependencies(ctx, publicops.AddDependenciesRequest{
|
||||
Actor: "writer",
|
||||
Edges: []publicops.DependencyEdge{
|
||||
{IssueID: grandchild, DependsOnID: child, Type: publicops.DepParentChild},
|
||||
{IssueID: sibling, DependsOnID: child, Type: publicops.DepBlocks},
|
||||
},
|
||||
}); err != nil {
|
||||
t.Fatalf("the immediate parent-child edge and a sibling edge: %v", err)
|
||||
}
|
||||
assertDependencyEdgeTypedCount(t, ctx, fixture, "dependencies", grandchild, child, string(publicops.DepParentChild), 1)
|
||||
assertDependencyEdgeCount(t, ctx, fixture, "dependencies", sibling, child, 1)
|
||||
|
||||
_, err := fixture.Editor.AddDependencies(ctx, publicops.AddDependenciesRequest{
|
||||
Actor: "writer",
|
||||
Edges: []publicops.DependencyEdge{{IssueID: grandchild, DependsOnID: child, Type: publicops.DepBlocks}},
|
||||
})
|
||||
var dotted *publicops.DottedChildDependencyError
|
||||
if !errors.As(err, &dotted) || !errors.Is(err, publicops.ErrValidation) {
|
||||
t.Errorf("blocks on a parent whose parent-child edge is stored: error = %v, want *DottedChildDependencyError matching ErrValidation", err)
|
||||
}
|
||||
assertDependencyEdgeTypedCount(t, ctx, fixture, "dependencies", grandchild, child, string(publicops.DepParentChild), 1)
|
||||
assertDependencyEdgeCount(t, ctx, fixture, "dependencies", grandchild, child, 1)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -61,6 +61,7 @@ var roleContractCases = []roleContract{
|
|||
RunBatchApplyUpdateItemsRefuseATemplate,
|
||||
RunBatchApplySplicesTheMetadataOfATemplateItCreates,
|
||||
RunBatchApplyCloseItemsAnswerToTheCloseGuards,
|
||||
RunBatchApplyRefusesADottedChildGatedOnItsOwnParent,
|
||||
),
|
||||
|
||||
roleCases("BatchCloser", "BatchCloser()", oncePerRole,
|
||||
|
|
@ -301,6 +302,7 @@ var roleContractCases = []roleContract{
|
|||
RunDependencyEditorAcceptsADiamond,
|
||||
RunDependencyEditorGateScopeFollowsTheEdgeType,
|
||||
RunDependencyEditorAcceptsBlockingAcrossIssueTypes,
|
||||
RunDependencyEditorRefusesADottedChildGatedOnItsOwnParent,
|
||||
),
|
||||
|
||||
// The accessor named here is not an accessor at all, alone among these
|
||||
|
|
|
|||
|
|
@ -676,7 +676,6 @@ go_test(
|
|||
"dep_test.go",
|
||||
"dep_warning_test.go",
|
||||
"dependency_hierarchy_embedded_test.go",
|
||||
"dependency_hierarchy_test.go",
|
||||
"diff_embedded_test.go",
|
||||
"directory_flag_test.go",
|
||||
"doctor_backend_guard_test.go",
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@ import (
|
|||
"github.com/steveyegge/beads/internal/storage"
|
||||
"github.com/steveyegge/beads/internal/storage/issueops"
|
||||
"github.com/steveyegge/beads/internal/types"
|
||||
publicops "github.com/steveyegge/beads/issueops"
|
||||
)
|
||||
|
||||
// Scope note:
|
||||
|
|
@ -417,27 +418,14 @@ func runBatchOp(ctx context.Context, tx storage.Transaction, op batchOp) (batchO
|
|||
return result, nil
|
||||
|
||||
case "dep.add":
|
||||
if len(op.args) < 2 {
|
||||
return result, fmt.Errorf("dep add requires <from-id> <to-id>")
|
||||
}
|
||||
from, to := op.args[0], op.args[1]
|
||||
depType := "blocks"
|
||||
if len(op.args) >= 3 {
|
||||
depType = op.args[2]
|
||||
}
|
||||
dt := types.DependencyType(depType)
|
||||
if !dt.IsValid() {
|
||||
return result, fmt.Errorf("dep add: invalid dependency type %q", depType)
|
||||
}
|
||||
dep := &types.Dependency{
|
||||
IssueID: from,
|
||||
DependsOnID: to,
|
||||
Type: dt,
|
||||
dep, err := batchDepAddEdge(op.args)
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
if err := tx.AddDependency(ctx, dep, actorName); err != nil {
|
||||
return result, err
|
||||
}
|
||||
result.Target = fmt.Sprintf("%s->%s", from, to)
|
||||
result.Target = fmt.Sprintf("%s->%s", dep.IssueID, dep.DependsOnID)
|
||||
return result, nil
|
||||
|
||||
case "dep.remove":
|
||||
|
|
@ -454,6 +442,38 @@ func runBatchOp(ctx context.Context, tx storage.Transaction, op batchOp) (batchO
|
|||
return result, fmt.Errorf("internal: unhandled batch op %q", op.cmd)
|
||||
}
|
||||
|
||||
// batchDepAddEdge builds the edge a `dep add <from-id> <to-id> [type]` line
|
||||
// asks for. Both backends' dispatch switches call it, so the default type, the
|
||||
// arity and type errors, and the dotted-id hierarchy rule cannot drift between
|
||||
// them.
|
||||
// Neither backend writes the edge through the DependencyEditor role that
|
||||
// enforces that rule (storage.Transaction.AddDependency and the unit of work's
|
||||
// AddDependencies verb do not), so batch asks the role's rule directly, the
|
||||
// way bd link does: a script line `dep add bd-abc.1 bd-abc` is refused, and
|
||||
// rolls the batch back, exactly as `bd dep add bd-abc.1 bd-abc` is.
|
||||
func batchDepAddEdge(args []string) (*types.Dependency, error) {
|
||||
if len(args) < 2 {
|
||||
return nil, fmt.Errorf("dep add requires <from-id> <to-id>")
|
||||
}
|
||||
from, to := args[0], args[1]
|
||||
depType := "blocks"
|
||||
if len(args) >= 3 {
|
||||
depType = args[2]
|
||||
}
|
||||
dt := types.DependencyType(depType)
|
||||
if !dt.IsValid() {
|
||||
return nil, fmt.Errorf("dep add: invalid dependency type %q", depType)
|
||||
}
|
||||
if err := publicops.CheckDottedChildDependency(from, to, dt); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &types.Dependency{
|
||||
IssueID: from,
|
||||
DependsOnID: to,
|
||||
Type: dt,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// parseUpdateKVs walks a slice of "key=value" tokens and builds the updates
|
||||
// map accepted by storage.Transaction.UpdateIssue. Only a small, documented
|
||||
// subset of fields is allowed — anything else is a hard error so typos in
|
||||
|
|
|
|||
|
|
@ -259,6 +259,77 @@ func assertBatchParity(t *testing.T, classic, proxied batchParityOutcome) {
|
|||
}
|
||||
}
|
||||
|
||||
// TestProxiedServerBatchDepAddRefusesADottedChildGatedOnItsParent pins the
|
||||
// dotted-id hierarchy rule on a batched `dep add`. Neither backend writes that
|
||||
// edge through the DependencyEditor role that enforces the rule, so batch asks
|
||||
// the rule itself (batchDepAddEdge). Both backends must refuse bd-abc.1 ->
|
||||
// bd-abc with the sentence `bd dep add` prints, name the line, and roll the
|
||||
// whole batch back, while the one edge the rule allows — parent-child to the
|
||||
// immediate parent — still lands.
|
||||
func TestProxiedServerBatchDepAddRefusesADottedChildGatedOnItsParent(t *testing.T) {
|
||||
requireSharedProxiedServer(t)
|
||||
t.Parallel()
|
||||
bd := buildEmbeddedBD(t)
|
||||
|
||||
type outcome struct {
|
||||
refusedCode int
|
||||
refusalReported bool
|
||||
rolledBack bool
|
||||
edgesAfterRefusal int
|
||||
allowedCode int
|
||||
edgesAfterAllowed int
|
||||
}
|
||||
outcomes := make(map[string]outcome, 2)
|
||||
|
||||
for _, env := range newCrossModeEnvs(t, bd, "bdc", "bdp") {
|
||||
var got outcome
|
||||
|
||||
parent := env.create(t, "Dotted parent")
|
||||
// An explicit dotted id stores no parent-child edge (only --parent
|
||||
// does), so every edge counted below is one a batch wrote.
|
||||
child := env.create(t, "Dotted child", "--id", parent+".1", "--priority", "2")
|
||||
|
||||
// Line 1 is a valid write the refusal on line 2 must take back with it.
|
||||
script := fmt.Sprintf("update %s priority=1\ndep add %s %s\n", child, child, parent)
|
||||
stdout, stderr, code := env.runStdin(t, script, "batch")
|
||||
// The failing line is named the way any failing line is, around the
|
||||
// sentence `bd dep add` prints for the same edge.
|
||||
refusal := fmt.Sprintf("line 2 (dep add %s %s): cannot add dependency: %s is already a child of %s.",
|
||||
child, parent, child, parent)
|
||||
got.refusedCode = code
|
||||
got.refusalReported = strings.Contains(stdout+stderr, refusal)
|
||||
got.rolledBack = env.show(t, child).Priority == 2
|
||||
got.edgesAfterRefusal = len(env.depList(t, child))
|
||||
if got.refusedCode == 0 || !got.refusalReported {
|
||||
t.Errorf("[%s] batch exit=%d, want non-zero and %q\nstdout:\n%s\nstderr:\n%s",
|
||||
env.mode, code, refusal, stdout, stderr)
|
||||
}
|
||||
|
||||
stdout, stderr, code = env.runStdin(t, fmt.Sprintf("dep add %s %s parent-child\n", child, parent), "batch")
|
||||
got.allowedCode = code
|
||||
if code != 0 {
|
||||
t.Fatalf("[%s] batch parent-child dep add failed with exit %d\nstdout:\n%s\nstderr:\n%s", env.mode, code, stdout, stderr)
|
||||
}
|
||||
got.edgesAfterAllowed = len(env.depList(t, child))
|
||||
|
||||
outcomes[env.mode] = got
|
||||
|
||||
if !got.rolledBack {
|
||||
t.Errorf("[%s] the refused line did not roll back line 1's priority write", env.mode)
|
||||
}
|
||||
if got.edgesAfterRefusal != 0 {
|
||||
t.Errorf("[%s] the refused batch left %d edges on the child, want 0", env.mode, got.edgesAfterRefusal)
|
||||
}
|
||||
if got.edgesAfterAllowed != 1 {
|
||||
t.Errorf("[%s] batch parent-child dep add: %d edges on the child, want 1", env.mode, got.edgesAfterAllowed)
|
||||
}
|
||||
}
|
||||
|
||||
if outcomes["classic"] != outcomes["proxied"] {
|
||||
t.Errorf("cross-mode divergence:\nclassic=%+v\nproxied=%+v", outcomes["classic"], outcomes["proxied"])
|
||||
}
|
||||
}
|
||||
|
||||
// depList reads the dependency records of one issue as a flat array, the shape
|
||||
// `bd dep list --json` documents.
|
||||
func (e crossModeEnv) depList(t *testing.T, id string) []map[string]any {
|
||||
|
|
|
|||
|
|
@ -161,22 +161,9 @@ func runBatchOpUOW(ctx context.Context, uw uow.UnitOfWork, op batchOp) (batchOpR
|
|||
return result, nil
|
||||
|
||||
case "dep.add":
|
||||
if len(op.args) < 2 {
|
||||
return result, fmt.Errorf("dep add requires <from-id> <to-id>")
|
||||
}
|
||||
from, to := op.args[0], op.args[1]
|
||||
depType := "blocks"
|
||||
if len(op.args) >= 3 {
|
||||
depType = op.args[2]
|
||||
}
|
||||
dt := types.DependencyType(depType)
|
||||
if !dt.IsValid() {
|
||||
return result, fmt.Errorf("dep add: invalid dependency type %q", depType)
|
||||
}
|
||||
dep := &types.Dependency{
|
||||
IssueID: from,
|
||||
DependsOnID: to,
|
||||
Type: dt,
|
||||
dep, err := batchDepAddEdge(op.args)
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
// AddDependencies (not the single-edge AddDependency) because it lands
|
||||
// each edge in the plane its own SOURCE lives in, which is the routing
|
||||
|
|
@ -198,7 +185,7 @@ func runBatchOpUOW(ctx context.Context, uw uow.UnitOfWork, op batchOp) (batchOpR
|
|||
if _, err := uw.DependencyUseCase().AddDependencies(ctx, []*types.Dependency{dep}, actorName, domain.BulkAddDepsOpts{}); err != nil {
|
||||
return result, err
|
||||
}
|
||||
result.Target = fmt.Sprintf("%s->%s", from, to)
|
||||
result.Target = fmt.Sprintf("%s->%s", dep.IssueID, dep.DependsOnID)
|
||||
return result, nil
|
||||
|
||||
case "dep.remove":
|
||||
|
|
|
|||
|
|
@ -1,9 +1,13 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/steveyegge/beads/internal/types"
|
||||
publicops "github.com/steveyegge/beads/issueops"
|
||||
)
|
||||
|
||||
func TestTokenizeBatchLine(t *testing.T) {
|
||||
|
|
@ -261,6 +265,91 @@ func TestParseUpdateKVs(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
// TestBatchDepAddEdge pins the edge a `dep add` line builds on both backends,
|
||||
// and that the line asks the dotted-id hierarchy rule before either backend
|
||||
// writes: the refusal is the role's own typed error, so a batch prints the
|
||||
// sentence `bd dep add` prints and rolls back on it.
|
||||
func TestBatchDepAddEdge(t *testing.T) {
|
||||
tooLong := strings.Repeat("x", types.MaxDependencyTypeLen+1)
|
||||
tests := []struct {
|
||||
name string
|
||||
args []string
|
||||
want *types.Dependency
|
||||
wantErr string
|
||||
wantDotted bool
|
||||
}{
|
||||
{
|
||||
name: "default type is blocks",
|
||||
args: []string{"bd-1", "bd-2"},
|
||||
want: &types.Dependency{IssueID: "bd-1", DependsOnID: "bd-2", Type: types.DepBlocks},
|
||||
},
|
||||
{
|
||||
name: "explicit type",
|
||||
args: []string{"bd-1", "bd-2", "related"},
|
||||
want: &types.Dependency{IssueID: "bd-1", DependsOnID: "bd-2", Type: types.DepRelated},
|
||||
},
|
||||
{
|
||||
name: "missing to-id",
|
||||
args: []string{"bd-1"},
|
||||
wantErr: "dep add requires <from-id> <to-id>",
|
||||
},
|
||||
{
|
||||
name: "invalid type",
|
||||
args: []string{"bd-1", "bd-2", tooLong},
|
||||
wantErr: `dep add: invalid dependency type "` + tooLong + `"`,
|
||||
},
|
||||
{
|
||||
name: "dotted child gated on its own parent",
|
||||
args: []string{"bd-abc.1", "bd-abc"},
|
||||
wantDotted: true,
|
||||
},
|
||||
{
|
||||
name: "any explicit type up the tree, not only blocking ones",
|
||||
args: []string{"bd-abc.1", "bd-abc", "related"},
|
||||
wantDotted: true,
|
||||
},
|
||||
{
|
||||
name: "parent-child past the immediate parent",
|
||||
args: []string{"bd-abc.1.2", "bd-abc", "parent-child"},
|
||||
wantDotted: true,
|
||||
},
|
||||
{
|
||||
name: "parent-child to the immediate parent is the hierarchy itself",
|
||||
args: []string{"bd-abc.1", "bd-abc", "parent-child"},
|
||||
want: &types.Dependency{IssueID: "bd-abc.1", DependsOnID: "bd-abc", Type: types.DepParentChild},
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got, err := batchDepAddEdge(tt.args)
|
||||
switch {
|
||||
case tt.wantDotted:
|
||||
var dotted *publicops.DottedChildDependencyError
|
||||
if !errors.As(err, &dotted) {
|
||||
t.Fatalf("batchDepAddEdge(%q) = %+v, %v; want *DottedChildDependencyError", tt.args, got, err)
|
||||
}
|
||||
if !errors.Is(err, publicops.ErrValidation) {
|
||||
t.Errorf("refusal %v does not match ErrValidation", err)
|
||||
}
|
||||
if dotted.IssueID != tt.args[0] || dotted.DependsOnID != tt.args[1] {
|
||||
t.Errorf("refusal names %s -> %s, want %s -> %s", dotted.IssueID, dotted.DependsOnID, tt.args[0], tt.args[1])
|
||||
}
|
||||
case tt.wantErr != "":
|
||||
if err == nil || err.Error() != tt.wantErr {
|
||||
t.Fatalf("batchDepAddEdge(%q) err = %v, want %q", tt.args, err, tt.wantErr)
|
||||
}
|
||||
default:
|
||||
if err != nil {
|
||||
t.Fatalf("batchDepAddEdge(%q): %v", tt.args, err)
|
||||
}
|
||||
if !reflect.DeepEqual(got, tt.want) {
|
||||
t.Errorf("batchDepAddEdge(%q) = %+v, want %+v", tt.args, got, tt.want)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestBatchCmd_Registered(t *testing.T) {
|
||||
// Ensure 'bd batch' is wired into rootCmd with the correct group.
|
||||
cmd, _, err := rootCmd.Find([]string{"batch"})
|
||||
|
|
|
|||
|
|
@ -213,41 +213,6 @@ func resolveUnresolvedDepTarget(sourceID, dependsOnArg string, resolveErr error)
|
|||
return "", fmt.Errorf("resolving dependency ID %s: %v", dependsOnArg, resolveErr)
|
||||
}
|
||||
|
||||
// isChildOf returns true if childID is a hierarchical child of parentID.
|
||||
// For example, "bd-abc.1" is a child of "bd-abc", and "bd-abc.1.2" is a child of "bd-abc.1".
|
||||
func isChildOf(childID, parentID string) bool {
|
||||
_, isAncestor := hierarchicalParentRelation(childID, parentID)
|
||||
return isAncestor
|
||||
}
|
||||
|
||||
func hierarchicalParentRelation(childID, targetID string) (immediateParent string, isAncestor bool) {
|
||||
// A child ID has the format "parentID.N" or "parentID.N.M" etc.
|
||||
// Use ParseHierarchicalID to get the actual parent
|
||||
_, actualParentID, depth := types.ParseHierarchicalID(childID)
|
||||
if depth == 0 {
|
||||
return "", false // Not a hierarchical ID
|
||||
}
|
||||
// Check if the immediate parent matches
|
||||
if actualParentID == targetID {
|
||||
return actualParentID, true
|
||||
}
|
||||
// Also check if targetID is an ancestor (e.g., "bd-abc" is an ancestor of "bd-abc.1.2")
|
||||
return actualParentID, strings.HasPrefix(childID, targetID+".")
|
||||
}
|
||||
|
||||
// isDisallowedHierarchicalDependency reports whether an explicit dependency
|
||||
// conflicts with hierarchy encoded in a dotted issue ID. The one allowed match
|
||||
// is a parent-child edge to the immediate dotted-ID parent; blocking and other
|
||||
// edge types to any parent/ancestor, plus parent-child edges to higher ancestors,
|
||||
// remain rejected.
|
||||
func isDisallowedHierarchicalDependency(fromID, toID string, depType types.DependencyType) bool {
|
||||
immediateParent, isAncestor := hierarchicalParentRelation(fromID, toID)
|
||||
if !isAncestor {
|
||||
return false
|
||||
}
|
||||
return depType != types.DepParentChild || toID != immediateParent
|
||||
}
|
||||
|
||||
var depCmd = &cobra.Command{
|
||||
Use: "dep [issue-id]",
|
||||
GroupID: "deps",
|
||||
|
|
@ -312,10 +277,6 @@ Examples:
|
|||
}
|
||||
defer toCleanup()
|
||||
|
||||
if isDisallowedHierarchicalDependency(fromID, toID, types.DepBlocks) {
|
||||
return HandleErrorRespectJSON("cannot add dependency: %s is already a child of %s. Children inherit dependency on parent completion via hierarchy. Adding an explicit dependency would create a deadlock", fromID, toID)
|
||||
}
|
||||
|
||||
opsCtx, err := issueOpsContext(ctx)
|
||||
if err != nil {
|
||||
return HandleErrorRespectJSON("%v", err)
|
||||
|
|
@ -498,9 +459,8 @@ Examples:
|
|||
}
|
||||
|
||||
dt := canonicalDependencyType(types.DependencyType(depType))
|
||||
if isDisallowedHierarchicalDependency(fromID, toID, dt) {
|
||||
return HandleErrorRespectJSON("cannot add dependency: %s is already a child of %s. Children inherit dependency on parent completion via hierarchy. Adding an explicit dependency would create a deadlock", fromID, toID)
|
||||
}
|
||||
// The dotted-id hierarchy refusal is the role's
|
||||
// (issueops.CheckDottedChildDependency), raised by AddDependencies below.
|
||||
|
||||
if err := validateDependencyType(dt); err != nil {
|
||||
return HandleErrorRespectJSON("%v", err)
|
||||
|
|
@ -827,7 +787,9 @@ func validateBulkDepEdges(ctx context.Context, edges []bulkDepEdge) ([]bulkDepEd
|
|||
current.DependsOnID = toID
|
||||
}
|
||||
|
||||
if isDisallowedHierarchicalDependency(current.IssueID, current.DependsOnID, current.Type) {
|
||||
// The role refuses this edge too; asking the library rule here only lets
|
||||
// the bulk report name every offending line before anything is written.
|
||||
if issueops.IsDottedChildDependency(current.IssueID, current.DependsOnID, current.Type) {
|
||||
errs = append(errs, fmt.Sprintf("line %d: cannot add dependency: %s is already a child of %s", edge.Line, current.IssueID, current.DependsOnID))
|
||||
resolved = append(resolved, current)
|
||||
continue
|
||||
|
|
|
|||
|
|
@ -177,10 +177,6 @@ func runDepBlocksProxiedServer(cmd *cobra.Command, ctx context.Context, blockerI
|
|||
return HandleErrorRespectJSON("%v", err)
|
||||
}
|
||||
|
||||
if isDisallowedHierarchicalDependency(blockedID, blockerID, types.DepBlocks) {
|
||||
return HandleErrorRespectJSON("cannot add dependency: %s is already a child of %s. Children inherit dependency on parent completion via hierarchy. Adding an explicit dependency would create a deadlock", blockedID, blockerID)
|
||||
}
|
||||
|
||||
noCycleCheck, _ := cmd.Flags().GetBool("no-cycle-check")
|
||||
|
||||
edge := issueops.DependencyEdge{IssueID: blockedID, DependsOnID: blockerID, Type: types.DepBlocks}
|
||||
|
|
@ -247,9 +243,6 @@ func runDepAddProxiedServer(cmd *cobra.Command, ctx context.Context, args []stri
|
|||
toID = dependsOnArg
|
||||
|
||||
dt := canonicalDependencyType(types.DependencyType(depType))
|
||||
if isDisallowedHierarchicalDependency(fromID, toID, dt) {
|
||||
return HandleErrorRespectJSON("cannot add dependency: %s is already a child of %s. Children inherit dependency on parent completion via hierarchy. Adding an explicit dependency would create a deadlock", fromID, toID)
|
||||
}
|
||||
|
||||
if err := validateDependencyType(dt); err != nil {
|
||||
return HandleErrorRespectJSON("%v", err)
|
||||
|
|
@ -299,7 +292,7 @@ func runDepAddBulkProxied(cmd *cobra.Command, ctx context.Context, file, default
|
|||
|
||||
depEdges := make([]issueops.DependencyEdge, 0, len(edges))
|
||||
for _, edge := range edges {
|
||||
if isDisallowedHierarchicalDependency(edge.IssueID, edge.DependsOnID, edge.Type) {
|
||||
if issueops.IsDottedChildDependency(edge.IssueID, edge.DependsOnID, edge.Type) {
|
||||
return HandleErrorRespectJSON("line %d: cannot add dependency: %s is already a child of %s", edge.Line, edge.IssueID, edge.DependsOnID)
|
||||
}
|
||||
if strings.HasPrefix(edge.DependsOnID, "external:") {
|
||||
|
|
|
|||
|
|
@ -1080,88 +1080,6 @@ func TestTreeNodeJSONIncludesEdgeFromParent(t *testing.T) {
|
|||
// These tests serve as regression tests ensuring the storage layer
|
||||
// continues to provide user-friendly error messages.
|
||||
|
||||
func TestIsChildOf(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
childID string
|
||||
parentID string
|
||||
want bool
|
||||
}{
|
||||
// Positive cases: should be detected as child
|
||||
{
|
||||
name: "direct child",
|
||||
childID: "bd-abc.1",
|
||||
parentID: "bd-abc",
|
||||
want: true,
|
||||
},
|
||||
{
|
||||
name: "grandchild",
|
||||
childID: "bd-abc.1.2",
|
||||
parentID: "bd-abc",
|
||||
want: true,
|
||||
},
|
||||
{
|
||||
name: "nested grandchild direct parent",
|
||||
childID: "bd-abc.1.2",
|
||||
parentID: "bd-abc.1",
|
||||
want: true,
|
||||
},
|
||||
{
|
||||
name: "deeply nested child",
|
||||
childID: "bd-abc.1.2.3",
|
||||
parentID: "bd-abc",
|
||||
want: true,
|
||||
},
|
||||
|
||||
// Negative cases: should NOT be detected as child
|
||||
{
|
||||
name: "same ID",
|
||||
childID: "bd-abc",
|
||||
parentID: "bd-abc",
|
||||
want: false,
|
||||
},
|
||||
{
|
||||
name: "not a child - unrelated IDs",
|
||||
childID: "bd-xyz",
|
||||
parentID: "bd-abc",
|
||||
want: false,
|
||||
},
|
||||
{
|
||||
name: "not a child - sibling",
|
||||
childID: "bd-abc.2",
|
||||
parentID: "bd-abc.1",
|
||||
want: false,
|
||||
},
|
||||
{
|
||||
name: "reversed - parent is not child of child",
|
||||
childID: "bd-abc",
|
||||
parentID: "bd-abc.1",
|
||||
want: false,
|
||||
},
|
||||
{
|
||||
name: "prefix but not hierarchical",
|
||||
childID: "bd-abcd",
|
||||
parentID: "bd-abc",
|
||||
want: false,
|
||||
},
|
||||
{
|
||||
name: "not hierarchical ID",
|
||||
childID: "bd-abc",
|
||||
parentID: "bd-xyz",
|
||||
want: false,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got := isChildOf(tt.childID, tt.parentID)
|
||||
if got != tt.want {
|
||||
t.Errorf("isChildOf(%q, %q) = %v, want %v", tt.childID, tt.parentID, got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestDepRoutedTargetOpensReadOnly is the regression guard for the dep/link
|
||||
// target-resolution invariant: a cross-rig dependency target is resolved by ID
|
||||
// only, so resolveIDWithRouting must open the routed foreign store read-only,
|
||||
|
|
|
|||
|
|
@ -1,55 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/steveyegge/beads/internal/types"
|
||||
)
|
||||
|
||||
func TestIsDisallowedHierarchicalDependency(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
fromID string
|
||||
toID string
|
||||
depType types.DependencyType
|
||||
want bool
|
||||
}{
|
||||
{
|
||||
name: "immediate parent-child allowed",
|
||||
fromID: "bd-root.1.2",
|
||||
toID: "bd-root.1",
|
||||
depType: types.DepParentChild,
|
||||
want: false,
|
||||
},
|
||||
{
|
||||
name: "immediate parent blocks rejected",
|
||||
fromID: "bd-root.1.2",
|
||||
toID: "bd-root.1",
|
||||
depType: types.DepBlocks,
|
||||
want: true,
|
||||
},
|
||||
{
|
||||
name: "grandparent parent-child rejected",
|
||||
fromID: "bd-root.1.2",
|
||||
toID: "bd-root",
|
||||
depType: types.DepParentChild,
|
||||
want: true,
|
||||
},
|
||||
{
|
||||
name: "unrelated target allowed",
|
||||
fromID: "bd-root.1.2",
|
||||
toID: "bd-other",
|
||||
depType: types.DepBlocks,
|
||||
want: false,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got := isDisallowedHierarchicalDependency(tt.fromID, tt.toID, tt.depType)
|
||||
if got != tt.want {
|
||||
t.Fatalf("isDisallowedHierarchicalDependency(%q, %q, %q) = %v, want %v", tt.fromID, tt.toID, tt.depType, got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -143,7 +143,7 @@ type GraphApplyDryRunRow struct {
|
|||
ParentID string `json:"parent_id,omitempty"`
|
||||
}
|
||||
|
||||
const graphApplyDryRunTransactionValidationNote = "dry-run validates the graph structure only; live create may still reject parent-child blocking paths after resolving stored dependencies"
|
||||
const graphApplyDryRunTransactionValidationNote = "dry-run validates the graph structure only; live create may still reject parent-child blocking paths after resolving stored dependencies, or an edge that gates a dotted-id child on its own ancestor"
|
||||
|
||||
// Known-field sets list the JSON keys recognized on each plan struct; unknown
|
||||
// keys warn about schema typos. Derived from json tags so they can't drift. (GH#3367)
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ import (
|
|||
"github.com/steveyegge/beads/internal/storage"
|
||||
"github.com/steveyegge/beads/internal/types"
|
||||
"github.com/steveyegge/beads/internal/ui"
|
||||
"github.com/steveyegge/beads/issueops"
|
||||
)
|
||||
|
||||
var linkCmd = &cobra.Command{
|
||||
|
|
@ -63,8 +64,10 @@ Examples:
|
|||
defer toCleanup()
|
||||
|
||||
dt := types.DependencyType(depType)
|
||||
if isDisallowedHierarchicalDependency(fromID, toID, dt) {
|
||||
return HandleErrorRespectJSON("cannot add dependency: %s is already a child of %s. Children inherit dependency on parent completion via hierarchy. Adding an explicit dependency would create a deadlock", fromID, toID)
|
||||
// bd link writes through the store's own dependency verb rather than
|
||||
// the DependencyEditor role, so it asks the role's rule directly.
|
||||
if err := issueops.CheckDottedChildDependency(fromID, toID, dt); err != nil {
|
||||
return HandleErrorRespectJSON("%v", err)
|
||||
}
|
||||
|
||||
if !dt.IsValid() {
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ import (
|
|||
"github.com/steveyegge/beads/internal/storage/uow"
|
||||
"github.com/steveyegge/beads/internal/types"
|
||||
"github.com/steveyegge/beads/internal/ui"
|
||||
"github.com/steveyegge/beads/issueops"
|
||||
)
|
||||
|
||||
func runLinkProxiedServer(cmd *cobra.Command, ctx context.Context, args []string) error {
|
||||
|
|
@ -18,8 +19,8 @@ func runLinkProxiedServer(cmd *cobra.Command, ctx context.Context, args []string
|
|||
depType, _ := cmd.Flags().GetString("type")
|
||||
|
||||
dt := types.DependencyType(depType)
|
||||
if isDisallowedHierarchicalDependency(id1, id2, dt) {
|
||||
return HandleErrorRespectJSON("cannot add dependency: %s is already a child of %s. Children inherit dependency on parent completion via hierarchy. Adding an explicit dependency would create a deadlock", id1, id2)
|
||||
if err := issueops.CheckDottedChildDependency(id1, id2, dt); err != nil {
|
||||
return HandleErrorRespectJSON("%v", err)
|
||||
}
|
||||
|
||||
if !dt.IsValid() {
|
||||
|
|
|
|||
|
|
@ -889,6 +889,19 @@ func TestApplyBatchMapsTheRolesTypedRefusalsOntoTheDocumentedCodes(t *testing.T)
|
|||
wantStatus: http.StatusNotFound,
|
||||
wantCode: "not_found",
|
||||
},
|
||||
{
|
||||
// The dotted-id hierarchy rule is request validation (it unwraps to
|
||||
// ErrValidation), never the hierarchy CONFLICT's dependency_cycle:
|
||||
// it is decided from the two resolved ids, ahead of every check that
|
||||
// reads the stored graph, so even a child whose parent-child edge IS
|
||||
// stored gets this 400, with no hierarchy members to describe.
|
||||
name: "a dotted child gated on its own parent",
|
||||
err: itemErr(0, issueops.ItemDepAdd, "", "bd-1.1",
|
||||
&issueops.DottedChildDependencyError{IssueID: "bd-1.1", DependsOnID: "bd-1", Type: issueops.DepBlocks}),
|
||||
wantStatus: http.StatusBadRequest,
|
||||
wantCode: "invalid_argument",
|
||||
wantParam: "items",
|
||||
},
|
||||
{
|
||||
name: "the workspace's own validation",
|
||||
err: itemErr(0, issueops.ItemCreate, "", "", storage.ErrValidation),
|
||||
|
|
|
|||
|
|
@ -564,6 +564,20 @@ func TestAddDependenciesMapsTheGraphsTypedRefusals(t *testing.T) {
|
|||
wantCode: CodeInvalidArgument,
|
||||
wantMembers: map[string]any{"param": "edges[0].depends_on_id"},
|
||||
},
|
||||
{
|
||||
// The dotted-id hierarchy rule (issueops.CheckDottedChildDependency)
|
||||
// is the role's validation, so it is the 400 below and never the
|
||||
// hierarchy conflict's dependency_cycle members.
|
||||
name: "a dotted child gated on its own parent is a 400 on edges",
|
||||
body: oneEdge,
|
||||
err: &issueops.DottedChildDependencyError{
|
||||
IssueID: "bd-1.1", DependsOnID: "bd-1", Type: issueops.DepBlocks,
|
||||
},
|
||||
wantStatus: http.StatusBadRequest,
|
||||
wantCode: CodeInvalidArgument,
|
||||
wantMembers: map[string]any{"param": "edges"},
|
||||
absentMembers: []string{"issue_id", "blocker_id", "blocker_is_ancestor"},
|
||||
},
|
||||
{
|
||||
name: "the role's own validation refusal is a 400 on edges",
|
||||
body: oneEdge,
|
||||
|
|
|
|||
|
|
@ -4277,6 +4277,9 @@ paths:
|
|||
or a payload its `kind` does not name, a `create` with no `title`, a
|
||||
duplicate `key`, a `Ref` with neither `key` nor `id` or with both, a
|
||||
`dep_add` with an unstorable `type` or pointing a row at ITSELF, a
|
||||
`dep_add` from a dotted-id child to one of its own ancestors
|
||||
(anything but the parent-child edge to its IMMEDIATE parent, judged
|
||||
once the item's refs resolve and carrying `param` `items`), a
|
||||
`waits-for` gate outside its two values, an item a workspace's own
|
||||
validation refuses, and an edge endpoint that names nothing this
|
||||
database can see. An explicit `create.id` that already names a
|
||||
|
|
@ -4396,7 +4399,9 @@ paths:
|
|||
and `blocker_is_ancestor`. They may come from the per-edge probe or
|
||||
from the END GATE, which is the one place an edge that is legal on
|
||||
its own and illegal in the graph this request built is caught.
|
||||
Neither has a force bypass.
|
||||
Neither has a force bypass. A `dep_add` from a dotted-id child to an
|
||||
ancestor its own id names is neither: it is a `400`
|
||||
`invalid_argument`, as on that operation.
|
||||
|
||||
|
||||
`already_exists` is a `create` item whose EXPLICIT `id` already
|
||||
|
|
@ -5598,13 +5603,19 @@ paths:
|
|||
is empty after trimming, longer than 256 bytes or carrying control
|
||||
characters, an empty or over-long `edges` array, a blank or
|
||||
over-long endpoint id, an unstorable `type`, an edge that points an
|
||||
issue at ITSELF, or an edge endpoint that names nothing this
|
||||
database can see. Nothing is written in any of these cases.
|
||||
issue at ITSELF, an edge from a dotted-id child to one of its own
|
||||
ancestors (anything but the parent-child edge to its IMMEDIATE
|
||||
parent), or an edge endpoint that names nothing this database can
|
||||
see. Nothing is written in any of these cases.
|
||||
|
||||
|
||||
A self-dependency is a `400` rather than a `409` because it is
|
||||
request-intrinsic: it is invalid whatever the graph holds, so it is
|
||||
a refusal of a VALUE and not a statement about state. An endpoint
|
||||
a refusal of a VALUE and not a statement about state. The dotted-id
|
||||
child's edge is a `400` for the same reason, carrying `param`
|
||||
`edges`: the two ids decide it before the graph is read, so even a
|
||||
child whose parent-child edge is already stored gets this `400`,
|
||||
never the `409` hierarchy refusal or `dependency_exists`. An endpoint
|
||||
that names nothing is a `400` rather than a `404` for
|
||||
`POST /v0/beads/issues:batchCreate`'s reason: the refusal is about
|
||||
the request BODY, and there is no id in the path to have missed.
|
||||
|
|
@ -5636,6 +5647,11 @@ paths:
|
|||
|
||||
Neither has a force bypass. The recovery for both is to rethink the
|
||||
edge, which is why they are one status and not a retry.
|
||||
|
||||
|
||||
An edge from a dotted-id child to an ancestor its own id names is
|
||||
neither: it is a `400` `invalid_argument`, decided from the two ids
|
||||
before the graph is read.
|
||||
x-bd-codes: [dependency_cycle, dependency_exists]
|
||||
content:
|
||||
application/problem+json:
|
||||
|
|
|
|||
|
|
@ -135,5 +135,9 @@ func checkEdge(i int, edge issueops.DependencyEdge) error {
|
|||
case edge.IssueID == edge.DependsOnID:
|
||||
return fmt.Errorf("%s: %w", edge.IssueID, issueops.ErrSelfDependency)
|
||||
}
|
||||
return nil
|
||||
// The dotted-id hierarchy rule, for the self-dependency check's reason: the
|
||||
// server refuses it as a 400 that arrives here as a bare ErrValidation,
|
||||
// while the role promises the typed *DottedChildDependencyError. It is the
|
||||
// library's own check, not a restatement.
|
||||
return issueops.CheckDottedChildDependency(edge.IssueID, edge.DependsOnID, edge.Type)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -265,6 +265,10 @@ func TestServedBatchApplyCloseItemsAnswerToTheCloseGuards(t *testing.T) {
|
|||
conformance.RunBatchApplyCloseItemsAnswerToTheCloseGuards(t, t.Context(), newServedBatchApplyFixture(t, "hbacg"))
|
||||
}
|
||||
|
||||
func TestServedBatchApplyRefusesADottedChildGatedOnItsOwnParent(t *testing.T) {
|
||||
conformance.RunBatchApplyRefusesADottedChildGatedOnItsOwnParent(t, t.Context(), newServedBatchApplyFixture(t, "hbadot"))
|
||||
}
|
||||
|
||||
// TestServedBatchApplyStampsSpawnerIDOnlyWhenNamed wires the dep_add
|
||||
// HasSpawner/ThreadID lineage conformance case onto the http leg (S5): a
|
||||
// served default Config always advertises CapBatchApplyDepAddLineage (it is
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ import (
|
|||
"testing"
|
||||
|
||||
"github.com/steveyegge/beads/backend/conformance"
|
||||
"github.com/steveyegge/beads/internal/httpapi/apigen"
|
||||
"github.com/steveyegge/beads/internal/types"
|
||||
"github.com/steveyegge/beads/issueops"
|
||||
)
|
||||
|
|
@ -389,6 +390,10 @@ func TestServedDependencyEditorAcceptsBlockingAcrossIssueTypes(t *testing.T) {
|
|||
conformance.RunDependencyEditorAcceptsBlockingAcrossIssueTypes(t, t.Context(), newServedDependencyEditorFixture(t, "hd32"))
|
||||
}
|
||||
|
||||
func TestServedDependencyEditorRefusesADottedChildGatedOnItsOwnParent(t *testing.T) {
|
||||
conformance.RunDependencyEditorRefusesADottedChildGatedOnItsOwnParent(t, t.Context(), newServedDependencyEditorFixture(t, "hddot"))
|
||||
}
|
||||
|
||||
func TestServedDependencyEditorGateScopeFollowsTheEdgeType(t *testing.T) {
|
||||
conformance.RunDependencyEditorGateScopeFollowsTheEdgeType(t, t.Context(), newServedDependencyEditorFixture(t, "hd33"))
|
||||
}
|
||||
|
|
@ -433,3 +438,37 @@ func TestServedDependencyEditorSameTypeReAddWithIdenticalMetadataIsANoOp(t *test
|
|||
func TestServedDependencyEditorSameTypeReAddWithChangedThreadMintsOneVersion(t *testing.T) {
|
||||
conformance.RunDependencyEditorSameTypeReAddWithChangedThreadMintsOneVersion(t, t.Context(), newServedDependencyEditorFixture(t, "hd41"))
|
||||
}
|
||||
|
||||
// TestServedServerRefusesADottedChildGatedOnItsOwnParent sends the edge on the
|
||||
// raw wire, past the client's own CheckDottedChildDependency, so what refuses
|
||||
// it is the SERVER's role — the leg a non-bd HTTP caller (gc, curl) reaches.
|
||||
// Before the rule moved into issueops only the CLI refused it, and this edge
|
||||
// landed.
|
||||
func TestServedServerRefusesADottedChildGatedOnItsOwnParent(t *testing.T) {
|
||||
env := newServedEnv(t, "hddotw")
|
||||
parent := env.prefix + "-dotted"
|
||||
child := parent + ".1"
|
||||
for _, id := range []string{parent, child} {
|
||||
if err := env.createIssue(t.Context(), &types.Issue{ID: id, Title: id, Status: types.StatusOpen, Priority: 2, IssueType: types.TypeTask}, "seed"); err != nil {
|
||||
t.Fatalf("seed %s: %v", id, err)
|
||||
}
|
||||
}
|
||||
w, err := env.subject.roleWire("DependencyEditor")
|
||||
if err != nil {
|
||||
t.Fatalf("roleWire: %v", err)
|
||||
}
|
||||
_, err = w.AddDependencies(t.Context(), apigen.AddDependenciesRequest{
|
||||
Actor: "writer",
|
||||
Edges: []apigen.DependencyEdge{{IssueId: child, DependsOnId: parent, Type: "blocks"}},
|
||||
})
|
||||
if !errors.Is(err, issueops.ErrValidation) {
|
||||
t.Fatalf("raw-wire child -> parent blocks: error = %v, want the server's ErrValidation refusal", err)
|
||||
}
|
||||
var n int
|
||||
if err := env.queryScalar(t.Context(), "SELECT COUNT(*) FROM dependencies WHERE issue_id = ?", []any{child}, &n); err != nil {
|
||||
t.Fatalf("count edges: %v", err)
|
||||
}
|
||||
if n != 0 {
|
||||
t.Fatalf("%d edge(s) from %s landed; the server must refuse a dotted child gated on its own parent", n, child)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -270,6 +270,11 @@ func TestBatchApplyContract(t *testing.T) {
|
|||
defer cancel()
|
||||
conformance.RunBatchApplyCloseItemsAnswerToTheCloseGuards(t, ctx, fixture)
|
||||
})
|
||||
t.Run("RefusesADottedChildGatedOnItsOwnParent", func(t *testing.T) {
|
||||
ctx, cancel := testContext(t)
|
||||
defer cancel()
|
||||
conformance.RunBatchApplyRefusesADottedChildGatedOnItsOwnParent(t, ctx, fixture)
|
||||
})
|
||||
}
|
||||
|
||||
// newDoltBatchApplyFixture composes the frozen role kit with this backend's
|
||||
|
|
|
|||
|
|
@ -259,6 +259,12 @@ func TestDependencyEditorAcceptsBlockingAcrossIssueTypes(t *testing.T) {
|
|||
conformance.RunDependencyEditorAcceptsBlockingAcrossIssueTypes(t, ctx, fixture)
|
||||
}
|
||||
|
||||
func TestDependencyEditorRefusesADottedChildGatedOnItsOwnParent(t *testing.T) {
|
||||
fixture, ctx, cleanup := newDoltDependencyEditorFixture(t, "dotted")
|
||||
defer cleanup()
|
||||
conformance.RunDependencyEditorRefusesADottedChildGatedOnItsOwnParent(t, ctx, fixture)
|
||||
}
|
||||
|
||||
// newDoltDependencyEditorFixture composes the backend's role fixture kit with
|
||||
// the accessor under test. Every hook but the accessor comes from the kit, so
|
||||
// the seeding and scalar-query plumbing stays identical to the other roles'.
|
||||
|
|
|
|||
|
|
@ -196,6 +196,9 @@ func TestBatchApplyContract(t *testing.T) {
|
|||
t.Run("CloseItemsAnswerToTheCloseGuards", func(t *testing.T) {
|
||||
conformance.RunBatchApplyCloseItemsAnswerToTheCloseGuards(t, ctx, fixture)
|
||||
})
|
||||
t.Run("RefusesADottedChildGatedOnItsOwnParent", func(t *testing.T) {
|
||||
conformance.RunBatchApplyRefusesADottedChildGatedOnItsOwnParent(t, ctx, fixture)
|
||||
})
|
||||
}
|
||||
|
||||
// newEmbeddedBatchApplyFixture composes the frozen role kit with this backend's
|
||||
|
|
|
|||
|
|
@ -261,6 +261,12 @@ func TestEmbeddedDependencyEditorAcceptsBlockingAcrossIssueTypes(t *testing.T) {
|
|||
conformance.RunDependencyEditorAcceptsBlockingAcrossIssueTypes(t, ctx, newEmbeddedDependencyEditorFixture(t, ctx, "xtype"))
|
||||
}
|
||||
|
||||
func TestEmbeddedDependencyEditorRefusesADottedChildGatedOnItsOwnParent(t *testing.T) {
|
||||
skipUnlessEmbeddedDolt(t)
|
||||
ctx := t.Context()
|
||||
conformance.RunDependencyEditorRefusesADottedChildGatedOnItsOwnParent(t, ctx, newEmbeddedDependencyEditorFixture(t, ctx, "dotted"))
|
||||
}
|
||||
|
||||
// newEmbeddedDependencyEditorFixture composes the backend's role fixture kit
|
||||
// with the accessor under test. Every hook but the accessor comes from the kit,
|
||||
// so the seeding and scalar-query plumbing stays identical to the other roles'.
|
||||
|
|
|
|||
|
|
@ -352,6 +352,12 @@ func (r *applyBatchRun) applyDepAdd(ctx context.Context, tx *sql.Tx, index int,
|
|||
// bound to. The planner catches only the syntactically identical pair.
|
||||
return itemErr(fmt.Errorf("%w: %s", publicops.ErrSelfDependency, source))
|
||||
}
|
||||
// The dotted-id hierarchy rule DependencyEditor applies, on the RESOLVED
|
||||
// ids: a key can name a row whose minted id is a dotted child, so the planner
|
||||
// cannot decide this before the creates ran.
|
||||
if err := publicops.CheckDottedChildDependency(source, target, item.Type); err != nil {
|
||||
return itemErr(err)
|
||||
}
|
||||
// THE CROSS-PLANE REFUSAL IS ABOUT ROWS THIS REQUEST CREATED, and only
|
||||
// those. The two planes hold their edges in different tables, so an edge
|
||||
// between a durable row and a wisp the same batch minted is one the batch
|
||||
|
|
|
|||
|
|
@ -21,6 +21,12 @@ import (
|
|||
// self-edge otherwise trips the cycle check and reports the wrong refusal, and
|
||||
// SkipPerEdgeCycleCheck would skip it entirely.
|
||||
//
|
||||
// The dotted-id hierarchy rule (publicops.CheckDottedChildDependency) is here
|
||||
// for the same reason: it is decided from the request alone, and putting it in
|
||||
// the shared validator is what makes every leg — dolt, embedded, the unit of
|
||||
// work and the server behind httpapi — refuse a child gated on its own dotted
|
||||
// parent, not only the CLI that used to check it before calling the role.
|
||||
//
|
||||
// The type check is that there IS a type — non-empty, within the column's
|
||||
// length. It is deliberately not a membership test: the vocabulary is an open,
|
||||
// workspace-configurable set (see the Dep* constants), so refusing an unlisted
|
||||
|
|
@ -43,6 +49,9 @@ func ValidateAddDependenciesRequest(request publicops.AddDependenciesRequest) er
|
|||
if edge.IssueID == edge.DependsOnID {
|
||||
return fmt.Errorf("%w: %s cannot depend on itself", domain.ErrSelfDependency, edge.IssueID)
|
||||
}
|
||||
if err := publicops.CheckDottedChildDependency(edge.IssueID, edge.DependsOnID, edge.Type); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -461,6 +461,9 @@ func (r *uowApplyRun) applyDepAdd(ctx context.Context, index int, item *publicop
|
|||
if source == target {
|
||||
return itemErr(fmt.Errorf("%w: %s", publicops.ErrSelfDependency, source))
|
||||
}
|
||||
if err := publicops.CheckDottedChildDependency(source, target, item.Type); err != nil {
|
||||
return itemErr(err)
|
||||
}
|
||||
sourceWisp, sourceMine := r.planes[source]
|
||||
targetWisp, targetMine := r.planes[target]
|
||||
if sourceMine && targetMine && sourceWisp != targetWisp {
|
||||
|
|
|
|||
|
|
@ -166,6 +166,9 @@ func TestBatchApplyContract(t *testing.T) {
|
|||
t.Run("CloseItemsAnswerToTheCloseGuards", func(t *testing.T) {
|
||||
conformance.RunBatchApplyCloseItemsAnswerToTheCloseGuards(t, ctx, fixture)
|
||||
})
|
||||
t.Run("RefusesADottedChildGatedOnItsOwnParent", func(t *testing.T) {
|
||||
conformance.RunBatchApplyRefusesADottedChildGatedOnItsOwnParent(t, ctx, fixture)
|
||||
})
|
||||
}
|
||||
|
||||
func newUOWBatchApplyFixture(t *testing.T, ctx context.Context, prefix string) conformance.BatchApplyFixture {
|
||||
|
|
|
|||
|
|
@ -66,6 +66,7 @@ func TestUOWDependencyEditorContract(t *testing.T) {
|
|||
{name: "AcceptsADiamond", run: conformance.RunDependencyEditorAcceptsADiamond},
|
||||
{name: "GateScopeFollowsTheEdgeType", run: conformance.RunDependencyEditorGateScopeFollowsTheEdgeType},
|
||||
{name: "AcceptsBlockingAcrossIssueTypes", run: conformance.RunDependencyEditorAcceptsBlockingAcrossIssueTypes},
|
||||
{name: "RefusesADottedChildGatedOnItsOwnParent", run: conformance.RunDependencyEditorRefusesADottedChildGatedOnItsOwnParent},
|
||||
} {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
test.run(t, ctx, fixture)
|
||||
|
|
|
|||
|
|
@ -2,6 +2,8 @@ package issueops
|
|||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/steveyegge/beads/internal/types"
|
||||
)
|
||||
|
|
@ -147,12 +149,20 @@ type RemoveDependencyResult struct {
|
|||
type DependencyEditor interface {
|
||||
// AddDependencies asserts every edge in the request as ONE durable act:
|
||||
// one transaction, one history entry. Any refused edge refuses the whole
|
||||
// request and writes nothing — a self-dependency (ErrSelfDependency), a
|
||||
// scheduling cycle (ErrDependencyCycle), a conflicting type on a pair that
|
||||
// already has an edge (*DependencyTypeConflictError), a blocking edge that
|
||||
// would gate an issue on its own ancestor or descendant
|
||||
// (*DependencyHierarchyConflictError), or a SOURCE that does not exist
|
||||
// (ErrDependencySourceNotFound).
|
||||
// request and writes nothing — a self-dependency (ErrSelfDependency), an
|
||||
// explicit edge from a dotted-id child to its own ancestor
|
||||
// (*DottedChildDependencyError), a scheduling cycle (ErrDependencyCycle),
|
||||
// a conflicting type on a pair that already has an edge
|
||||
// (*DependencyTypeConflictError), a blocking edge that would gate an issue
|
||||
// on its own ancestor or descendant (*DependencyHierarchyConflictError),
|
||||
// or a SOURCE that does not exist (ErrDependencySourceNotFound).
|
||||
//
|
||||
// The dotted-child refusal is decided from the request alone, before any
|
||||
// read, so it takes precedence over every refusal that reads stored rows:
|
||||
// a child whose parent-child edge to that parent is already stored (the
|
||||
// `bd create --parent` shape) is refused with *DottedChildDependencyError,
|
||||
// which matches ErrValidation, not with the hierarchy or type conflict the
|
||||
// stored edge would otherwise raise.
|
||||
//
|
||||
// A target's existence is checked only where the backend can see it. A
|
||||
// target may legitimately be an "external:" reference or an issue in
|
||||
|
|
@ -188,3 +198,72 @@ type DependencyEditor interface {
|
|||
// missing edge is Removed false with a nil error, not ErrNotFound.
|
||||
RemoveDependency(ctx context.Context, req RemoveDependencyRequest) (RemoveDependencyResult, error)
|
||||
}
|
||||
|
||||
// DottedChildDependencyError refuses an explicit edge from a dotted-id child to
|
||||
// its own ancestor. The id already says "bd-abc.1 is under bd-abc": a child
|
||||
// inherits its parent's completion through the hierarchy, so a blocking (or any
|
||||
// other) explicit edge back up the tree either duplicates that structure or, for
|
||||
// a blocking type, deadlocks it — the parent cannot close before the child, and
|
||||
// the child would wait on the parent.
|
||||
//
|
||||
// The one edge it allows is the hierarchy itself: a parent-child edge to the
|
||||
// IMMEDIATE dotted parent. A parent-child edge to a higher ancestor is refused
|
||||
// too, because it would contradict the parent the id names.
|
||||
//
|
||||
// It unwraps to ErrValidation: the refusal is decidable from the two ids and
|
||||
// the type alone, with no read, so it is a property of the request.
|
||||
//
|
||||
// The message is the sentence `bd dep add` already printed, kept verbatim, so
|
||||
// it says "deadlock" whatever the type; Type is carried for callers that
|
||||
// inspect the refusal and is not rendered.
|
||||
type DottedChildDependencyError struct {
|
||||
IssueID string
|
||||
DependsOnID string
|
||||
Type DependencyType
|
||||
}
|
||||
|
||||
func (e *DottedChildDependencyError) Error() string {
|
||||
return fmt.Sprintf("cannot add dependency: %s is already a child of %s. Children inherit dependency on parent completion via hierarchy. Adding an explicit dependency would create a deadlock",
|
||||
e.IssueID, e.DependsOnID)
|
||||
}
|
||||
|
||||
// Unwrap classifies the refusal as request validation.
|
||||
func (e *DottedChildDependencyError) Unwrap() error { return ErrValidation }
|
||||
|
||||
// IsDottedChildDependency reports whether an edge from issueID to dependsOnID
|
||||
// of type depType is the dotted-id hierarchy conflict CheckDottedChildDependency
|
||||
// refuses. It is exported for callers that phrase the refusal themselves (a
|
||||
// bulk report naming the offending line); every role enforces it through
|
||||
// CheckDottedChildDependency.
|
||||
func IsDottedChildDependency(issueID, dependsOnID string, depType DependencyType) bool {
|
||||
_, immediateParent, depth := types.ParseHierarchicalID(issueID)
|
||||
if depth == 0 || dependsOnID == "" {
|
||||
return false
|
||||
}
|
||||
if dependsOnID != immediateParent && !strings.HasPrefix(issueID, dependsOnID+".") {
|
||||
return false
|
||||
}
|
||||
return depType != DepParentChild || dependsOnID != immediateParent
|
||||
}
|
||||
|
||||
// CheckDottedChildDependency is the ONE enforcement of the dotted-id hierarchy
|
||||
// rule. Every DependencyEditor implementation applies it to each requested edge
|
||||
// and every BatchApplier applies it to each dep_add item once its refs resolve,
|
||||
// so `bd dep add`, an HTTP dependencies:add, and a batch apply (including
|
||||
// `bd create --graph`'s own edges) refuse the same edge the same way. Two CLI
|
||||
// paths that write an edge through a store verb instead of a role call it
|
||||
// themselves: `bd link` and `bd batch`'s `dep add`.
|
||||
//
|
||||
// Other edge writers do not apply it yet, so they can still store an edge the
|
||||
// roles refuse. The known ones are `bd relate`; the edges a create writes with
|
||||
// its issue (`bd create --deps`/`--waits-for`, and Lifecycle.Create's ParentID,
|
||||
// Dependencies and WaitsFor); `bd duplicate`, `bd supersede` and
|
||||
// `bd duplicates --auto-merge`'s link and reparenting; and the tracker engine's
|
||||
// createDependencies. The molecule, template and swarm writers have not been
|
||||
// audited against it. bd-25s1wh tracks the gap.
|
||||
func CheckDottedChildDependency(issueID, dependsOnID string, depType DependencyType) error {
|
||||
if IsDottedChildDependency(issueID, dependsOnID, depType) {
|
||||
return &DottedChildDependencyError{IssueID: issueID, DependsOnID: dependsOnID, Type: depType}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -340,3 +340,58 @@ func (operationsProbe) Close(context.Context, issueops.CloseRequest) (issueops.C
|
|||
func (operationsProbe) Reopen(context.Context, issueops.ReopenRequest) (issueops.ReopenResult, error) {
|
||||
return issueops.ReopenResult{}, nil
|
||||
}
|
||||
|
||||
// TestCheckDottedChildDependency pins the dotted-id hierarchy rule every
|
||||
// DependencyEditor and BatchApplier enforces. It absorbs the CLI's former
|
||||
// isChildOf / isDisallowedHierarchicalDependency tables.
|
||||
func TestCheckDottedChildDependency(t *testing.T) {
|
||||
for _, tt := range []struct {
|
||||
name string
|
||||
from string
|
||||
to string
|
||||
depType issueops.DependencyType
|
||||
want bool
|
||||
}{
|
||||
{"direct child blocks on parent", "bd-abc.1", "bd-abc", issueops.DepBlocks, true},
|
||||
{"grandchild blocks on grandparent", "bd-abc.1.2", "bd-abc", issueops.DepBlocks, true},
|
||||
{"grandchild blocks on immediate parent", "bd-abc.1.2", "bd-abc.1", issueops.DepBlocks, true},
|
||||
{"deeply nested child blocks on root", "bd-abc.1.2.3", "bd-abc", issueops.DepBlocks, true},
|
||||
{"child relates to parent", "bd-abc.1", "bd-abc", issueops.DepRelated, true},
|
||||
{"grandchild parent-child to grandparent", "bd-root.1.2", "bd-root", issueops.DepParentChild, true},
|
||||
{"immediate parent-child allowed", "bd-root.1.2", "bd-root.1", issueops.DepParentChild, false},
|
||||
{"same id", "bd-abc", "bd-abc", issueops.DepBlocks, false},
|
||||
{"unrelated ids", "bd-xyz", "bd-abc", issueops.DepBlocks, false},
|
||||
{"unrelated target from a dotted child", "bd-root.1.2", "bd-other", issueops.DepBlocks, false},
|
||||
{"sibling", "bd-abc.2", "bd-abc.1", issueops.DepBlocks, false},
|
||||
{"parent on its child", "bd-abc", "bd-abc.1", issueops.DepBlocks, false},
|
||||
{"prefix but not hierarchical", "bd-abcd", "bd-abc", issueops.DepBlocks, false},
|
||||
{"textual prefix of a dotted id is not an ancestor", "bd-abc.10", "bd-abc.1", issueops.DepBlocks, false},
|
||||
{"external target", "bd-abc.1", "external:bd-abc", issueops.DepBlocks, false},
|
||||
} {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if got := issueops.IsDottedChildDependency(tt.from, tt.to, tt.depType); got != tt.want {
|
||||
t.Fatalf("IsDottedChildDependency(%q, %q, %q) = %v, want %v", tt.from, tt.to, tt.depType, got, tt.want)
|
||||
}
|
||||
err := issueops.CheckDottedChildDependency(tt.from, tt.to, tt.depType)
|
||||
if !tt.want {
|
||||
if err != nil {
|
||||
t.Fatalf("CheckDottedChildDependency = %v, want nil", err)
|
||||
}
|
||||
return
|
||||
}
|
||||
var dotted *issueops.DottedChildDependencyError
|
||||
if !errors.As(err, &dotted) || !errors.Is(err, issueops.ErrValidation) {
|
||||
t.Fatalf("CheckDottedChildDependency = %v, want *DottedChildDependencyError matching ErrValidation", err)
|
||||
}
|
||||
if dotted.IssueID != tt.from || dotted.DependsOnID != tt.to || dotted.Type != tt.depType {
|
||||
t.Fatalf("refusal = %#v, want the edge it refused", dotted)
|
||||
}
|
||||
// The CLI prints this sentence verbatim, so it is behaviour.
|
||||
want := "cannot add dependency: " + tt.from + " is already a child of " + tt.to +
|
||||
". Children inherit dependency on parent completion via hierarchy. Adding an explicit dependency would create a deadlock"
|
||||
if err.Error() != want {
|
||||
t.Fatalf("message = %q, want %q", err.Error(), want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue