Files
archie/internal/infrastructure/staterpc/conformance_test.go
T

425 lines
18 KiB
Go

package staterpc
import (
"context"
"errors"
"net"
"testing"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/test/bufconn"
"github.com/samcharles93/archie-core/internal/domain/binding"
"github.com/samcharles93/archie-core/internal/domain/mapping"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/store"
)
// contract is the union of every store surface staterpc fronts (minus the
// playbook-dispatch ledger, split out below to keep the interface under the
// repo's 8-method cap), so the same test battery drives both the local
// *store.Store and the remote *Client through one interface value, per
// docs/prds/state-store-contract.md §11's conformance requirement.
type contract interface {
store.TaskStore
store.CaptureStore
store.MappingStore
store.BindingStore
store.BindingDispatcher
store.BindingTaskCreator
store.ConfigSnapshotStore
store.ApplyStatusStore
}
// playbookContract is the playbook-dispatch idempotency-ledger surface, split
// out from contract so each aggregate stays under the repo's interfacebloat
// cap without weakening what the conformance battery proves.
type playbookContract interface {
store.PlaybookDispatcher
}
// taskLogContract is the task-log read group, driven separately because it is
// not a *store.Store surface: the reader is internal/logging's own registry,
// which owns the log format, so the local side of this contract is a registry
// rather than a store.
type taskLogContract interface {
store.TaskLogStore
}
func remoteContract(t *testing.T, local *store.Store) contract {
t.Helper()
return remoteTaskStore(t, local, nil)
}
// remoteTaskStore serves local behind a bufconn listener with a task-log
// reader attached, and returns a client for it. The reader is a parameter
// because the log files are internal/logging's, not the store's: this contract
// fronts a reader rather than a table.
func remoteTaskStore(t *testing.T, local *store.Store, logs store.TaskLogStore) *Client {
t.Helper()
listener := bufconn.Listen(1 << 20)
server := grpc.NewServer()
RegisterServer(server, Deps{
Tasks: local, Captures: local, Mappings: local, Bindings: local,
BindingDispatcher: local, BindingTaskCreator: local, PlaybookDispatcher: local, ConfigSnapshots: local, ApplyStatus: local,
TaskLogs: logs,
})
go func() { _ = server.Serve(listener) }()
t.Cleanup(func() { server.Stop(); _ = listener.Close() })
conn, err := grpc.NewClient("passthrough:///state",
grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithContextDialer(func(ctx context.Context, _ string) (net.Conn, error) { return listener.DialContext(ctx) }))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = conn.Close() })
return NewClient(conn)
}
// TestStateStoreConformance runs the same battery of contract calls through
// both the local adapter and a bufconn-backed gRPC client, asserting
// identical behaviour including error-sentinel fidelity and the
// not-found-as-(nil,nil) convention (§7, §11).
func TestStateStoreConformance(t *testing.T) {
for _, mode := range []string{"local", "grpc"} {
t.Run(mode, func(t *testing.T) {
ctx := t.Context()
local := store.OpenTest(t)
var c contract = local
var pc playbookContract = local
if mode == "grpc" {
remote := remoteTaskStore(t, local, nil)
c = remote
pc = remote
}
// workflow.Store view: EnqueueChatTask, Transition, Update, InsertEvent.
task, err := c.EnqueueChatTask(ctx, "acme", "widget", "title", "body", "implement", "")
if err != nil || task == nil {
t.Fatalf("EnqueueChatTask: %+v %v", task, err)
}
if err := c.Transition(ctx, task.ID, task.Status, "running", "started"); err != nil {
t.Fatalf("Transition: %v", err)
}
task.Plan = "the plan"
task.Status = "running"
task.PRNumber = 401
// The workflow pin is what a retry re-reads instead of resolving the
// active control-plane resource again (docs/prds/runtime-control-plane.md:95).
// A wire hop that drops it leaves the daemon's digest guard dead, so
// the battery carries it through Update and back out of TaskByID.
task.WorkflowDefinitionVersion = 7
task.WorkflowDefinitionDigest = "sha256:beef"
task.WorkflowDefinitionYAML = "name: implement\nsteps: []\n"
if err := c.Update(ctx, task); err != nil {
t.Fatalf("Update: %v", err)
}
eventID, err := c.InsertEvent(ctx, events.Event{Kind: "stage_finish", TaskID: task.ID, Attempt: 2, Data: map[string]any{"duration_ms": 12.0}})
if err != nil || eventID == 0 {
t.Fatalf("InsertEvent: %v %v", eventID, err)
}
// R4's wire acceptance: the per-attempt configuration document IS an
// event, so it has to survive the same hop an event does, including
// its nested structure and the attempt key that attributes it to one
// run. A payload that arrives flattened reads as a config with no
// fields at all. The document rides under the daemon's own key
// (internal/daemon/daemon.go), asserted by name below.
_, err = c.InsertEvent(ctx, events.Event{
Kind: events.KindConfigCaptured, TaskID: task.ID, Attempt: 2,
Data: map[string]any{
"schema": events.ConfigCapturedSchema,
"document": map[string]any{"bot_user": "archie", "models": map[string]any{"implement": "anthropic/claude"}},
},
})
if err != nil {
t.Fatalf("InsertEvent config_captured: %v", err)
}
// Stale transition: from no longer matches current status.
err = c.Transition(ctx, task.ID, "queued", "merged", "")
if !errors.Is(err, store.ErrStaleTransition) {
t.Fatalf("Transition stale = %v, want ErrStaleTransition", err)
}
// TaskQueries: found=false is not an error.
missing, err := c.TaskByID(ctx, task.ID+999999)
if err != nil || missing != nil {
t.Fatalf("TaskByID missing: %+v %v", missing, err)
}
got, err := c.TaskByID(ctx, task.ID)
if err != nil || got == nil || got.Plan != "the plan" {
t.Fatalf("TaskByID: %+v %v", got, err)
}
if got.WorkflowDefinitionVersion != 7 || got.WorkflowDefinitionDigest != "sha256:beef" ||
got.WorkflowDefinitionYAML != "name: implement\nsteps: []\n" {
t.Errorf("workflow pin after round trip = (%d, %q, %q), want (7, \"sha256:beef\", the YAML); a dropped pin makes each retry re-resolve the active definition",
got.WorkflowDefinitionVersion, got.WorkflowDefinitionDigest, got.WorkflowDefinitionYAML)
}
byIssue, err := c.TaskByIssue(ctx, task.Owner, task.Repo, task.IssueNumber)
if err != nil || byIssue == nil || byIssue.ID != task.ID {
t.Fatalf("TaskByIssue: %+v %v", byIssue, err)
}
if err := c.Transition(ctx, task.ID, "running", "pr_open", "PR #401"); err != nil {
t.Fatalf("Transition to pr_open: %v", err)
}
byPR, err := c.OpenTaskByPR(ctx, task.Owner, task.Repo, task.PRNumber)
if err != nil || byPR == nil || byPR.ID != task.ID {
t.Fatalf("OpenTaskByPR: %+v %v", byPR, err)
}
missing, err = c.OpenTaskByPR(ctx, task.Owner, task.Repo, task.PRNumber+1)
if err != nil || missing != nil {
t.Fatalf("OpenTaskByPR missing: %+v %v", missing, err)
}
if _, err := c.Tasks(ctx, 10); err != nil {
t.Fatalf("Tasks: %v", err)
}
if _, err := c.StatusCounts(ctx); err != nil {
t.Fatalf("StatusCounts: %v", err)
}
if _, err := c.OpenPRs(ctx); err != nil {
t.Fatalf("OpenPRs: %v", err)
}
// TaskEvents / EventsSince / stats.
evs, err := c.TaskEvents(ctx, task.ID)
if err != nil || len(evs) != 2 || evs[0].Data["duration_ms"] != 12.0 {
t.Fatalf("TaskEvents: %+v %v", evs, err)
}
if evs[0].Attempt != 2 {
t.Errorf("TaskEvents attempt = %d, want 2 (provenance must survive the wire)", evs[0].Attempt)
}
if evs[1].Kind != events.KindConfigCaptured || evs[1].Attempt != 2 || evs[1].Data["schema"] != events.ConfigCapturedSchema {
t.Errorf("config_captured event = %+v, want its kind, attempt and schema preserved", evs[1])
}
if _, renamed := evs[1].Data["config"]; renamed {
t.Error(`the document crossed under "config"; the producer writes it under "document"`)
}
if len(evs[1].Data) != 2 {
t.Errorf("config_captured data keys = %v, want exactly schema and document", evs[1].Data)
}
doc, ok := evs[1].Data["document"].(map[string]any)
if !ok || doc["bot_user"] != "archie" {
t.Errorf("config_captured payload = %#v, want the decoded document under its own key", evs[1].Data)
}
if _, err := c.EventsSince(ctx, 0, 10); err != nil {
t.Fatalf("EventsSince: %v", err)
}
if _, err := c.WorkflowStats(ctx); err != nil {
t.Fatalf("WorkflowStats: %v", err)
}
if _, err := c.StageStats(ctx); err != nil {
t.Fatalf("StageStats: %v", err)
}
if _, err := c.TokensByDay(ctx, 7); err != nil {
t.Fatalf("TokensByDay: %v", err)
}
// Lifecycle: ClaimNext / ClaimByIssue / Requeue / RetryTask / RecoverStale.
if _, err := c.EnqueueIssue(ctx, "acme", "widget", 42, "issue title", "body", "bug", ""); err != nil {
t.Fatalf("EnqueueIssue: %v", err)
}
claimed, err := c.ClaimNext(ctx)
if err != nil || claimed == nil {
t.Fatalf("ClaimNext: %+v %v", claimed, err)
}
if err := c.Requeue(ctx, claimed.ID, "running", ""); err != nil {
t.Fatalf("Requeue: %v", err)
}
if err := c.RetryTask(ctx, claimed.ID, "queued", ""); err != nil {
t.Fatalf("RetryTask: %v", err)
}
if _, err := c.RecoverStale(ctx); err != nil {
t.Fatalf("RecoverStale: %v", err)
}
byClaim, err := c.ClaimByIssue(ctx, "acme", "widget", 999999)
if err != nil || byClaim != nil {
t.Fatalf("ClaimByIssue missing: %+v %v", byClaim, err)
}
// Archive. RecoverStale above may have requeued task if it was
// still running, so re-fetch its current status rather than
// trusting the in-memory snapshot.
current, err := c.TaskByID(ctx, task.ID)
if err != nil || current == nil {
t.Fatalf("TaskByID before archive: %+v %v", current, err)
}
if _, err := c.ArchiveTask(ctx, task.ID, current.Status, events.Event{Kind: "archived"}); err != nil {
t.Fatalf("ArchiveTask: %v", err)
}
if _, err := c.ClearTerminalTasks(ctx); err != nil {
t.Fatalf("ClearTerminalTasks: %v", err)
}
// Mapping: found=false, ErrMappingNotFound.
mappingID, err := c.InsertMapping(ctx, mapping.Mapping{Name: "m1", Fields: []mapping.Field{{Name: "a", Path: "a", Type: mapping.TypeString}}})
if err != nil || mappingID == 0 {
t.Fatalf("InsertMapping: %v %v", mappingID, err)
}
missingMapping, err := c.GetMapping(ctx, mappingID+999999)
if err != nil || missingMapping != nil {
t.Fatalf("GetMapping missing: %+v %v", missingMapping, err)
}
gotMapping, err := c.GetMapping(ctx, mappingID)
if err != nil || gotMapping == nil || gotMapping.Name != "m1" {
t.Fatalf("GetMapping: %+v %v", gotMapping, err)
}
if _, err := c.ListMappings(ctx); err != nil {
t.Fatalf("ListMappings: %v", err)
}
gotMapping.Name = "m1-renamed"
if err := c.UpdateMapping(ctx, *gotMapping); err != nil {
t.Fatalf("UpdateMapping: %v", err)
}
err = c.UpdateMapping(ctx, mapping.Mapping{ID: mappingID + 999999, Name: "x", Fields: gotMapping.Fields})
if !errors.Is(err, store.ErrMappingNotFound) {
t.Fatalf("UpdateMapping missing = %v, want ErrMappingNotFound", err)
}
err = c.DeleteMapping(ctx, mappingID+999999)
if !errors.Is(err, store.ErrMappingNotFound) {
t.Fatalf("DeleteMapping missing = %v, want ErrMappingNotFound", err)
}
// Binding: found=false, ErrBindingNotFound, ErrBindingOverlap,
// ErrBindingTransition, and the dispatch surface incl.
// ErrAlreadyDispatched.
bindingID, err := c.InsertBinding(ctx, binding.Binding{
Name: "b1", Matcher: binding.Matcher{Source: "sentry"}, MappingID: mappingID,
Workflow: "implement", Secret: "0123456789abcdef0123456789abcdef",
})
if err != nil || bindingID == 0 {
t.Fatalf("InsertBinding: %v %v", bindingID, err)
}
_, err = c.InsertBinding(ctx, binding.Binding{
Name: "b2", Matcher: binding.Matcher{Source: "sentry"}, MappingID: mappingID,
Workflow: "implement", Secret: "0123456789abcdef0123456789abcdef",
})
if !errors.Is(err, store.ErrBindingOverlap) {
t.Fatalf("InsertBinding overlap = %v, want ErrBindingOverlap", err)
}
missingBinding, err := c.GetBinding(ctx, bindingID+999999)
if err != nil || missingBinding != nil {
t.Fatalf("GetBinding missing: %+v %v", missingBinding, err)
}
gotBinding, err := c.GetBinding(ctx, bindingID)
if err != nil || gotBinding == nil || gotBinding.Name != "b1" {
t.Fatalf("GetBinding: %+v %v", gotBinding, err)
}
if _, err := c.ListBindings(ctx); err != nil {
t.Fatalf("ListBindings: %v", err)
}
err = c.ApproveBinding(ctx, bindingID)
if !errors.Is(err, store.ErrBindingTransition) {
t.Fatalf("ApproveBinding from draft = %v, want ErrBindingTransition", err)
}
err = c.DeleteBinding(ctx, bindingID+999999)
if !errors.Is(err, store.ErrBindingNotFound) {
t.Fatalf("DeleteBinding missing = %v, want ErrBindingNotFound", err)
}
// Capture + dispatch.
captureID, err := c.InsertCapture(ctx, store.CapturedEvent{Source: "sentry", Body: `{"id":1}`, Authenticated: true}, 0, 0)
if err != nil || captureID == 0 {
t.Fatalf("InsertCapture: %v %v", captureID, err)
}
if _, err := c.ListCaptures(ctx, 10); err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if _, err := c.ArmedBindingsForSource(ctx, "sentry"); err != nil {
t.Fatalf("ArmedBindingsForSource: %v", err)
}
bindingTask, err := c.EnqueueBindingTask(ctx, "acme", "widget", "t", "b", "implement", "", bindingID, 1)
if err != nil || bindingTask == nil {
t.Fatalf("EnqueueBindingTask: %+v %v", bindingTask, err)
}
if err := c.RecordDispatch(ctx, bindingID, 1, captureID, bindingTask.ID); err != nil {
t.Fatalf("RecordDispatch: %v", err)
}
err = c.RecordDispatch(ctx, bindingID, 1, captureID, bindingTask.ID)
if !errors.Is(err, store.ErrAlreadyDispatched) {
t.Fatalf("RecordDispatch dup = %v, want ErrAlreadyDispatched", err)
}
if _, err := c.ListUndispatchedCaptures(ctx, []string{"sentry"}, 10); err != nil {
t.Fatalf("ListUndispatchedCaptures: %v", err)
}
// Playbook dispatch ledger: ErrAlreadyDispatched survives the hop
// via errors.Is, and DeletePlaybookDispatches actually clears the
// row (the same key records again after delete).
if err := pc.RecordPlaybookDispatch(ctx, "pb.yaml", "v1", "archie:acme/widget/7", "notify"); err != nil {
t.Fatalf("RecordPlaybookDispatch: %v", err)
}
// Three of the four PRIMARY KEY components are carried through the hop
// with a distinguishing value here: a client/server mapping that drops
// or transposes event_id, playbook_version, or action_id collapses
// these distinct rows onto the first tuple and fails one of the three
// below.
if err := pc.RecordPlaybookDispatch(ctx, "pb.yaml", "v1", "archie:acme/widget/8", "notify"); err != nil {
t.Fatalf("RecordPlaybookDispatch (distinct event_id) = %v, want success", err)
}
if err := pc.RecordPlaybookDispatch(ctx, "pb.yaml", "v2", "archie:acme/widget/7", "notify"); err != nil {
t.Fatalf("RecordPlaybookDispatch (distinct playbook_version) = %v, want success", err)
}
if err := pc.RecordPlaybookDispatch(ctx, "pb.yaml", "v1", "archie:acme/widget/7", "build"); err != nil {
t.Fatalf("RecordPlaybookDispatch (distinct action_id) = %v, want success", err)
}
err = pc.RecordPlaybookDispatch(ctx, "pb.yaml", "v1", "archie:acme/widget/7", "notify")
if !errors.Is(err, store.ErrAlreadyDispatched) {
t.Fatalf("RecordPlaybookDispatch dup = %v, want ErrAlreadyDispatched", err)
}
if err := pc.DeletePlaybookDispatches(ctx, "pb.yaml"); err != nil {
t.Fatalf("DeletePlaybookDispatches: %v", err)
}
if err := pc.RecordPlaybookDispatch(ctx, "pb.yaml", "v1", "archie:acme/widget/7", "notify"); err != nil {
t.Fatalf("RecordPlaybookDispatch after delete = %v, want success (delete must clear the row)", err)
}
})
}
}
// TestConfigSnapshotContract drives the published configuration projection
// through both the local store and the gRPC client. The document is opaque to
// this hop, so the test's whole claim is that it arrives unchanged: the UI
// process renders exactly what the daemon published, and an absent snapshot
// reads as "not published yet" rather than an error.
func TestConfigSnapshotContract(t *testing.T) {
for _, mode := range []string{"local", "grpc"} {
t.Run(mode, func(t *testing.T) {
local := store.OpenTest(t)
var st contract = local
if mode == "grpc" {
st = remoteContract(t, local)
}
ctx := t.Context()
if _, found, err := st.ConfigSnapshot(ctx); err != nil || found {
t.Fatalf("unpublished snapshot = (found %v, %v), want (false, nil)", found, err)
}
published := store.ConfigSnapshot{
Schema: "webui.ConfigView/1",
Document: []byte(`{"identity":{"bot_user":"archie"},"providers":{"openai":{"api_key_env":"OPENAI_API_KEY","configured":true}}}`),
PublishedAt: time.Date(2026, 9, 9, 12, 30, 0, 0, time.UTC),
}
if err := st.PutConfigSnapshot(ctx, published); err != nil {
t.Fatalf("PutConfigSnapshot: %v", err)
}
got, found, err := st.ConfigSnapshot(ctx)
if err != nil || !found {
t.Fatalf("ConfigSnapshot = (found %v, %v), want the published snapshot", found, err)
}
if got.Schema != published.Schema {
t.Errorf("schema = %q, want %q", got.Schema, published.Schema)
}
if string(got.Document) != string(published.Document) {
t.Errorf("document = %s, want %s", got.Document, published.Document)
}
if !got.PublishedAt.Equal(published.PublishedAt) {
t.Errorf("published at = %v, want %v", got.PublishedAt, published.PublishedAt)
}
})
}
}