Files
archie/internal/infrastructure/postgres/edastore_test.go
T
sam be9a45ad2d Merge branch 'pg/foundation' into worktree-agent-a96503bc8828fc104
# Conflicts:
#	docs/data/generated/dev-docs.json
#	internal/app/archied/state_store_test.go
#	internal/app/archied/state_store_toolcalls_test.go
#	internal/contracts/state/v1/state.pb.go
#	internal/daemon/dispatch_bindings_test.go
#	internal/infrastructure/bindingcipher/cipher_test.go
#	internal/infrastructure/captureintake/receiver_test.go
#	internal/infrastructure/edastore/contracts_binding.go
#	internal/infrastructure/edastore/testsupport_test.go
#	internal/infrastructure/postgres/edastore.go
#	internal/infrastructure/postgres/edastore_test.go
#	internal/infrastructure/staterpc/error_test.go
#	internal/store/store.go
#	internal/webui/api_binding_test.go
2026-09-24 19:47:00 +10:00

214 lines
7.8 KiB
Go

package postgres
import (
"errors"
"testing"
"time"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/samcharles93/archie-core/internal/domain/binding"
"github.com/samcharles93/archie-core/internal/domain/mapping"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/infrastructure/bindingcipher"
)
const edaTestKey = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
// edaFor builds an EDA store over a migrated database, with no cipher.
func edaFor(t *testing.T) *EDA {
t.Helper()
pool, _ := migrated(t)
return NewEDA(pool, nil)
}
func edaWithCipher(t *testing.T, cipher bindingcipher.BindingCipher) (*pgxpool.Pool, *EDA) {
t.Helper()
pool, _ := migrated(t)
return pool, NewEDA(pool, cipher)
}
func insertBinding(t *testing.T, s *EDA, source string) string {
t.Helper()
id, err := s.InsertBinding(t.Context(), binding.Binding{
Name: "n", Matcher: binding.Matcher{Source: source}, Workflow: "implement",
})
if err != nil {
t.Fatalf("InsertBinding() error = %v", err)
}
return id
}
// Hazard 2: unique-violation detection must be by SQLSTATE, not by grepping
// the driver's error text. A Postgres error whose message happens to contain
// "unique" but whose SQLSTATE is not 23505 must not be treated as one, and a
// 23505 with a message lacking those words must be detected.
func TestIsUniqueViolationDetectsBySQLState(t *testing.T) {
if !isUniqueViolation(&pgconn.PgError{Code: "23505", Message: "duplicate key value"}) {
t.Error("SQLSTATE 23505 was not detected as a unique violation")
}
if isUniqueViolation(&pgconn.PgError{Code: "23502", Message: "null value in column of a unique constraint"}) {
t.Error("a non-23505 error whose text says unique was treated as a unique violation; SQLSTATE is authoritative")
}
if isUniqueViolation(errors.New("not a database error")) {
t.Error("a non-Postgres error was treated as a unique violation")
}
}
// Hazard 2 (integration): the dispatch ledger is at-most-once, refused by the
// schema and surfaced as ErrAlreadyDispatched.
func TestRecordDispatchIsIdempotent(t *testing.T) {
s := edaFor(t)
if err := s.RecordDispatch(t.Context(), "b1", 1, "c1", 42); err != nil {
t.Fatalf("first RecordDispatch() error = %v", err)
}
if err := s.RecordDispatch(t.Context(), "b1", 1, "c1", 99); !errors.Is(err, storecontract.ErrAlreadyDispatched) {
t.Errorf("second RecordDispatch() error = %v, want ErrAlreadyDispatched", err)
}
}
// binding_version is stored but deliberately not part of the unique key: a
// version bump does not permit re-dispatching the same (binding, capture).
func TestBindingDispatchVersionBumpDoesNotPermitRedispatch(t *testing.T) {
s := edaFor(t)
if err := s.RecordDispatch(t.Context(), "b1", 1, "c1", 42); err != nil {
t.Fatalf("first RecordDispatch() error = %v", err)
}
if err := s.RecordDispatch(t.Context(), "b1", 2, "c1", 99); !errors.Is(err, storecontract.ErrAlreadyDispatched) {
t.Errorf("redispatch with a version bump = %v, want ErrAlreadyDispatched: binding_version is not part of the key", err)
}
}
func TestPlaybookDispatchIsIdempotent(t *testing.T) {
s := edaFor(t)
if err := s.RecordPlaybookDispatch(t.Context(), "p1", "v1", "e1", "a1"); err != nil {
t.Fatalf("first RecordPlaybookDispatch() error = %v", err)
}
if err := s.RecordPlaybookDispatch(t.Context(), "p1", "v1", "e1", "a1"); !errors.Is(err, storecontract.ErrAlreadyDispatched) {
t.Errorf("second RecordPlaybookDispatch() error = %v, want ErrAlreadyDispatched", err)
}
}
// The lifecycle gate survives the port: pending_approval -> armed, and only
// from pending_approval.
func TestBindingLifecycle(t *testing.T) {
s := edaFor(t)
id := insertBinding(t, s, "src-lifecycle")
if err := s.ApproveBinding(t.Context(), id); err != nil {
t.Fatalf("ApproveBinding(pending_approval) error = %v", err)
}
if err := s.ApproveBinding(t.Context(), id); !errors.Is(err, storecontract.ErrBindingTransition) {
t.Errorf("re-approving an armed binding = %v, want ErrBindingTransition", err)
}
armed, err := s.ArmedBindingsForSource(t.Context(), "src-lifecycle")
if err != nil || len(armed) != 1 {
t.Fatalf("ArmedBindingsForSource() = %d bindings (err %v), want 1", len(armed), err)
}
}
// A capture round-trips its payload verbatim.
func TestCaptureRoundTrip(t *testing.T) {
s := edaFor(t)
body := `{"action":"created"}`
if _, err := s.InsertCapture(t.Context(), storecontract.CapturedEvent{
Source: "sentry", Body: body, Headers: `{"X-Hook":"1"}`, ContentType: "application/json",
}, 0, 0); err != nil {
t.Fatalf("InsertCapture() error = %v", err)
}
list, err := s.ListCaptures(t.Context(), 10)
if err != nil || len(list) != 1 {
t.Fatalf("ListCaptures() = %d (err %v), want 1", len(list), err)
}
if list[0].Body != body {
t.Errorf("Body round-trip = %q, want %q", list[0].Body, body)
}
}
func TestMappingCRUD(t *testing.T) {
s := edaFor(t)
id, err := s.InsertMapping(t.Context(), mapping.Mapping{Name: "payload-map"})
if err != nil {
t.Fatalf("InsertMapping() error = %v", err)
}
got, err := s.GetMapping(t.Context(), id)
if err != nil || got == nil {
t.Fatalf("GetMapping() = %v (err %v), want the mapping", got, err)
}
if got.Name != "payload-map" {
t.Errorf("Name = %q, want payload-map", got.Name)
}
got.Name = "renamed"
if err := s.UpdateMapping(t.Context(), *got); err != nil {
t.Fatalf("UpdateMapping() error = %v", err)
}
if err := s.DeleteMapping(t.Context(), id); err != nil {
t.Fatalf("DeleteMapping() error = %v", err)
}
if err := s.DeleteMapping(t.Context(), id); !errors.Is(err, storecontract.ErrMappingNotFound) {
t.Errorf("DeleteMapping(absent) = %v, want ErrMappingNotFound", err)
}
}
// The Notify callback is an injected seam, not a LISTEN/NOTIFY path: a store
// wired with one fires a change event per successful bindings/mappings write,
// and one wired with none is a silent no-op.
func TestNotifyCallbackIsAnInjectedSeam(t *testing.T) {
s := edaFor(t)
var got []events.Event
s.SetNotify(func(e events.Event) { got = append(got, e) })
id, err := s.InsertMapping(t.Context(), mapping.Mapping{Name: "wired"})
if err != nil {
t.Fatalf("InsertMapping() error = %v", err)
}
if len(got) != 1 {
t.Fatalf("notified %d times, want 1", len(got))
}
if got[0].Data["id"] != id || got[0].Data["action"] != "create" {
t.Errorf("event data = %+v, want id=%q action=create", got[0].Data, id)
}
// A store composed without a notifier is a silent no-op.
s.SetNotify(nil)
if _, err := s.InsertMapping(t.Context(), mapping.Mapping{Name: "silent"}); err != nil {
t.Fatalf("InsertMapping(nil notifier) error = %v", err)
}
}
// tool_calls is an append-only transcript with no unique index: repeated rows
// are distinct entries, and one task's calls never surface in another's.
func TestToolCallRoundTrip(t *testing.T) {
s := edaFor(t)
at := time.Date(2026, 9, 23, 1, 2, 3, 0, time.UTC)
for range 2 {
if err := s.InsertToolCall(t.Context(), ToolCall{
TaskID: 42, Attempt: 2, Tool: "shell", Result: "all checks passed", CalledAt: at,
}); err != nil {
t.Fatalf("InsertToolCall() error = %v", err)
}
}
if err := s.InsertToolCall(t.Context(), ToolCall{
TaskID: 7, Attempt: 1, Tool: "read_file", Error: "no such file", CalledAt: at.Add(time.Second),
}); err != nil {
t.Fatalf("InsertToolCall(other task) error = %v", err)
}
got, err := s.TaskToolCalls(t.Context(), 42)
if err != nil {
t.Fatalf("TaskToolCalls() error = %v", err)
}
if len(got) != 2 {
t.Fatalf("TaskToolCalls() returned %d rows, want 2 (the transcript is append-only)", len(got))
}
if got[0].Result != "all checks passed" || got[0].Error != "" {
t.Errorf("first row result/error = %q/%q, want the summary with no error", got[0].Result, got[0].Error)
}
if got[0].CalledAt.IsZero() {
t.Error("called_at did not round-trip")
}
}