Files
archie/modules/events/access_test.go
T
sam 61f576a25c feat(events): capture, event types, mappings and trigger approval on the binary (#2062, #2098)
Event types, field mappings and the stored-delivery inspector move into
modules/events: copied from internal/domain/eventtype and
internal/domain/mapping, which the old services still import. Each stored
event records how its delivery was verified; a source that checks nothing
refuses deliveries until approved; triggers gain approve, pause, resume,
event-type and mapping binding, dispatch history and delete. The captures,
mappings and bindings sections are reported as served.
2026-11-22 11:39:46 +11:00

166 lines
6.9 KiB
Go

package events
import (
"context"
"errors"
"io"
"log/slog"
"net/http"
"net/http/httptest"
"slices"
"strings"
"testing"
"github.com/google/uuid"
"github.com/samcharles93/archie-core/internal/platform/httpjson"
"github.com/samcharles93/archie-core/modules/connectors"
"github.com/samcharles93/archie-core/modules/events/internal/store"
"github.com/samcharles93/archie-core/modules/governance"
"github.com/samcharles93/archie-core/modules/runs"
)
// deliveryPolicy answers every delivery with one decision and records who
// asked.
type deliveryPolicy struct {
decision governance.Decision
asked []string
}
func (d *deliveryPolicy) AuthorizeDelivery(_ context.Context, org governance.OrgID, source, addr string) governance.Decision {
d.asked = append(d.asked, string(org)+" "+source+" "+addr)
return d.decision
}
// onceInserter stores an event once per source event id, as the table's
// uniqueness constraint does.
type onceInserter struct{ stored map[string]bool }
func (o *onceInserter) Insert(_ context.Context, e store.Event) (bool, error) {
if o.stored[e.SourceEventID] {
return false, nil
}
o.stored[e.SourceEventID] = true
return true, nil
}
type noEcho struct{}
func (noEcho) SentBy(context.Context, string, ...string) (uuid.UUID, bool, error) {
return uuid.Nil, false, nil
}
func (noEcho) Send(context.Context, string, string, string, string) error { return nil }
// TestIntakeAppliesTheDeliveryPolicyBeforeStoring guards the webhook entry
// point: a delivery that passes source verification is still refused when the
// per-source, per-address delivery policy denies it or can't be read, and
// nothing is parsed or stored then. A redelivery of a stored event id is
// counted as a duplicate and stored once, so it can't dispatch again.
func TestIntakeAppliesTheDeliveryPolicyBeforeStoring(t *testing.T) {
const token = "not-a-real-token" //nolint:gosec // fixture bearer token the verifier must accept
denied := governance.DeniedAt(governance.LevelObject, []string{"hook-allowlist"})
tests := []struct {
name string
bearer string
policy governance.Decision
unwired bool
deliveries int
want int
wantBody string
wantStored int
wantAsked []string
}{
{name: "an allowed delivery is stored", bearer: token, policy: governance.Allowed(), deliveries: 1, want: http.StatusAccepted, wantBody: `"stored":1`, wantStored: 1, wantAsked: []string{"org-sys hook 203.0.113.9"}},
{name: "a redelivered event id is counted, not stored again", bearer: token, policy: governance.Allowed(), deliveries: 2, want: http.StatusAccepted, wantBody: `"duplicates":1`, wantStored: 1, wantAsked: []string{"org-sys hook 203.0.113.9", "org-sys hook 203.0.113.9"}},
{name: "a valid token with a denying policy", bearer: token, policy: denied, deliveries: 1, want: http.StatusForbidden, wantAsked: []string{"org-sys hook 203.0.113.9"}},
{name: "a valid token while the chain is unavailable", bearer: token, policy: governance.Unavailable(), deliveries: 1, want: http.StatusServiceUnavailable, wantAsked: []string{"org-sys hook 203.0.113.9"}},
{name: "a valid token with no policy wired", bearer: token, unwired: true, deliveries: 1, want: http.StatusServiceUnavailable},
{name: "a wrong token never reaches the policy", bearer: "other", policy: governance.Allowed(), deliveries: 1, want: http.StatusUnauthorized},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
policy := &deliveryPolicy{decision: tt.policy}
inserter := &onceInserter{stored: map[string]bool{}}
m := &Module{
orgID: "default", log: slog.New(slog.DiscardHandler), inserter: inserter, deliveries: noEcho{},
reader: fakeSources{store.Source{OrgID: "default", Name: "hook", Connector: "c", Verification: store.Token, TokenSHA256: httpjson.TokenHash(token)}},
parse: func(context.Context, string, []byte, map[string]string) ([]connectors.Event, error) {
return []connectors.Event{{Type: "alert", SourceEventID: "evt-1"}}, nil
},
}
if !tt.unwired {
m.UseDeliveryPolicy(policy)
}
var rec *httptest.ResponseRecorder
for range tt.deliveries {
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/hooks/hook", strings.NewReader(`{}`))
req.SetPathValue("source", "hook")
req.RemoteAddr = "203.0.113.9:4711"
req.Header.Set("Authorization", "Bearer "+tt.bearer)
rec = httptest.NewRecorder()
m.intake(rec, req)
}
body, _ := io.ReadAll(rec.Body)
if rec.Code != tt.want || !strings.Contains(string(body), tt.wantBody) {
t.Fatalf("status %d body %s, want %d containing %q", rec.Code, body, tt.want, tt.wantBody)
}
if len(inserter.stored) != tt.wantStored {
t.Fatalf("events stored = %d, want %d", len(inserter.stored), tt.wantStored)
}
if !slices.Equal(policy.asked, tt.wantAsked) {
t.Fatalf("delivery policy asked %v, want %v", policy.asked, tt.wantAsked)
}
})
}
}
// startRecorder is the run starter a trigger calls: it records the principal
// each start carried and answers with a fixed error.
type startRecorder struct {
err error
principals []governance.IdentityID
}
func (s *startRecorder) Start(ctx context.Context, _ runs.StartRequest) (uuid.UUID, error) {
p, _ := governance.PrincipalFromContext(ctx)
s.principals = append(s.principals, p.IdentityID)
return uuid.New(), s.err
}
func (*startRecorder) CheckTrigger(context.Context, string, string) error { return nil }
// TestTriggersStartRunsAsTheWorkload guards that dispatching an event never
// starts a run without a principal: the workload principal acts, a refusal
// skips the trigger for good, and a chain that can't decide fails the dispatch
// so the event stays queued instead of being dropped.
func TestTriggersStartRunsAsTheWorkload(t *testing.T) {
tests := []struct {
name string
err error
wantStarted bool
wantErr error
}{
{name: "an allowed start", wantStarted: true},
{name: "a refused start is final", err: governance.ErrDenied},
{name: "an undecidable start is retried", err: governance.ErrChainUnavailable, wantErr: governance.ErrChainUnavailable},
{name: "another failure is retried", err: errors.New("database down"), wantErr: errors.New("database down")},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
starts := &startRecorder{err: tt.err}
m := &Module{runs: starts, log: slog.New(slog.DiscardHandler)}
_, started, err := m.startRun(t.Context(), store.Event{ID: uuid.New(), OrgID: "default"}, store.Trigger{Name: "t", Workflow: "triage"}, nil)
if started != tt.wantStarted {
t.Fatalf("started = %v, want %v", started, tt.wantStarted)
}
if (err == nil) != (tt.wantErr == nil) || (tt.wantErr != nil && !strings.Contains(err.Error(), tt.wantErr.Error())) {
t.Fatalf("error = %v, want %v", err, tt.wantErr)
}
if !slices.Equal(starts.principals, []governance.IdentityID{governance.WorkloadID}) {
t.Fatalf("start acted as %v, want the workload principal", starts.principals)
}
})
}
}