beads/cmd/bd/serve_store_identity_test.go
Julian Knutsen 4450fe99bb
feat(http): bd blocked over bd serve (blocked.list), plus bd blocked --flags [--raw] (#7649)
* feat(http): bd blocked over bd serve (blocked.list) through issueops.BlockedLister

`bd blocked` refused against an HTTP workspace: it called the legacy
GetBlockedIssues, which the HTTP backend stubs as unsupported. It now runs
one role on every route, and bd serve publishes that role.

- Role: issueops.BlockedLister.ListBlocked(BlockedRequest{ParentID, Labels,
  LabelsAny, ExcludeLabels}) -> BlockedResult{Items}. One body,
  internal/storage/issueops.ExecuteListBlockedInTx over the unchanged
  GetBlockedIssuesInTx; labels normalized in the role (BlockedFilter);
  Items never nil and in a total order (priority, created_at desc, id).
- Legs: DoltStore (read tx), EmbeddedDoltStore (read conn), uow (read unit
  of work through the use case's GetBlockedIssues, so the
  external-dependency uow decorator applies). Census: storage.DoltStorage
  gains BlockedLister(); HookFiringStore passes it through (a read),
  telemetry wraps it, uow.notifyingProvider, externaldeps.uowProvider and
  httpapi.timedProvider build it.
- externaldeps.Store.BlockedLister is built over its own GetBlockedIssues,
  so local `bd blocked` output is unchanged. Over a remote store it takes
  the server's listing when the server advertises
  policy.external_dependencies, else decorates the server's listing here
  through EdgeReader and BatchGetter (decorateBlocked, factored out of
  GetBlockedIssues).
- Wire: GET /v0/beads/blocked (listBlockedIssues; parent, label,
  label_any, exclude_label) answering BlockedPage {items, has_more} with
  the new x-go-type-pinned BlockedIssue schema, behind the new
  blocked.list token. apigen and the wire-shape golden regenerated; the
  golden diff is additive only, so wire_revision stays 2.
  Config.BlockedLister is a required role, wired in bd serve.
- Client: httpclient.Store.BlockedLister dials through Store.dispatch, so
  an older server is refused BEFORE the dial with *wire.CapabilityError
  naming blocked.list. The legacy Store.GetBlockedIssues rides the role
  (page and row cap applied to its answer) and leaves the unsupported
  shell. Divergence ledger row F-blocked retired.
- CLI: `bd blocked` takes BlockedLister() from the store on the direct
  routes and from the provider's BlockedListerSource on the proxied route;
  runBlockedProxiedServer is deleted. --json output is the same rows in
  the same order, [] when empty.

Tests: backend/conformance RunBlockedLister (10 cases: direct blocker,
child attributed to its blocked parent, closed blocker, wisp plane, pinned
status, parent filter, label filters with normalization, order, empty
slice, request not mutated) on dolt, embedded, uow and the served HTTP
client; httpapi handler tests (mapping, unknown/repeated params,
projection, capability); httpclient stub tests (pre-dial refusal naming
the token, encoding, projection, legacy door paging); skew and vocabulary
counts; TestE2E_BlockedOverHTTP (served `bd blocked --json` equals the
local command's after mapping ids and timestamps, member order included,
external blocker named, older-server refusal with no dial); corpus
gc-blocked re-marked and gc-blocked-parent added, both pending until the
reference server advertises blocked.list.

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

* fix(blocked): pin server-side external decoration, refuse has_more, serve the legacy door over http

Review fixes for the blocked.list slice.

- Server-side external decoration is now pinned on the compositions bd
  serve answers from. TestWrapUOWProviderBlockedListerNamesExternalBlockers
  lists through the wrapped unit-of-work provider's own BlockedLister
  accessor (the bd serve provider path) and requires an external-only row
  and a mixed row to carry their external: refs; building that lister over
  the inner provider fails it. TestServedBlockedListerCarriesExternalRefs-
  WhenTheServerEnforces serves the store-shaped composition
  (externaldeps.Store.BlockedLister, policy advertised) and requires the
  operation's own answer, through the undecorated client role, to carry the
  refs, and the client's decorated chain to return it unchanged; serving
  the inner store's lister fails it.
- The client refuses an answer reporting has_more with the new typed
  httpclient.TruncatedListingError instead of returning a short listing:
  the operation has no cursor, and a caller reads a missing row as
  unblocked. The legacy door inherits it.
- externaldeps.Store.GetBlockedIssues over an http store reads the extra
  sources through the served roles (EdgeReader, BatchGetter) instead of the
  raw GetIssuesByIDs / GetDependencyRecordsForIssues the http backend
  refuses, and the decoration skips the source read when there is nothing
  to load. The legacy door on the CLI chain (bd mol stale, the wisp
  commands) now answers over http in both policy modes;
  TestServedLegacyGetBlockedIssuesThroughTheDecorator pins it, paging
  included. bd ready --explain still refuses on its other raw reads; the
  CHANGELOG says so.
- Docs: the spec and the retired F-blocked ledger row state that the
  listing is unpaged, bounded by the client's 32 MiB response limit
  (refused, never read in part), and that has_more is refused.
- Contract: new cases for waits-for and conditional-blocks blockers, no
  type exclusions (gate, epic), and a stale flag with no nameable blocker
  (on the legs that can write the column: dolt, embedded; skipped
  elsewhere with the reason). Order seeds explicit created_at values with
  five rows tied on priority and created_at, two of them wisps, so only the
  id tiebreak orders them; dropping the tiebreak now fails every run.

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

* feat(blocked): bd blocked --flags, the blocked flag per id from stdin

`bd blocked --flags [--json]` reads ids from stdin, one per line (blank
lines and repeats ignored), and prints the blocked flag bd holds for each:
with --json, [{"id","is_blocked"}] in the order the ids were first given,
omitting an id that names no row on either plane, [] for no input. It is
the readiness column a consumer otherwise had to read with `bd sql`, so no
such consumer needs a local-only command.

It is the FLAG, not the listing: `bd blocked` narrows the stored flag to
rows it can name a blocker for, and --flags does not, so a row whose flag
is set with no nameable blocker reads true here and is absent from the
listing. Where the external-dependency policy applies, an unsatisfied
external: blocker sets the flag, as it keeps the row out of `bd ready`.

One library entry on every route: issueops.BlockedFlags over the route's
BlockingAnnotator (the store's accessor on dolt, embedded and HTTP, the
provider's on the proxied route). Over HTTP that is listBlockingAnnotations
with is_blocked behind dependencies.blocking.isBlocked; a server without
that token is refused before the dial, naming it. No wire change. The
listing's filter flags are refused with --flags rather than ignored.

Tests: TestE2E_BlockedFlagsOverHTTP (served JSON equals the local command's
after mapping ids to titles, unknown id omitted, repeat collapsed, [] on
empty stdin, filters refused; a stale-flagged row with no blocker reads
true and is absent from `bd blocked --json`, which fails if --flags is
derived from the listing; an older server's handshake refused naming the
token with no dial); TestProxiedServerBlocked/flags_reads_ids_from_stdin on
the proxied route; corpus gc-blocked-flags, pending until the reference
server advertises the token. CHANGELOG entry.

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

* feat(blocked): bd blocked --flags --raw, the stored is_blocked column

`bd blocked --flags --raw [--json]` answers the stored is_blocked column
for each id read from stdin, exactly what reading is_blocked from the issues
and wisps tables returns, without the external-dependency policy: a row
blocked only by an unsatisfied external: ref reads false (the policy-aware
--flags reads true), and a stale flag reads true either way. Same output
shape as --flags. This lets a consumer move off a `bd sql` read of the
column with no change in what it reads. The default --flags is unchanged.

The role is taken from beneath every decorator: storage.UnwrapStore on the
direct routes, uow.UnwrapProvider on the proxied route. Over HTTP the
innermost store is the http client, whose annotation read is the server's
answer: against a server that does not advertise
policy.external_dependencies that answer is the column, and --raw is
served. A server that advertises it decorates the flag it answers, the v0
wire has no member asking it for the column, and the decorated flag cannot
be turned back into the column client-side, so --raw against such a server
is refused before the annotation read, naming the token, rather than
answered with the decorated flag. --raw without --flags is refused.

Tests: TestE2E_BlockedFlagsOverHTTP/raw_is_the_stored_column (served --raw
equals local --raw; the externally-blocked-only row reads true with --flags
and false with --raw on both; locally blocked rows agree; a stale-flagged
row reads true in both modes; --raw without --flags exits 1; a server
advertising the policy refuses --raw with no annotation request);
TestProxiedServerBlocked/flags_raw_is_the_stored_column; corpus
gc-blocked-flags-raw (pending until the reference server advertises
dependencies.blocking.isBlocked). Routing --raw through the decorated
annotator fails the e2e. CHANGELOG entry.

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

* docs(changelog): bd blocked --flags --raw is for the local and proxied routes

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

* test(blocked): give the e2e gate-kid its own priority; document --flags answers closed ids

TestE2E_BlockedOverHTTP seeded gate-parent and gate-kid at one priority, so
when both landed in the same second their order fell to the generated ids,
which differ between the local and the served workspace: the comparison
failed intermittently. gate-kid now has its own priority. Ten runs on the
embedded lane pass.

bd blocked --flags answers a closed id too, with its stored flag; a SQL read
of the column filtered on status <> 'closed' leaves it out. Said in the
command's doc and the CHANGELOG.

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

* fix(blocked): apply label filters to external-only blocked rows

The external-dependency policy appends a row blocked only by an
unsatisfied external: ref after the label query has run, so --label,
--label-any and --exclude-label never judged it: bd blocked and
GET /v0/beads/blocked listed it whatever its labels, on every route.
Both decorators now filter those rows by the request's labels. The uow
decorator reads them through GetMany, chunked at MaxGetManyIDs, so their
labels are hydrated; GetIssuesByIDs left them empty, which also printed
them unlabelled on the proxied route.

Review fixes (adopt-pr apply-fixes, iteration 1):
- major #1: label filters on external-only rows in the store and uow
  decorators, with absence-asserting arms in the unit, served httpclient
  (server- and client-enforced policy), e2e and proxied tiers; the spec
  and the role doc say such rows are narrowed like every other row.
- minor #2: the policy.external_dependencies token prose names the
  blocked listing (spec, routes.go, regenerated types.gen.go).
- minor #6: SERVE_RUNBOOK and the allowUnlimited comment record the
  blocked listing's unbounded whole-set answer and why.
- minor #10: BlockedLister telemetry-outermost and typed-unsupported pins
  beside the ReadyCounter pair, plus the externaldeps wrap pin.
- nit #9: F-blocked names --flags --raw's refusal against a server that
  applies the policy (ledger.go and the regenerated ledger doc).
- nit #11: the remote BlockedLister no longer builds a local lister it
  then discards.

Review fixes (adopt-pr apply-fixes, iteration 2; the review approved at
940 with one minor and two nits, none gating):
- minor (the --flags refusal list was unpinned): the new
  TestBlockedFlagsRefusesEveryListingFilter pins blockedFlagFilterFlags
  to the flags blockedCmd registers, in both directions. Every
  registered flag except --flags and --raw must be refused, and every
  entry must name a registered flag. The test walks Flags() rather than
  LocalFlags(), so it does not merge the root's persistent flags into
  blockedCmd, and it skips inherited root flags and cobra's --help.
  Mutants:
  - four fail it: a new filter flag left off the list, a dropped
    entry, a misspelled entry, and --raw added to the list;
  - a simulated earlier in-process run (merged root flags plus --help)
    stays green, and fails once either skip is removed.
- nit (the remote branch's span): the remote BlockedLister comment now
  says why that lister is not wrapped again. The inner lister already
  carries telemetry's span, so wrapping would nest a second span of the
  same name. The comment also says what runs outside that span.
- nit (duplicated order comparator): left as is. finishBlockedIssues
  predates this PR, so merging the two sorts would refactor existing
  code with no review pass left after this one.

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

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Co-authored-by: Eddie the Engineer <338826946+gascity-eddie[bot]@users.noreply.github.com>
2026-10-17 12:29:13 +00:00

369 lines
14 KiB
Go

//go:build cgo
package main
import (
"context"
"errors"
"fmt"
"io"
"net/http"
"os"
"path/filepath"
"strings"
"sync/atomic"
"testing"
"github.com/steveyegge/beads/internal/beads"
"github.com/steveyegge/beads/internal/configfile"
"github.com/steveyegge/beads/internal/git"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/storage/backends"
"github.com/steveyegge/beads/internal/types"
"github.com/steveyegge/beads/issueops"
"github.com/steveyegge/beads/memoryops"
)
// TestServeAnswersFromTheStoreTheRootCommandOpened pins the one property this
// whole arm exists for, and pins it as a property rather than as a shape.
//
// "Serve answers from the store bd already opened" and "serve opens a second
// store of its own" produce identical output on every other assertion available:
// the same reads, the same claims, the same handshake, the same clean shutdown.
// The difference is a leaked handle with no owner, doubled pools, and — on a
// backend that takes an exclusive workspace lock — a second open that fights the
// first. Replacing `store` in runServe with a store opened here, which compiles,
// used to pass everything.
//
// So WHICH store answered has to be readable off the wire. Every open through
// this registry hands back a store whose reader answers with one issue named
// after that open: the first is "store-1", a second would be "store-2". The
// response body says which one the server is on, and no amount of wiring can
// forge it.
func TestServeAnswersFromTheStoreTheRootCommandOpened(t *testing.T) {
const name = "serve-store-identity"
var opens atomic.Int64
open := func(context.Context, string) (storage.DoltStorage, error) {
return &serveIdentityDoltStore{
serveIdentityStore: &serveIdentityStore{id: fmt.Sprintf("store-%d", opens.Add(1))},
}, nil
}
backends.Register(name, backends.Backend{
Open: open,
OpenReadOnly: open,
WorkspaceIsBeadsDir: true,
})
t.Cleanup(func() { backends.Deregister(name) })
dir := t.TempDir()
initGitRepoAt(t, dir)
beadsDir := filepath.Join(dir, ".beads")
if err := os.MkdirAll(beadsDir, 0o755); err != nil {
t.Fatalf("mkdir .beads: %v", err)
}
if err := (&configfile.Config{Backend: name}).Save(beadsDir); err != nil {
t.Fatalf("save metadata.json: %v", err)
}
useStorageModeGlobals(t)
restoreServeGlobals(t)
t.Chdir(dir)
t.Setenv("BEADS_DIR", beadsDir)
// The workspace snapshot is resolved once per process and cached, so a test
// that chdirs into its own workspace has to clear it going in and coming
// out.
beads.ResetCaches()
git.ResetCaches()
t.Cleanup(func() {
beads.ResetCaches()
git.ResetCaches()
})
// Stand in for PersistentPreRunE, which opens the workspace through exactly
// this dispatch and leaves it in `store`. This is the store bd already
// opened, and it is store-1.
opened, err := openRegisteredStoreForTest(t, name, beadsDir)
if err != nil {
t.Fatalf("open the registered backend: %v", err)
}
store = opened
serveAddr, serveAllowNonLoopback = "127.0.0.1:0", false
ctx, cancel := context.WithCancel(t.Context())
defer cancel()
setRootContext(ctx, cancel)
lines, stopCapture := captureStdoutLines(t)
done := make(chan error, 1)
go func() {
err := runServe()
stopCapture()
done <- err
}()
addr := waitForBoundAddress(t, lines, done)
body := getBody(t, "http://"+addr+"/v0/beads/ready?limit=5")
if !strings.Contains(body, opened.id) {
t.Errorf("GET /v0/beads/ready answered from a store other than the one bd opened (%s):\n%s", opened.id, body)
}
// Named separately, because the two failures are different bugs: the body
// above says the server is on the wrong store, and this says a store was
// created that nobody will ever close.
if n := opens.Load(); n != 1 {
t.Errorf("the registered backend was opened %d times, want 1: bd serve created a store of its own", n)
}
cancel()
if err := <-done; err != nil {
t.Fatalf("runServe returned %v, want a clean shutdown", err)
}
}
// openRegisteredStoreForTest opens the workspace the way PersistentPreRunE
// does: through the registry, by name, with no knowledge of what is behind it.
func openRegisteredStoreForTest(t *testing.T, name, beadsDir string) (*serveIdentityDoltStore, error) {
t.Helper()
backend, ok := backends.Lookup(name)
if !ok {
t.Fatalf("backend %q is not registered", name)
}
opened, err := backend.Open(t.Context(), beadsDir)
if err != nil {
return nil, err
}
identified, ok := opened.(*serveIdentityDoltStore)
if !ok {
t.Fatalf("the registry returned %T, not the identified store this test reads by name", opened)
}
return identified, nil
}
// getBody issues a GET and returns the raw body, failing on anything but a 200.
func getBody(t *testing.T, url string) string {
t.Helper()
resp, err := http.Get(url)
if err != nil {
t.Fatalf("GET %s: %v", url, err)
}
defer resp.Body.Close()
payload, err := io.ReadAll(resp.Body)
if err != nil {
t.Fatalf("read %s: %v", url, err)
}
if resp.StatusCode != http.StatusOK {
t.Fatalf("GET %s status = %d, want 200: %s", url, resp.StatusCode, payload)
}
return string(payload)
}
// serveIdentityStore is a store that says which store it is. Its reader answers
// every ready query with a single issue whose ID is the store's own, so the
// identity of the value the server was wired to is a substring of the response
// rather than something a test has to reach inside the server to inspect.
//
// IT EMBEDS NOTHING, and the assertion below is why. This stub used to embed a
// nil storage.DoltStorage, so a role it had not declared arrived as a promoted
// method on a nil interface — GraphCounter did, and it surfaced as a segfault on
// a full-package CI shard rather than as a compile error, because no -run
// pattern anyone reached for names this test. Declaring the whole of
// serveRoleSource makes the next role a build failure here.
type serveIdentityStore struct {
id string
}
var _ serveRoleSource = (*serveIdentityStore)(nil)
// serveIdentityDoltStore is what the registry hands back, because
// backends.Backend.Open returns a whole storage.DoltStorage. The roles above sit
// one embed shallower than the nil store in serveStubRest and so shadow it:
// nothing on this path calls anything else, and a nil panic naming the method
// would be a truer failure than a stub that answered.
type serveIdentityDoltStore struct {
*serveIdentityStore
serveStubRest
}
func (s *serveIdentityStore) IssueReader() (issueops.Reader, error) {
return serveIdentityReader{id: s.id}, nil
}
func (s *serveIdentityStore) IssueClaimer() (issueops.Claimer, error) {
return serveIdentityClaimer{}, nil
}
// Close is the one lifecycle method that is reached: the test harness closes a
// store it finds left behind. There is nothing to release.
func (s *serveIdentityStore) Close() error { return nil }
// The rest of the roles httpapi.Config requires. This test drives one route,
// but Listen refuses a partial role set, so the server does not bind at all
// without them.
//
// They hand back serveIdentityRole, which satisfies each interface by
// EMBEDDING it rather than implementing it: non-nil, so the set is complete,
// while an actual call panics naming the method it reached.
func (*serveIdentityStore) BatchCloser() (issueops.BatchCloser, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) ReadyClaimer() (issueops.ReadyClaimer, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) Releaser() (issueops.Releaser, error) { return serveIdentityRole{}, nil }
// LeaseReclaimer is declared at depth 1 for Releaser's reason: its hook
// decorator wraps, and the recursion would otherwise land on a nil-embedded
// promotion.
func (*serveIdentityStore) LeaseReclaimer() (issueops.LeaseReclaimer, error) {
return serveIdentityRole{}, nil
}
// Heartbeater is declared at depth 1 for the same reason: its hook decorator
// recurses, and the recursion would otherwise land on a nil-embedded promotion.
func (*serveIdentityStore) Heartbeater() (issueops.Heartbeater, error) {
return serveIdentityRole{}, nil
}
// BlockedLister is declared at depth 1 for the same reason.
func (*serveIdentityStore) BlockedLister() (issueops.BlockedLister, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) IssueLifecycle() (issueops.Lifecycle, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) WorkspaceConfig() (issueops.WorkspaceConfig, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) StatsReporter() (issueops.StatsReporter, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) CycleDetector() (issueops.CycleDetector, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) EdgeReader() (issueops.EdgeReader, error) { return serveIdentityRole{}, nil }
// GraphCounter is declared for the reason every accessor here is, and it is the
// one this stub was CAUGHT missing rather than written with: the edge-count
// role is a read, so its hook decorator recurses, and the recursion lands on a
// type whose embedded storage.DoltStorage is nil. That is a promoted method on
// a nil interface — a segfault inside `bd serve`'s role extraction, not a
// compile error — and it surfaced only on the full-suite macOS shard, because
// no test name here matches the ones a role slice thinks to run.
func (*serveIdentityStore) GraphCounter() (issueops.GraphCounter, error) {
return serveIdentityRole{}, nil
}
// BatchGetter is declared at depth 1 for GraphCounter's reason: the many-ids
// read is also a read, so its hook decorator (hook_batch_getter.go) recurses
// and the recursion would land on a nil-embedded promotion if this were not
// here.
func (*serveIdentityStore) BatchGetter() (issueops.BatchGetter, error) {
return serveIdentityRole{}, nil
}
// IssueRelations is the first role added to serveIssueRoles since this stub
// stopped embedding a nil store, so the comment above it is now a record of the
// old regime rather than a warning about this one: GraphCounter had to be found
// by a CI shard, and this had to be declared before the package would build,
// with `missing method IssueRelations` naming it.
//
// It is declared HERE, at depth 1, and that placement is the load-bearing half.
// serveIdentityDoltStore embeds this type shallower than serveStubRest's nil
// store, so a role declared here shadows the promotion; one declared on the
// wrapper instead would satisfy the compiler and leave the assertion below
// unable to see it.
func (*serveIdentityStore) IssueRelations() (issueops.Relations, error) {
return serveIdentityRole{}, nil
}
// Commenter is declared at depth 1 for IssueRelations' reason, and it is the
// second role to arrive as a build error here rather than as a runtime one.
func (*serveIdentityStore) Commenter() (issueops.Commenter, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) BlockingAnnotator() (issueops.BlockingAnnotator, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) TreeWalker() (issueops.TreeWalker, error) { return serveIdentityRole{}, nil }
func (*serveIdentityStore) ReadyCounter() (issueops.ReadyCounter, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) Counter() (issueops.Counter, error) { return serveIdentityRole{}, nil }
func (*serveIdentityStore) Querier() (issueops.Querier, error) { return serveIdentityRole{}, nil }
func (*serveIdentityStore) Sweeper() (issueops.Sweeper, error) { return serveIdentityRole{}, nil }
func (*serveIdentityStore) Deleter() (issueops.Deleter, error) { return serveIdentityRole{}, nil }
func (*serveIdentityStore) BatchCreator() (issueops.BatchCreator, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) DependencyEditor() (issueops.DependencyEditor, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) BatchApplier() (issueops.BatchApplier, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) Memories() (memoryops.Memories, error) {
return serveIdentityRole{}, nil
}
func (*serveIdentityStore) MetadataCAS() (issueops.MetadataCAS, error) {
return serveIdentityRole{}, nil
}
// serveIdentityRole satisfies every one of them at once, which it can because no
// two of those interfaces declare a method of the same name. If a future role
// collides, split this into one type per role — the embedded method would stop
// being promoted and the build would say so.
type serveIdentityRole struct {
issueops.Lifecycle
issueops.Releaser
issueops.LeaseReclaimer
issueops.Heartbeater
issueops.BlockedLister
issueops.ReadyClaimer
issueops.BatchCloser
issueops.MetadataCAS
issueops.WorkspaceConfig
issueops.StatsReporter
issueops.CycleDetector
issueops.EdgeReader
issueops.GraphCounter
issueops.BatchGetter
issueops.Relations
issueops.Commenter
issueops.BlockingAnnotator
issueops.TreeWalker
issueops.ReadyCounter
issueops.Counter
issueops.Querier
issueops.Sweeper
issueops.Deleter
issueops.BatchCreator
issueops.DependencyEditor
issueops.BatchApplier
memoryops.Memories
}
type serveIdentityReader struct{ id string }
func (r serveIdentityReader) Ready(context.Context, issueops.ReadyRequest) (issueops.IssuePage, error) {
return issueops.IssuePage{
Items: []*issueops.IssueWithCounts{{Issue: &types.Issue{
ID: r.id,
Title: "answered by " + r.id,
Status: types.StatusOpen,
}}},
}, nil
}
func (serveIdentityReader) List(context.Context, issueops.ListRequest) (issueops.IssuePage, error) {
return issueops.IssuePage{}, errors.ErrUnsupported
}
func (serveIdentityReader) Get(context.Context, issueops.GetRequest) (*issueops.IssueDetails, error) {
return nil, errors.ErrUnsupported
}
type serveIdentityClaimer struct{}
func (serveIdentityClaimer) Claim(context.Context, issueops.ClaimRequest) (issueops.ClaimResult, error) {
return issueops.ClaimResult{}, errors.ErrUnsupported
}