Files
archie/internal/domain/binding/binding_test.go
T
sam ed1557c12e feat(edastore)!: move event capture and bindings onto PocketBase collections
The event-capture tables (captures, mappings, bindings, binding_dispatches,
playbook_dispatches) now live in PocketBase-owned collections and their ids
are opaque record ids rather than autoincrement integers. The task lifecycle
stays on SQLite: tasks/transitions/events carry FIFO claim ordering, id-cursor
pagination and the task-grant map, none of which gain anything from being
hand-editable. binding_dispatches.task_id is the single seam and stays an
integer addressing that store.

BREAKING: CapturedEvent.Id, Mapping.Id, Binding.Id and Binding.MappingId are
strings on the wire, as are the ids in the capture/mapping/binding requests.
RecordDispatchRequest.task_id is deliberately unchanged.

What the collections buy, beyond storage: a payload nobody has modelled yet is
inspectable, a mapping is editable at runtime, and a binding's relation to its
mapping is enforced. The old schema declared no FOREIGN KEY on that link, so a
dangling mapping_id was previously possible and is now refused.

Behaviour preserved deliberately, each recovered from the SQLite version
rather than reimplemented from memory:
  - draft -> pending_approval -> armed, with approval only from
    pending_approval and an edit always returning a binding for re-approval
  - one binding per source, guarded on insert, update and approve
  - an empty secret on update keeps the stored one, so an edit form that does
    not echo it back cannot silently disarm a binding
  - ErrMappingNotFound / ErrBindingNotFound on a missing delete target
  - sentinels are re-exported from storecontract, never redefined: staterpc
    matches on exact canonical message to rehydrate them, so a second
    definition would break errors.Is across the wire invisibly

Two implementation notes worth keeping:
  - at-most-once dispatch is now a unique index rather than INSERT OR IGNORE.
    Only the unique-violation maps to ErrAlreadyDispatched; any other save
    error is returned, because treating them all as "already recorded" would
    turn the ledger into a silent at-least-once dispatcher.
  - captures store received_at themselves at nanosecond precision in a
    fixed-width layout. PocketBase autodates are millisecond and record ids
    are random, so same-millisecond captures would otherwise order
    arbitrarily; the old store got insertion order free from autoincrement.
  - ListUndispatchedCaptures is raw SQL: the anti-join is a subquery and
    PocketBase's filter DSL is not SQL. A read fires no hooks either way.

Adds tool_calls, which had no persistence at all: tool calls only ever reached
the on-disk task log, readable as text but never queryable or watchable.
Nothing writes it yet.

The binding secret cipher moves with the bindings it protects.
2026-09-23 02:19:28 +10:00

95 lines
3.2 KiB
Go

package binding
import "testing"
func validBinding() Binding {
return Binding{
Name: "sentry alerts",
Matcher: Matcher{Source: "sentry"},
MappingID: "m1",
Workflow: "implement",
Secret: "0123456789abcdef0123456789abcdef",
}
}
// TestValidateAcceptsNoRepoPin pins backward compatibility: a binding
// with neither Owner nor Repo set (today's only shape) must remain
// valid -- resolveBindingRepo's single-configured-repo fallback still
// applies to it.
func TestValidateAcceptsNoRepoPin(t *testing.T) {
b := validBinding()
if err := b.Validate(); err != nil {
t.Fatalf("Validate() = %v, want nil", err)
}
}
// TestValidateAcceptsBothOwnerAndRepo is the multi-repo fix: a binding
// naming a specific owner/repo must be accepted.
func TestValidateAcceptsBothOwnerAndRepo(t *testing.T) {
b := validBinding()
b.Owner, b.Repo = "acme", "widget"
if err := b.Validate(); err != nil {
t.Fatalf("Validate() = %v, want nil", err)
}
}
// TestValidateRejectsPartialRepoPin: Owner and Repo are a pair. A
// binding naming only one of them is ambiguous -- it isn't "no pin"
// (that's both empty) and it isn't a complete pin, so it must be
// rejected at validation time rather than silently guessing which
// half was meant.
// TestValidateForUpdateAcceptsEmptySecret is the fix for a real bug found
// via browser testing (t2db.8): UpdateBinding's own documented contract
// treats an empty Secret as "preserve the existing one" (COALESCE against
// NULLIF), but the API handler validated with the create-time Validate,
// which rejected any edit that didn't retype the full secret -- making
// the store's own documented behavior unreachable.
func TestValidateForUpdateAcceptsEmptySecret(t *testing.T) {
b := validBinding()
b.Secret = ""
if err := b.ValidateForUpdate(); err != nil {
t.Fatalf("ValidateForUpdate() = %v, want nil for an empty (preserve-existing) secret", err)
}
}
// TestValidateForUpdateStillEnforcesLengthOnANewSecret confirms the fix
// isn't a blanket bypass: a genuinely-supplied short secret on update is
// still rejected, same floor as create.
func TestValidateForUpdateStillEnforcesLengthOnANewSecret(t *testing.T) {
b := validBinding()
b.Secret = "short"
if err := b.ValidateForUpdate(); err == nil {
t.Fatal("ValidateForUpdate() = nil, want error for a too-short (but non-empty) secret")
}
}
// TestValidateRejectsEmptySecretOnCreate pins that the fix is scoped to
// update only -- Validate (used at create time, where there is no
// existing secret to fall back to) still requires a real one.
func TestValidateRejectsEmptySecretOnCreate(t *testing.T) {
b := validBinding()
b.Secret = ""
if err := b.Validate(); err == nil {
t.Fatal("Validate() = nil, want error for an empty secret at create time")
}
}
func TestValidateRejectsPartialRepoPin(t *testing.T) {
tests := []struct {
name string
owner, repo string
}{
{"owner only", "acme", ""},
{"repo only", "", "widget"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
b := validBinding()
b.Owner, b.Repo = tt.owner, tt.repo
if err := b.Validate(); err == nil {
t.Fatalf("Validate() = nil, want error for partial owner/repo pin (owner=%q repo=%q)", tt.owner, tt.repo)
}
})
}
}