* fix(gate): resolve a bead gate whose awaited bead no longer exists (wy-dgfuiu) A gate with await_type=bead whose awaited bead has been purged could never resolve: GetIssue returns storage.ErrNotFound (or a wrapped sql.ErrNoRows) against real storage, checkBeadGate returned (false, "bead gate %q: %v"), the bead arm of evaluateGates never sets r.err, and applyGateCheckResults fell to the "pending" arm with exit 0. The gate stayed pending forever. Treat a missing bead as resolution, reusing the existing gateProxiedNotFound predicate so a genuine backend or transport failure still stays pending. close.go shares checkBeadGate and inherits the fix. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01MjQHZQoR8qZTaNj2QTZokr * fix(gate): resolve a deleted bead gate target only after a local sighting Review fixes for #6395 (adopt-pr iterations 1 to 5). The PR resolves a bead gate when its awaited bead no longer exists, but the lookups it relies on turned a routing failure into not-found: the direct getter (getIssueWithRouting) and the proxied getter both returned the local miss when a prefix-routed rig could not be read, so an OPEN bead in an unreachable rig resolved its gate and unblocked the step. An await_id that never named a real bead (a typo, a short ID) also resolved on the first check. - A miss outside this rig's own store is errBeadGateTargetUnconfirmed: a matched routes.jsonl route whose rig fails or does not return the bead, an unreadable routes.jsonl, or the contributor auto-routed store. The gate stays pending and the reason names the cause. inspectBeadGate tests it before not-found, because the wrapped routing error can itself be a not-found. Only this rig's own absence counts as gone. - bd gate check resolves a gone target only if an earlier check saw it in this rig. The first local sighting stamps await_seen=<await_id> in the gate's metadata (an OpSetMetadata merge, so other keys survive, and retargeting the gate invalidates it). A target that is gone and was never seen stays pending with "no earlier gate check saw it; check the await_id, or close the gate with bd gate resolve". A bead read through a route is never stamped, so a misdirected route cannot arm a later local miss. A failed stamp write is an error row, like a failed gh:run await_id persist. - The proxied getter reads the target with workapi.GetIssueOrWisp (the issue use case alone never returns a wisp), stamps inside the apply transaction, and never auto-routes. - bd close applies the same rule (evaluateBeadGate, recording no sighting): a gone bead satisfies the gate only if an earlier check saw it, so closing a gate on a typo'd await_id still needs --force. - bd close reads the awaited bead from the store that owns the gate (RoutedResult.Store), as bd gate check in that rig would. Read from the launcher's store, a routed gate whose awaited bead only its own rig can reach (no route for it from the launcher) saw that open bead as missing and, its sighting recorded, closed without --force. The proxied-server route keeps the fresh-read getter (#5861). - bd rename and bd rename-prefix (both the rename loop and --repair) point a bead gate at its bead's new ID, keeping a <rig>: prefix and carrying the sighting. UpdateIssueID rewrites text references but never await_id, so a seen bead's rename read as a deletion and resolved the gate on its next check. - UpdateIssueID also commits on its own, so a retarget written after it left a window, or after a failure a lasting state, where the gate held a sighting of an ID that no longer existed and resolved while its bead was open under the new ID. All three paths now rename through renameIssueKeepingBeadGates, which orders the writes so no state in between resolves a gate: it moves await_id to the new ID while the sighting still names the old one (dropping, in the same write, a sighting that already names the new ID), renames the bead, and then records the sighting under the new ID. A check in between finds a never-seen ID and stays pending. If moving a gate or renaming the bead fails, the gates are pointed back at the old ID without a sighting, since a failed write may still have landed, and the rename fails: bd rename exits non-zero instead of warning from its text-reference loop. Losing only the final sighting write is a warning; the next check records the sighting again. - A check lists the gate before it looks the bead up, so a rename landing in between left it holding a copy that still waited on the old ID with its sighting: the old ID was gone, and the check closed the gate while the bead was open under its new ID. Once the bead is found gone, evaluateBeadGate reads the gate back from its own store (rereadBeadGate) and resolves only if the stored gate still waits on the same await_id and still records the sighting. The rename moves the gate before the bead takes the new ID, so a read made after the miss sees the move. This covers bd gate check, its proxied route and bd close; a gate that cannot be read back, or is found only through a route, stays pending. - checkBeadGate, the target lookup without the sighting rule, had no production caller left and read like the bead-gate rule, which is how bd close came to skip the sighting. It moves into the tests; inspectBeadGate carries the lookup contract and points callers at evaluateBeadGate. - The gate check help, docs/workflows/gates.md and the CHANGELOG describe the rule, including that a rename does not read as a deletion to a check or bd close that read the gate before it, and that a rename that fails partway leaves the gate pending without a sighting; the #6404 entry no longer says a routed read failure reads as not-found. The CHANGELOG also warns that a rename by an older bd does not move the gate, so once a check has seen the bead, the next check or bd close after that rename closes the gate while the bead is still open: upgrade the clients that rename beads together with the ones that check gates. docs/cli-reference is pinned to v1.2.2, so it is unchanged (generate-cli-docs.sh --check passes). Tests: TestCheckBeadGate_UnconfirmedMissStaysPending, TestEvaluateGates_BeadGateSightingRule, TestEvaluateBeadGate_*, TestBeadGateSeenUpdate_KeepsOtherMetadata, TestBeadGateTargetSeen, TestProxiedFreshReadGetter_LocalMissFollowsRoutes, TestRoutedBeadGateGetter_ReportsWhereTheAnswerCameFrom, TestCheckGateSatisfaction_BeadGateNeedsASighting, TestCloseDirectPreflight_BeadGateReadsTheGatesOwnStore, TestCloseBeadGateGetter_RouteSelection, TestBeadGateRetargetUpdate, TestPlanBeadGateMoves, TestRenameIssueKeepingBeadGates and TestRenameIssueKeepingBeadGates_FailedWritesResolveNoGate, which fails each write of a rename in turn, landed or not, and evaluates every gate after each write, both as stored and as a concurrent check listed it before the rename (unit); the unreadable-rig step of TestCheckBeadGateCrossRigPrefixRoute, TestRepairPrefixesRetargetsBeadGates (gates renamed before and after their bead) and TestRenameFailureLeavesBeadGatesPending (bd rename, --repair and rename-prefix with a failing UpdateIssueID, landed or not) (cgo); TestEmbeddedGateCreate/check_bead_gate_resolves_only_a_missing_target_it_saw and /rename_keeps_a_bead_gate_on_its_target (embedded); TestProxiedServerGateCheck/bead_gate_resolves_when_seen_target_is_deleted and /bead_gate_never_seen_target_stays_pending (proxied). Reordering the unconfirmed case after not-found, dropping the sighting condition, swallowing the routed error, stamping routed sightings, or matching any stamp regardless of await_id each fails these tests, as do closing with the sighting-blind lookup, reading the launcher's store on close, dropping the carried sighting or the rig prefix on a retarget, dropping the retarget from bd rename, the rename-prefix loop or --repair, renaming the bead before moving its gates, keeping the sighting when moving a gate back, keeping a stale sighting of the new ID, skipping the final sighting write, resolving a gone bead without reading the gate back or from a gate read back that moved, lost its sighting or was found only through a route, or reporting an unconfirmed read-back as an error or an unreadable gate as pending. Agent-Signature: claude-code-claude-opus-5-5-max on behalf of Julian Knutsen Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com> Co-authored-by: Eddie the Engineer <adopt-pr@gascity.com>
93 lines
3.3 KiB
Go
93 lines
3.3 KiB
Go
//go:build cgo
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/steveyegge/beads/internal/types"
|
|
)
|
|
|
|
// TestCheckBeadGateCrossRigPrefixRoute proves the full evaluator seam: the
|
|
// historical rig:id value is reduced to the target bead ID, the current
|
|
// routes.jsonl prefix router opens the foreign store read-only, and target
|
|
// lifecycle state determines whether the gate resolves. A routed rig that
|
|
// cannot be read leaves the gate pending: its bead is not proven gone.
|
|
//
|
|
// NOTE: This test uses os.Chdir and cannot run in parallel with other tests.
|
|
func TestCheckBeadGateCrossRigPrefixRoute(t *testing.T) {
|
|
ctx := context.Background()
|
|
townRoot := t.TempDir()
|
|
townBeadsDir := filepath.Join(townRoot, ".beads")
|
|
rigBeadsDir := filepath.Join(townRoot, "rig", ".beads")
|
|
if err := os.MkdirAll(townBeadsDir, 0o755); err != nil {
|
|
t.Fatalf("create town beads dir: %v", err)
|
|
}
|
|
if err := os.MkdirAll(rigBeadsDir, 0o755); err != nil {
|
|
t.Fatalf("create rig beads dir: %v", err)
|
|
}
|
|
|
|
townDBPath := filepath.Join(townBeadsDir, "dolt")
|
|
townStore := newTestStoreIsolatedDB(t, townDBPath, "hq")
|
|
rigStore := newTestStoreIsolatedDB(t, filepath.Join(rigBeadsDir, "dolt"), "gt")
|
|
for _, issue := range []*types.Issue{
|
|
{ID: "gt-closed", Title: "Closed routed target", Status: types.StatusClosed, Priority: 2, IssueType: types.TypeTask},
|
|
{ID: "gt-open", Title: "Open routed target", Status: types.StatusOpen, Priority: 2, IssueType: types.TypeTask},
|
|
} {
|
|
if err := rigStore.CreateIssue(ctx, issue, "test"); err != nil {
|
|
t.Fatalf("create routed issue %s: %v", issue.ID, err)
|
|
}
|
|
}
|
|
if err := rigStore.Close(); err != nil {
|
|
t.Fatalf("close rig store: %v", err)
|
|
}
|
|
|
|
routesPath := filepath.Join(townBeadsDir, "routes.jsonl")
|
|
if err := os.WriteFile(routesPath, []byte(`{"prefix":"gt-","path":"rig"}`), 0o644); err != nil {
|
|
t.Fatalf("write routes.jsonl: %v", err)
|
|
}
|
|
|
|
oldDBPath := dbPath
|
|
dbPath = townDBPath
|
|
t.Cleanup(func() { dbPath = oldDBPath })
|
|
oldWD, err := os.Getwd()
|
|
if err != nil {
|
|
t.Fatalf("get working directory: %v", err)
|
|
}
|
|
if err := os.Chdir(townRoot); err != nil {
|
|
t.Fatalf("change to town root: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = os.Chdir(oldWD) })
|
|
|
|
getter := routedBeadGateGetter{localStore: townStore}
|
|
resolved, reason, _ := checkBeadGate(ctx, getter, "rig:gt-closed")
|
|
if !resolved {
|
|
t.Fatalf("closed cross-rig target did not resolve gate: %s", reason)
|
|
}
|
|
|
|
resolved, reason, _ = checkBeadGate(ctx, getter, "rig:gt-open")
|
|
if resolved {
|
|
t.Fatalf("open cross-rig target unexpectedly resolved gate: %s", reason)
|
|
}
|
|
if !gateTestContainsIgnoreCase(reason, "open") {
|
|
t.Fatalf("pending reason %q does not report target status", reason)
|
|
}
|
|
|
|
// Point the rig at a database that does not exist: the route still
|
|
// matches, but the rig's store cannot be opened, so its open bead must not
|
|
// read as deleted.
|
|
writeTestMetadata(t, filepath.Join(rigBeadsDir, "dolt"), "gate_routing_missing_db")
|
|
resolved, reason, err = checkBeadGate(ctx, getter, "rig:gt-open")
|
|
if err != nil {
|
|
t.Fatalf("an unreadable routed rig is a pending gate, not an error: %v", err)
|
|
}
|
|
if resolved {
|
|
t.Fatalf("open target in an unreadable routed rig resolved the gate: %s", reason)
|
|
}
|
|
if !gateTestContainsIgnoreCase(reason, "cannot confirm") {
|
|
t.Fatalf("pending reason %q does not say the absence is unconfirmed", reason)
|
|
}
|
|
}
|