* Publish POST /v0/beads/issues:claimNext: take ready work atomically (ga-g3gg8)
A client of this surface that wants the next piece of work composes
`GET /v0/beads/ready` with `POST /v0/beads/issues/{id}:claim`. That
composition is a RACE, and it is the reason this operation exists rather than
a round trip saved: between the listing that offered a row and the claim that
asked for it, another agent claims it — so the second agent earns a 409 for a
row it was correctly offered, and a fleet polling one queue spends its
requests losing races instead of doing work.
`claimNextIssue` publishes issueops.ReadyClaimer, where selection, the
compare-and-set that wins the row, and the hydration of the row that was won
are ONE transaction. The row cannot move between being chosen and being
reported.
THE FILTER IS THE LISTING'S, and not a copy of it. The parameters are decoded
by readyFilters — the same function `listReadyWork` and `countReadyWork` share
— because a claim that answered a different question than `bd ready` shows
would hand an agent work the listing never offered it, and two predicates that
are allowed to differ eventually do. The actor is the only body member: it is
provenance that lands in a column, and this surface has always carried that in
a body, while re-spelling the filter as a body object would create exactly the
second expression the shared decoder exists to prevent.
TestClaimNextAdmitsExactlyTheListingsFilters holds the DOCUMENT to the same
identity, since only the handler is protected by sharing the function.
`limit` is refused BY VALUE rather than left to the unknown-parameter rule,
and the distinction is two different client recoveries. `unknown_parameter`
means "this server does not know that name — version skew, degrade or fall
back", which would be false: it is a name this server knows perfectly well on
the sibling listing. It will not ACT on it, which is `invalid_value`, and the
reason is the role's: a claim delivers the one row it wins however large the
pool it scanned, and the scan must stay unbounded or a window that happens to
be full of rows a racing agent already took reports nothing to claim.
`sort` IS published, unlike on `ready:count`, because order decides WHICH row
a claim writes to where it cannot change a cardinality — and it is sent
explicitly for handleReady's reason, which bites harder here: an empty policy
adopts storage's hybrid fallback, and here that changes the row that gets
written rather than the order rows are printed in.
NOTHING ELIGIBLE IS A 200 WITH `claimed` ABSENT. An empty ready front is the
steady state of a drained queue, not a failure, and a polling agent that had
to classify an error to discover it would be pattern-matching prose. There is
no boolean beside the member and no scan count: a second member carrying the
same fact is a second member that can disagree with the first. This is the one
place the operation differs from `issues/{id}:claim`, which 404s an id that
names nothing — that one was asked about a ROW, and this one was asked a
question whose honest answer can be "none".
It documents no 409 and no 404 at all, and both absences are contract. There
is no id to have missed, and a row a racing agent took is simply not in the
set this claim scanned.
The real-Dolt leg asserts the guarantee a fake cannot express: nine concurrent
claimants against six ready rows win six distinct rows and never the same one
twice. The assertion is on duplicates rather than on timing, so it is
deterministic however the goroutines interleave.
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
* Publish patch.add_labels and patch.remove_labels on updateIssue (ga-g3gg8)
The bead asked for "incremental label add/remove on the wire", noting that
labels are replace-only and that issueops.LabelPatch has Add and Remove. The
trace found the situation is narrower than that and more familiar: the role's
whole algebra IS already wire-expressible — as `labels.{replace,add,remove}`
on `issues:batchApply`'s update item, which has published `ApplyLabelPatch`
since it landed. What has no incremental spelling is `PATCH /v0/beads/issues/{id}`,
whose `patch.labels` is a bare array.
That is #5484's finding again, on the one member it did not close: two
operations for patching one issue, disagreeing about what patching one issue
means. This closes the gap from the same side, and this member is the last of
them.
`patch.labels` KEEPS ITS SHAPE, and that is a constraint rather than a
preference. Nesting it into an object the way `ApplyPatchBody` does would
RE-TYPE a published member, which is the one kind of change this document has
no additive route for — `## Profiles` names re-typing explicitly as not a
tightening, and the only remedies written down are a new optional member or
cutting /v1. So the increments arrive as two flat siblings, which is the shape
`notes` and `append_notes` already use for the same replace/increment pair on
this exact schema.
THEY ARE NOT MUTUALLY EXCLUSIVE WITH `labels`, and that is the difference from
that pair. The role defines an ORDER over all three — replace, then add, then
remove, so removal wins — so a request carrying all three has a defined result
and must reach the role whole. Notes have no such algebra, so there the two
members are a contradiction and are refused. The handler assembles one
LabelPatch in one loop for exactly this reason: a member decoded into its own
patch value would overwrite the others' fields and the last one decoded would
silently win.
The retired premise is worth stating, because it was written down and it was
half right. `patch.labels` said incremental edits were deferred because
"replacement is the only shape whose result the client already knows without a
read-back". That holds for a writer that knows it is alone and fails for every
other one: two agents each adding a tag to one row, each composing a
replacement from a read taken before the other wrote, silently drop each
other's label. `bd label add` and every agent that tags work concurrently are
that caller. The real-Dolt leg is written as exactly that scenario.
The length bound applies to all three members including `remove_labels`, where
a value the column could not hold could never have been stored: it is a rule
about what a label may BE, and the role refuses it there too and writes
nothing, so the edge refuses it where the 400 can name the member and the
index.
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
* Publish POST /v0/beads/issues:batchClose: close many, keep the survivors (ga-g3gg8)
`bd close a b c` is one transaction and one history entry. Over this surface it
has been N calls to `POST /v0/beads/issues/{id}:close`, which is N transactions
and N history entries, with no way for a caller to say it wanted them together.
The request is the transaction boundary, which is the whole reason
issueops.BatchCloser is a role rather than a loop.
IT IS THE ONE OPERATION HERE WHOSE 200 CARRIES REFUSALS, and that shape is the
ROLE's rather than an arrangement of it. An id the batch turns down is skipped
and the survivors commit, because an agent that finishes four of five steps and
mistypes the fifth should keep the four — so a per-item refusal is a RESULT of
the batch, not an error of it. `batchCreateIssues` is the deliberate opposite
and has said so in its own document since it landed: half a created plan cannot
be re-sent without duplicating the half that landed.
The division that falls out is the contract a client codes against, and it is
stated on both sides: a NON-2xx means the batch NEVER RAN, and a per-item
`code` means that item did not land while others may have.
`code` ON AN OUTCOME IS `Problem.code`'s VOCABULARY, restricted to `not_found`
and `not_closable`. A second vocabulary was the alternative and it was refused:
an item refusal and a request refusal are the same question asked at two
scopes, so a client made to learn two spellings would be classifying the SCOPE
rather than the condition. `open_children` keeps both of its readings, and both
are the single close's: present-and-a-count on a success (the number a forced
close bypassed, reported even for an idempotent re-close), and PRESENCE as the
discriminator between the two `not_closable` refusals on a failure, exactly as
on a problem document.
The projection fails CLOSED. An item error no arm recognizes becomes a refusal
carrying the generic code, never a success — because a success with no row is a
shape a client cannot tell from a real close, and a `default` that fell through
would produce exactly that.
NO COMPOSED CLAIM, and the omission is reasoned rather than partial. The role
can claim the next ready issue in the same transaction once the closes land;
publishing that member would need a second, BODY-shaped spelling of the ready
filter vocabulary that `GET /v0/beads/ready` and the `issues:claimNext` landing
beside this one both express as query parameters — and two spellings of one
predicate eventually disagree, which is the reason ReadyClaimer.Filter is the
listing's own request type. A client that wants both sends two requests and
loses the single transaction, which is a real loss and is named in the document
rather than papered over. It is additive later.
The per-item id is bounded HERE, which the single close gets from the
custom-method dispatcher and this operation has no dispatcher to get it from. It
is a 400 rather than a per-item `not_found`, because it is a statement about the
REQUEST and because reporting it as a miss would let a caller map this server's
notion of a well-formed id.
The real-Dolt leg asserts the claim the whole shape rests on: a batch whose
middle item names nothing still commits the two either side of it, each with its
OWN reason — read back through the CLI rather than off the response the batch
composed. A fake cannot state that, because it holds no rows to roll back.
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
* Scope the label members' no-op wording to the labels (ga-g3gg8)
`add_labels` and `remove_labels` each said a no-op edit "reports
`changed: false`". That is the RESPONSE's member and it describes the whole
patch, so it is only true of a request whose sole content was the no-op edit —
a request that also moved a title changed the row and reports true.
They now say what is true of the member: the edit changes no labels. The
response's reading is stated once beside it, as a fact about the patch.
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
* Fix two misspell findings inherited from the release merge (ga-lzcuv)
`main` is red on Lint as of 294af94be2, and both findings are prose from that
squash rather than from anything in this branch:
internal/httpapi/problem.go:85 `archaeology` -> misspell wants `archeology`
internal/httpapi/problem.go:591 `neighbour` -> misspell wants `neighbor`
`.golangci.yml` sets `misspell.locale: US`, so both are real under this
repository's configuration. They are fixed here because this branch merges next
and would otherwise carry a red Lint of its own making no changes to earn.
`neighbour` takes the US spelling. `archaeology` is REWORDED to `excavation`
rather than respelled: `archeology` is the spelling the linter wants and the
one most readers would read as a typo, and the sentence loses nothing by not
having the word in it. Rewording is the only one of the two options that leaves
the comment saying what it meant without looking wrong.
Neither is reachable from the local pre-commit hook, which fails at
golangci-lint config load in this environment before it analyses a file.
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---------
Co-authored-by: Review Sim <ci@beads.test>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
270 lines
12 KiB
Go
270 lines
12 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/steveyegge/beads/internal/types"
|
|
"github.com/steveyegge/beads/issueops"
|
|
)
|
|
|
|
// These are pure: the claimNext path runs end to end over a real listener
|
|
// against a fake ROLE, so the wire edge — the filter decode, the `limit`
|
|
// refusal, the body vocabulary, the absent-row answer — is covered on every
|
|
// pull request.
|
|
//
|
|
// What a fake cannot prove is the ATOMICITY that is the operation's entire
|
|
// reason for existing, and it is owned where it can be: the role-level contract
|
|
// against a real store (backend/conformance/ready_claimer_contract.go, run by
|
|
// internal/storage/uow). This slice cites that rather than pretending a fake
|
|
// can race itself.
|
|
|
|
const claimNextPath = "/v0/beads/issues:claimNext"
|
|
|
|
func (ts *testServer) claimNext(t *testing.T, path, body string) *http.Response {
|
|
t.Helper()
|
|
return ts.postBody(t, path, "application/json", body)
|
|
}
|
|
|
|
func newClaimNextServer(t *testing.T, claimer *roleReadyClaimer) *testServer {
|
|
t.Helper()
|
|
return newTestServer(t, rolesConfig(Config{ReadyClaimer: claimer}))
|
|
}
|
|
|
|
func readyRow(id string) *issueops.IssueWithCounts {
|
|
return &issueops.IssueWithCounts{Issue: seededIssue(id, "poller", types.StatusInProgress)}
|
|
}
|
|
|
|
// TestClaimNextAnswersWithTheRowItWon is the happy path: the role receives the
|
|
// actor, and the response carries the hydrated row under `claimed`.
|
|
func TestClaimNextAnswersWithTheRowItWon(t *testing.T) {
|
|
claimer := &roleReadyClaimer{result: issueops.ClaimNextResult{Claimed: readyRow("bd-1")}}
|
|
ts := newClaimNextServer(t, claimer)
|
|
|
|
resp := ts.claimNext(t, claimNextPath, `{"actor":"poller"}`)
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200: %s", resp.StatusCode, readAll(t, resp))
|
|
}
|
|
got := claimer.claimNextRequests()
|
|
if len(got) != 1 || got[0].Actor != "poller" {
|
|
t.Fatalf("the role received %+v, want exactly one claim by poller", got)
|
|
}
|
|
body := decodeBody(t, resp)
|
|
claimed, ok := body["claimed"].(map[string]any)
|
|
if !ok {
|
|
t.Fatalf("claimed = %#v, want an object", body["claimed"])
|
|
}
|
|
if claimed["id"] != "bd-1" {
|
|
t.Errorf("claimed.id = %v, want bd-1", claimed["id"])
|
|
}
|
|
}
|
|
|
|
// TestClaimNextAnswersAbsenceForADrainedQueue is the operation's other normal
|
|
// answer, and the one a polling client is written against.
|
|
//
|
|
// A drained queue is the STEADY STATE of a work loop, not a failure, so it is a
|
|
// 200 with the member absent rather than a 404 or a 409. `claimIssue` 404s an
|
|
// id that names nothing because it was asked about a ROW; this one was asked a
|
|
// question whose honest answer can be "none".
|
|
func TestClaimNextAnswersAbsenceForADrainedQueue(t *testing.T) {
|
|
claimer := &roleReadyClaimer{result: issueops.ClaimNextResult{Claimed: nil}}
|
|
ts := newClaimNextServer(t, claimer)
|
|
|
|
resp := ts.claimNext(t, claimNextPath, `{"actor":"poller"}`)
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200 for an empty ready front: %s", resp.StatusCode, readAll(t, resp))
|
|
}
|
|
body := decodeBody(t, resp)
|
|
if _, present := body["claimed"]; present {
|
|
t.Errorf("claimed = %#v; absence is the whole signal and a null is a second spelling of it", body["claimed"])
|
|
}
|
|
// And nothing else is invented beside it. A boolean or a scan count would
|
|
// be a second member carrying the same fact, which is a second member that
|
|
// can disagree with the first.
|
|
if len(body) != 0 {
|
|
t.Errorf("the empty answer carries %v; `claimed` is the only member this response has", body)
|
|
}
|
|
}
|
|
|
|
// TestClaimNextForwardsTheListingsFilters is the guarantee the shared decoder
|
|
// exists for, driven through a real request: every filter the ready listing
|
|
// admits reaches the role, spelled the same way.
|
|
func TestClaimNextForwardsTheListingsFilters(t *testing.T) {
|
|
claimer := &roleReadyClaimer{result: issueops.ClaimNextResult{Claimed: readyRow("bd-1")}}
|
|
ts := newClaimNextServer(t, claimer)
|
|
|
|
query := "?assignee=alice&unassigned=true&type=task&exclude_type=gate" +
|
|
"&label=urgent&label_any=a&exclude_label=wip&label_pattern=re*&label_regex=^re" +
|
|
"&priority=1&parent=bd-9&metadata_field=k%3Dv&has_metadata_key=owner" +
|
|
"&include_ephemeral=true&include_deferred=true&sort=oldest"
|
|
resp := ts.claimNext(t, claimNextPath+query, `{"actor":"poller"}`)
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200: %s", resp.StatusCode, readAll(t, resp))
|
|
}
|
|
got := claimer.claimNextRequests()
|
|
if len(got) != 1 {
|
|
t.Fatalf("the role received %+v, want exactly one request", got)
|
|
}
|
|
f := got[0].Filter
|
|
switch {
|
|
case f.Assignee != "alice", !f.Unassigned, f.IssueType != "task":
|
|
t.Errorf("the identity filters did not reach the role: %+v", f)
|
|
case len(f.ExcludeTypes) != 1, len(f.Labels) != 1, len(f.LabelsAny) != 1, len(f.ExcludeLabels) != 1:
|
|
t.Errorf("the list filters did not reach the role: %+v", f)
|
|
case f.LabelPattern != "re*", f.LabelRegex != "^re":
|
|
t.Errorf("the label matchers did not reach the role: %+v", f)
|
|
case f.Priority == nil || *f.Priority != 1, f.ParentID != "bd-9":
|
|
t.Errorf("the graph filters did not reach the role: %+v", f)
|
|
case f.MetadataFields["k"] != "v", f.HasMetadataKey != "owner":
|
|
t.Errorf("the metadata filters did not reach the role: %+v", f)
|
|
case !f.IncludeEphemeral, !f.IncludeDeferred:
|
|
t.Errorf("the plane filters did not reach the role: %+v", f)
|
|
case f.Sort != "oldest":
|
|
t.Errorf("Sort = %q, want oldest", f.Sort)
|
|
}
|
|
// The role refuses both, and this operation publishes no spelling for
|
|
// either, so the request it builds must never carry one.
|
|
if f.Limit != nil || f.Offset != 0 {
|
|
t.Errorf("the handler sent a page to a role that refuses one: limit=%v offset=%d", f.Limit, f.Offset)
|
|
}
|
|
}
|
|
|
|
// TestClaimNextSendsAnExplicitSortPolicy pins the value rather than the
|
|
// constant, for the reason handleReady's own test gives: an assertion against
|
|
// the value the handler read would hold for whatever value it took.
|
|
//
|
|
// It matters more here than on the listing. There, the sort decides what order
|
|
// rows are PRINTED in; here it decides which row the operation WRITES to.
|
|
func TestClaimNextSendsAnExplicitSortPolicy(t *testing.T) {
|
|
claimer := &roleReadyClaimer{result: issueops.ClaimNextResult{Claimed: readyRow("bd-1")}}
|
|
ts := newClaimNextServer(t, claimer)
|
|
|
|
if resp := ts.claimNext(t, claimNextPath, `{"actor":"poller"}`); resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200: %s", resp.StatusCode, readAll(t, resp))
|
|
}
|
|
got := claimer.claimNextRequests()
|
|
if len(got) != 1 || got[0].Filter.Sort != "priority" {
|
|
t.Fatalf("Sort = %q, want the document's default sent explicitly; an empty policy adopts storage's hybrid fallback",
|
|
got[0].Filter.Sort)
|
|
}
|
|
}
|
|
|
|
// TestClaimNextRefusesALimitByValue is the one parameter this operation turns
|
|
// down that its sibling accepts, and the refusal's REASON is the assertion.
|
|
//
|
|
// `unknown_parameter` would tell a client "this server does not know that name
|
|
// — version skew, degrade or fall back", which is false: the name is one this
|
|
// server knows perfectly well on the listing. `invalid_value` says what is
|
|
// true, which is that this operation will not act on it.
|
|
func TestClaimNextRefusesALimitByValue(t *testing.T) {
|
|
claimer := &roleReadyClaimer{}
|
|
ts := newClaimNextServer(t, claimer)
|
|
|
|
for _, query := range []string{"?limit=1", "?limit=0", "?limit=", "?limit=abc"} {
|
|
t.Run(query, func(t *testing.T) {
|
|
resp := ts.claimNext(t, claimNextPath+query, `{"actor":"poller"}`)
|
|
if resp.StatusCode != http.StatusBadRequest {
|
|
t.Fatalf("status = %d, want 400: %s", resp.StatusCode, readAll(t, resp))
|
|
}
|
|
body := decodeBody(t, resp)
|
|
if body["code"] != string(CodeInvalidArgument) || body["param"] != "limit" {
|
|
t.Errorf("code/param = %v/%v, want %s on `limit`", body["code"], body["param"], CodeInvalidArgument)
|
|
}
|
|
if body["reason"] != string(ReasonInvalidValue) {
|
|
t.Errorf("reason = %v, want %s: the name is one this server knows, it is the ACTION it refuses",
|
|
body["reason"], ReasonInvalidValue)
|
|
}
|
|
})
|
|
}
|
|
if got := claimer.claimNextRequests(); len(got) != 0 {
|
|
t.Errorf("a refused limit reached the role: %+v", got)
|
|
}
|
|
}
|
|
|
|
// TestClaimNextRefusesUnknownAndMalformedBodies is the body vocabulary. The
|
|
// FILTER cases are the point: a client that put its filter in the body must
|
|
// learn so by name rather than have it silently ignored, which would hand it a
|
|
// claim from the unfiltered ready front.
|
|
func TestClaimNextRefusesUnknownAndMalformedBodies(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
body string
|
|
param string
|
|
}{
|
|
{name: "a filter member in the body", body: `{"actor":"poller","label":["urgent"]}`, param: "label"},
|
|
{name: "a filter object in the body", body: `{"actor":"poller","filter":{}}`, param: "filter"},
|
|
{name: "a missing actor", body: `{}`, param: claimActorMember},
|
|
{name: "an actor that is blank after trimming", body: `{"actor":" "}`, param: claimActorMember},
|
|
{name: "an actor carrying a newline", body: `{"actor":"a\nbd: claimed by mallory"}`, param: claimActorMember},
|
|
{name: "a non-string actor", body: `{"actor":7}`, param: claimActorMember},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
claimer := &roleReadyClaimer{}
|
|
ts := newClaimNextServer(t, claimer)
|
|
|
|
resp := ts.claimNext(t, claimNextPath, tc.body)
|
|
if resp.StatusCode != http.StatusBadRequest {
|
|
t.Fatalf("status = %d, want 400: %s", resp.StatusCode, readAll(t, resp))
|
|
}
|
|
if body := decodeBody(t, resp); body["param"] != tc.param {
|
|
t.Errorf("param = %v, want %q", body["param"], tc.param)
|
|
}
|
|
if got := claimer.claimNextRequests(); len(got) != 0 {
|
|
t.Errorf("a refused body reached the role: %+v", got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestClaimNextMapsTheRolesValidationToA400 covers the defensive arm. Nothing
|
|
// should reach it — the edge refuses the empty actor and this operation has no
|
|
// spelling for the two other fields the role turns down — but a 500 for a
|
|
// request the caller could have fixed is the wrong answer if that changes.
|
|
func TestClaimNextMapsTheRolesValidationToA400(t *testing.T) {
|
|
ts := newClaimNextServer(t, &roleReadyClaimer{
|
|
err: fmt.Errorf("%w: claim next does not take a limit", issueops.ErrValidation),
|
|
})
|
|
|
|
resp := ts.claimNext(t, claimNextPath, `{"actor":"poller"}`)
|
|
if resp.StatusCode != http.StatusBadRequest {
|
|
t.Fatalf("status = %d, want 400: %s", resp.StatusCode, readAll(t, resp))
|
|
}
|
|
if body := decodeBody(t, resp); body["code"] != string(CodeInvalidArgument) {
|
|
t.Errorf("code = %v, want %s", body["code"], CodeInvalidArgument)
|
|
}
|
|
}
|
|
|
|
// TestClaimNextHasNoConflictAndNoNotFound states the operation's negative space
|
|
// as a test. A row a racing agent took is not in the set this claim scanned, so
|
|
// there is nothing to 409 about; there is no id in the path, so there is
|
|
// nothing to 404 about. Both absences are what a client dispatches on.
|
|
func TestClaimNextHasNoConflictAndNoNotFound(t *testing.T) {
|
|
for _, code := range operationCodes[OpClaimNextIssue] {
|
|
switch code {
|
|
case CodeNotFound, CodeAlreadyClaimed, CodeNotClaimable:
|
|
t.Errorf("claimNext documents %s; it names no row, so it can refuse for neither reason", code)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestClaimNextPathReachesItsHandler drives the documented path, which is the
|
|
// one thing route parity cannot check: this literal shares a prefix with the
|
|
// claim's wildcard, and ServeMux precedence is what keeps it from being parsed
|
|
// as a claim of an issue called ":claimNext".
|
|
func TestClaimNextPathReachesItsHandler(t *testing.T) {
|
|
claimer := &roleReadyClaimer{result: issueops.ClaimNextResult{Claimed: readyRow("bd-1")}}
|
|
ts := newClaimNextServer(t, claimer)
|
|
|
|
if resp := ts.claimNext(t, claimNextPath, `{"actor":"poller"}`); resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("POST the documented claimNext path: status = %d, want 200", resp.StatusCode)
|
|
}
|
|
line := findLogLine(t, ts.stderr.String(), "path="+claimNextPath)
|
|
if !strings.Contains(line, "op="+OpClaimNextIssue) {
|
|
t.Errorf("the documented claimNext path is served by another operation:\n%s", line)
|
|
}
|
|
if got := claimer.claimNextRequests(); len(got) != 1 {
|
|
t.Errorf("the documented path did not reach the role: %+v", got)
|
|
}
|
|
}
|