beads/backend/http/e2e_gates_test.go
Julian Knutsen ae693ef7cc
fix(http): bd gate create, add-waiter and discover over a connected HTTP workspace (#7621)
* fix(http): gate create, add-waiter and discover through the library roles

bd gate create, bd gate add-waiter and bd gate discover wrote through the
legacy CreateIssue, AddDependency and map-based UpdateIssue, which the http
store does not implement, so over a connected HTTP workspace each failed
before any gate member reached the wire. They now run through the roles on
every route (direct, proxied server, http):

- gate create is ONE Lifecycle.Create carrying the gate members and a
  reverse blocks edge from the blocked issue to the new gate: atomic on
  every route, one createIssue over http behind issues.create.gates. The
  proxied-server route's private unit of work is gone; it uses the same
  role.
- gate add-waiter reads through Reader.Get, deduplicates, and writes the
  whole waiter list through Lifecycle.Update guarded by the row version it
  read, retrying up to three times on ErrVersionMismatch, so concurrent
  adders cannot lose each other's waiter. Over http: issues.update.gates.
- gate discover lists through issueops.ListGates and records the run ID
  through the same Lifecycle await_id patch gate check makes; bd close's
  gh:run persist (updateGateAwaitID) takes the same path.
- Against a server without the token, each refuses before any write,
  naming the token.
- gate discover skips template gates, as gate check already does, instead
  of recording a run ID on a proto every later pour copies.

Tests: unit tests for the one-Create shape, the refusal, the add-waiter CAS
retry, and discover over ListGates with its template skip;
backend/http TestE2E_GatesOverHTTP (advertised and masked); four served
corpus shapes, pending until the reference server advertises the gate
tokens (verified to pass against a profile that does). CHANGELOG.

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

* fix(gate): add-waiter backs off under contention; discover fails on a failed write

Review follow-ups to the gate CLI port.

- gate add-waiter's guarded write retried three times with no wait, so a
  convoy of workers registering on one gate at once failed all but a few
  (the proxied route's old unit of work had served them all). Each retry
  now waits a jittered, doubling backoff (10 ms to 400 ms, drawn from
  [d/2, d)), for at most 20 writes. The bound is attempts, not wall time:
  under a loaded server one round takes seconds, and a wall-clock budget
  failed the convoy after two or three rounds. A cancelled wait stops the
  loop. TestProxiedServerGateAddWaiterConvoy (direct SQL and
  proxied, real Dolt server) and TestE2E_GatesOverHTTP's concurrent case
  run 11 simultaneous adders (one duplicate): all exit 0, every waiter
  present once.
- gate discover counts only the gates whose run ID was recorded and exits
  non-zero when any matched gate's write failed; it used to print the
  refused gate as updated and exit 0. TestE2E_GatesOverHTTP covers
  discover with and without issues.update.gates (fake gh).
- TestServedGateCheckOverAwaitTypedGates masks issues.update.gates itself,
  so upgrading reference_server.json does not turn its gh:run case into a
  different test.
- The discover listing test asserts closed gates are not listed.
- CHANGELOG: discover's template skip and add-waiter's template refusal
  are behavior changes on the local routes; gate create refuses
  a negative --timeout; gate create/add-waiter follow dolt.auto-commit and
  use the role's commit messages; the proxied create no longer journals
  dependency_added.

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

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-17 02:15:07 +00:00

315 lines
12 KiB
Go

//go:build cgo
package bdhttp_test
import (
"encoding/json"
"fmt"
"net/http"
"os"
"path/filepath"
"slices"
"strings"
"sync"
"testing"
"time"
)
// gateTokens are the two behavior tokens the gate commands depend on:
// issues.create.gates for a create carrying gate members (bd gate create),
// issues.update.gates for an await_id or waiters patch (bd gate add-waiter,
// bd gate discover, gate check's gh:run persist, bd update --await-id).
var gateTokens = []string{"issues.create.gates", "issues.update.gates"}
// withoutGateTokens rewrites the handshake into a server that predates the
// gate members: the live capability list minus the two gate tokens.
func withoutGateTokens(body map[string]any) {
caps, _ := body["capabilities"].([]any)
kept := make([]any, 0, len(caps))
for _, c := range caps {
if s, _ := c.(string); slices.Contains(gateTokens, s) {
continue
}
kept = append(kept, c)
}
body["capabilities"] = kept
}
// gateShow is the subset of `bd show --json` the gate cases read.
type gateShow struct {
ID string `json:"id"`
Status string `json:"status"`
IssueType string `json:"issue_type"`
AwaitType string `json:"await_type"`
AwaitID string `json:"await_id"`
Timeout int64 `json:"timeout"`
Waiters []string `json:"waiters"`
}
func showGate(t *testing.T, f *remoteRolesFixture, id string) gateShow {
t.Helper()
out := strings.TrimSpace(f.mustRun(nil, "show", id, "--json").stdout)
var rows []gateShow
if err := json.Unmarshal([]byte(out), &rows); err != nil {
var one gateShow
if err1 := json.Unmarshal([]byte(out), &one); err1 != nil {
t.Fatalf("parse bd show --json: %v\n%s", err, out)
}
return one
}
if len(rows) == 0 {
t.Fatalf("bd show %s --json returned no row", id)
}
return rows[0]
}
func readyIDs(t *testing.T, f *remoteRolesFixture) map[string]bool {
t.Helper()
ids := map[string]bool{}
for _, row := range jsonRows(t, f.mustRun(nil, "ready", "--json", "--limit", "0").stdout) {
if id, ok := row["id"].(string); ok {
ids[id] = true
}
}
return ids
}
func writesOf(paths []string) []string {
var writes []string
for _, p := range paths {
if !strings.HasPrefix(p, http.MethodGet+" ") {
writes = append(writes, p)
}
}
return writes
}
// TestE2E_GatesOverHTTP runs the gate commands through the real `bd` binary
// against an in-process `bd serve`.
//
// Against a server that advertises the gate tokens:
// - `bd gate create` is ONE createIssue carrying the gate members and the
// blocks edge (timer, gh:run and bead gates), and the blocked issue
// leaves the ready set;
// - `bd gate check --type=timer` closes an expired timer gate and the
// blocked issue becomes ready;
// - `bd gate add-waiter` registers a waiter once (the repeat writes nothing);
// - `bd update --await-id` sets await_id.
//
// Against a server that does not advertise them, each command is refused
// before any write, naming the token it needs, and nothing changes.
func TestE2E_GatesOverHTTP(t *testing.T) {
skipUnlessEmbeddedDolt(t)
bin := buildBD(t)
addr := startE2EServer(t)
proxyAddr, counter := startCountingProxy(t, addr)
f := newHTTPFixture(t, bin, proxyAddr)
var waiterGate string
t.Run("advertised", func(t *testing.T) {
timerTarget := f.create("timer target")
counter.reset()
created := f.mustRun(nil, "gate", "create", "--type=timer", "--timeout=1ns", "--blocks", timerTarget, "--json")
if w := writesOf(counter.snapshot()); !slices.Equal(w, []string{"POST /v0/beads/issues"}) {
t.Errorf("gate create wrote %v, want exactly one createIssue", w)
}
timerGate := firstJSONField(t, created.stdout, "id")
if g := showGate(t, f, timerGate); g.IssueType != "gate" || g.AwaitType != "timer" || g.Timeout != 1 || g.Status != "open" {
t.Errorf("timer gate reads back %+v, want an open timer gate with a 1ns timeout", g)
}
if readyIDs(t, f)[timerTarget] {
t.Errorf("%s is ready while its gate is open", timerTarget)
}
time.Sleep(10 * time.Millisecond)
r := f.mustRun(nil, "gate", "check", "--type=timer", "--escalate")
if !strings.Contains(r.stdout, "1 resolved") {
t.Errorf("gate check --type=timer = %q, want one resolved gate", r.stdout)
}
if g := showGate(t, f, timerGate); g.Status != "closed" {
t.Errorf("expired timer gate %s is %s after gate check, want closed", timerGate, g.Status)
}
if !readyIDs(t, f)[timerTarget] {
t.Errorf("%s is not ready after its timer gate resolved", timerTarget)
}
runTarget := f.create("run target")
runGate := firstJSONField(t, f.mustRun(nil, "gate", "create", "--type=gh:run", "--await-id=ci-wf", "--repo=owner/repo", "--blocks", runTarget, "--json").stdout, "id")
if g := showGate(t, f, runGate); g.AwaitType != "gh:run" || g.AwaitID != "ci-wf" {
t.Errorf("gh:run gate reads back %+v, want await gh:run ci-wf", g)
}
awaited := f.create("awaited bead")
beadTarget := f.create("bead target")
beadGate := firstJSONField(t, f.mustRun(nil, "gate", "create", "--type=bead", "--await-id", awaited, "--blocks", beadTarget, "--json").stdout, "id")
if g := showGate(t, f, beadGate); g.AwaitType != "bead" || g.AwaitID != awaited {
t.Errorf("bead gate reads back %+v, want await bead %s", g, awaited)
}
waiterGate = beadGate
counter.reset()
r = f.mustRun(nil, "gate", "add-waiter", beadGate, "rig/workers/a")
if !strings.Contains(r.stdout, "Added waiter to gate "+beadGate+": rig/workers/a") {
t.Errorf("add-waiter output = %q", r.stdout)
}
if w := writesOf(counter.snapshot()); len(w) != 1 || !strings.HasPrefix(w[0], "PATCH /v0/beads/issues/") {
t.Errorf("add-waiter wrote %v, want one updateIssue", w)
}
counter.reset()
r = f.mustRun(nil, "gate", "add-waiter", beadGate, "rig/workers/a")
if !strings.Contains(r.stdout, "Waiter already registered on gate "+beadGate) {
t.Errorf("repeat add-waiter output = %q", r.stdout)
}
if w := writesOf(counter.snapshot()); len(w) != 0 {
t.Errorf("a repeat add-waiter wrote %v", w)
}
f.mustRun(nil, "gate", "add-waiter", beadGate, "rig/workers/b")
if g := showGate(t, f, beadGate); !slices.Equal(g.Waiters, []string{"rig/workers/a", "rig/workers/b"}) {
t.Errorf("waiters = %v, want [rig/workers/a rig/workers/b]", g.Waiters)
}
f.mustRun(nil, "update", runGate, "--await-id", "12345", "--json")
if g := showGate(t, f, runGate); g.AwaitID != "12345" {
t.Errorf("await_id after update --await-id = %q, want 12345", g.AwaitID)
}
})
// A convoy registering on one gate at once: every adder must exit 0 and
// every waiter must be on the gate. Each round of simultaneous guarded
// writes has one winner, so this pins the retry backoff, not just the
// compare-and-set.
t.Run("concurrent add-waiter", func(t *testing.T) {
const adders = 10
target := f.create("convoy target")
gate := firstJSONField(t, f.mustRun(nil, "gate", "create", "--blocks", target, "--json").stdout, "id")
results := make([]bdResult, adders+1)
var wg sync.WaitGroup
start := make(chan struct{})
for i := 0; i <= adders; i++ {
waiter := fmt.Sprintf("rig/workers/c%d", i%adders) // the last one repeats c0
wg.Add(1)
go func(i int) {
defer wg.Done()
<-start
results[i] = f.run(nil, "gate", "add-waiter", gate, waiter)
}(i)
}
close(start)
wg.Wait()
for i, r := range results {
if r.code != 0 {
t.Errorf("adder %d exited %d: %s", i, r.code, r.stderr)
}
}
got := showGate(t, f, gate).Waiters
slices.Sort(got)
var want []string
for i := 0; i < adders; i++ {
want = append(want, fmt.Sprintf("rig/workers/c%d", i))
}
slices.Sort(want)
if !slices.Equal(got, want) {
t.Errorf("waiters after %d concurrent adders = %v, want each exactly once: %v", adders+1, got, want)
}
})
// gate discover over HTTP: a fake gh answers the run listing, and the
// discovered run ID is recorded through updateIssue (issues.update.gates).
binDir := t.TempDir()
gh := `#!/bin/sh
case "$1 $2" in
"run list") echo '[{"databaseId":4242,"name":"ci-wf","status":"in_progress","conclusion":"","createdAt":"'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'","workflowName":"ci-wf","headBranch":"main"}]' ;;
*) echo "unexpected gh $*" >&2; exit 3 ;;
esac
`
if err := os.WriteFile(filepath.Join(binDir, "gh"), []byte(gh), 0o755); err != nil {
t.Fatalf("write fake gh: %v", err)
}
ghEnv := []string{"PATH=" + binDir + string(os.PathListSeparator) + os.Getenv("PATH")}
t.Run("discover", func(t *testing.T) {
target := f.create("discover target")
gate := firstJSONField(t, f.mustRun(nil, "gate", "create", "--type=gh:run", "--await-id=ci-wf", "--blocks", target, "--json").stdout, "id")
counter.reset()
r := f.run(ghEnv, "gate", "discover")
if r.code != 0 {
t.Fatalf("gate discover exited %d: %s %s", r.code, r.stdout, r.stderr)
}
if !strings.Contains(r.stdout, "Updated 1 gate(s)") {
t.Errorf("gate discover output = %q, want one updated gate", r.stdout)
}
if w := writesOf(counter.snapshot()); len(w) != 1 || !strings.HasPrefix(w[0], "PATCH /v0/beads/issues/") {
t.Errorf("gate discover wrote %v, want one updateIssue", w)
}
if g := showGate(t, f, gate); g.AwaitID != "4242" {
t.Errorf("await_id after discover = %q, want 4242", g.AwaitID)
}
})
t.Run("refused without the tokens", func(t *testing.T) {
if waiterGate == "" {
t.Skip("the advertised case created no gate")
}
maskedAddr, maskedCounter := startMaskingProxy(t, addr, withoutGateTokens)
m := newHTTPFixture(t, bin, maskedAddr)
target := m.create("masked target")
before := showGate(t, f, waiterGate)
cases := []struct {
name string
args []string
token string
}{
{"gate create", []string{"gate", "create", "--type=timer", "--timeout=1h", "--blocks", target}, "issues.create.gates"},
{"gate create human", []string{"gate", "create", "--blocks", target}, "issues.create.gates"},
{"gate add-waiter", []string{"gate", "add-waiter", waiterGate, "rig/workers/c"}, "issues.update.gates"},
{"update --await-id", []string{"update", waiterGate, "--await-id", "999"}, "issues.update.gates"},
}
for _, tc := range cases {
maskedCounter.reset()
r := m.run(nil, tc.args...)
if r.code == 0 {
t.Errorf("%s against a server without %s exited 0: %s", tc.name, tc.token, r.stdout)
}
if !strings.Contains(r.stderr, tc.token) {
t.Errorf("%s refusal does not name %s: %s", tc.name, tc.token, r.stderr)
}
if w := writesOf(maskedCounter.snapshot()); len(w) != 0 {
t.Errorf("a refused %s wrote %v; the refusal must come before any write", tc.name, w)
}
}
// gate discover finds the run but cannot record it: the gate's error
// names the token, nothing is written, and the command fails rather
// than reporting the gate as updated.
runTarget := f.create("masked discover target")
runGate := firstJSONField(t, f.mustRun(nil, "gate", "create", "--type=gh:run", "--await-id=ci-wf", "--blocks", runTarget, "--json").stdout, "id")
maskedCounter.reset()
r := m.run(ghEnv, "gate", "discover")
if r.code == 0 {
t.Errorf("gate discover against a server without issues.update.gates exited 0: %s", r.stdout)
}
if !strings.Contains(r.stderr, "issues.update.gates") || !strings.Contains(r.stderr, runGate) {
t.Errorf("gate discover refusal does not name the gate and issues.update.gates: %s", r.stderr)
}
if strings.Contains(r.stdout, "Updated 1") {
t.Errorf("gate discover reported the refused gate as updated: %s", r.stdout)
}
if w := writesOf(maskedCounter.snapshot()); len(w) != 0 {
t.Errorf("a refused gate discover wrote %v", w)
}
if g := showGate(t, f, runGate); g.AwaitID != "ci-wf" {
t.Errorf("await_id after a refused discover = %q, want ci-wf untouched", g.AwaitID)
}
if !readyIDs(t, m)[target] {
t.Errorf("%s left the ready set though every gate create was refused", target)
}
after := showGate(t, f, waiterGate)
if after.AwaitID != before.AwaitID || !slices.Equal(after.Waiters, before.Waiters) {
t.Errorf("refused writes changed the gate: before %+v after %+v", before, after)
}
})
}