Files
archie/modules/chat/binding_test.go
T

378 lines
13 KiB
Go

package chat
import (
"context"
"encoding/json"
"encoding/json/jsontext"
"errors"
"log/slog"
"strings"
"testing"
"time"
"github.com/google/uuid"
"github.com/samcharles93/archie-core/internal/platform/hub"
"github.com/samcharles93/archie-core/modules/approvals"
"github.com/samcharles93/archie-core/modules/chat/internal/store"
"github.com/samcharles93/archie-core/modules/connectors"
"github.com/samcharles93/archie-core/modules/deliveries"
"github.com/samcharles93/archie-core/modules/governance"
"github.com/samcharles93/archie-core/modules/judgement"
)
var (
bindTurn = uuid.MustParse("11111111-1111-1111-1111-111111111111")
bindSession = uuid.MustParse("22222222-2222-2222-2222-222222222222")
bindAction = uuid.MustParse("33333333-3333-3333-3333-333333333333")
bindRequest = uuid.MustParse("44444444-4444-4444-4444-444444444444")
bindExpiry = time.Date(2100, 1, 1, 0, 0, 0, 0, time.UTC)
)
func baseBinding() Binding {
return Binding{
ID: bindAction, Org: "default", Session: bindSession, Turn: bindTurn, Owner: alice, Request: bindRequest,
Connector: "mail", Action: "send", Input: connectors.Canonical(jsontext.Value(`{"to":"a@example.com","body":"hi"}`)),
Target: connectors.Target{Kind: "mailbox", ID: "inbox", Environment: "prod"},
Effect: connectors.Effect{Reversibility: connectors.Irreversible, Summary: "sends mail"},
Approvers: []string{alice}, Expires: bindExpiry,
}
}
// TestBindingDigestCoversTheWholeAction guards the time-of-check to
// time-of-use gap: an approval is bound to everything that decides what runs
// and for whom, so a change to any part gives a different digest, a respelling
// of the same arguments does not, and a binding with a part missing has no
// digest at all.
func TestBindingDigestCoversTheWholeAction(t *testing.T) {
base, err := baseBinding().Digest()
if err != nil {
t.Fatal(err)
}
other := uuid.MustParse("99999999-9999-9999-9999-999999999999")
changes := []struct {
name string
change func(*Binding)
}{
{"the action's id", func(b *Binding) { b.ID = other }},
{"the organisation", func(b *Binding) { b.Org = "other" }},
{"the conversation", func(b *Binding) { b.Session = other }},
{"the turn", func(b *Binding) { b.Turn = other }},
{"the owner", func(b *Binding) { b.Owner = bob }},
{"the approval request", func(b *Binding) { b.Request = other }},
{"the connector", func(b *Binding) { b.Connector = "chat" }},
{"the action", func(b *Binding) { b.Action = "forward" }},
{"the arguments", func(b *Binding) { b.Input = jsontext.Value(`{"to":"b@example.com","body":"hi"}`) }},
{"the target's id", func(b *Binding) { b.Target.ID = "outbox" }},
{"a target removed", func(b *Binding) { b.Target = connectors.Target{} }},
{"the target's environment", func(b *Binding) { b.Target.Environment = "dev" }},
{"the effect", func(b *Binding) { b.Effect.Reversibility = connectors.Recoverable }},
{"the approvers", func(b *Binding) { b.Approvers = []string{bob} }},
{"the expiry", func(b *Binding) { b.Expires = bindExpiry.Add(time.Hour) }},
}
for _, tt := range changes {
t.Run("a change to "+tt.name+" changes the digest", func(t *testing.T) {
b := baseBinding()
tt.change(&b)
got, err := b.Digest()
if err != nil {
t.Fatal(err)
}
if got == base {
t.Fatalf("digest is unchanged by a change to %s", tt.name)
}
})
}
t.Run("respelled arguments keep the digest", func(t *testing.T) {
b := baseBinding()
b.Input = connectors.Canonical(jsontext.Value(`{ "body": "hi", "to": "a@example.com" }`))
got, err := b.Digest()
if err != nil || got != base {
t.Fatalf("digest = %q, %v; want %q", got, err, base)
}
})
missing := []struct {
name string
remove func(*Binding)
}{
{"id", func(b *Binding) { b.ID = uuid.Nil }},
{"organisation", func(b *Binding) { b.Org = "" }},
{"conversation", func(b *Binding) { b.Session = uuid.Nil }},
{"turn", func(b *Binding) { b.Turn = uuid.Nil }},
{"owner", func(b *Binding) { b.Owner = "" }},
{"approval request", func(b *Binding) { b.Request = uuid.Nil }},
{"connector", func(b *Binding) { b.Connector = "" }},
{"action", func(b *Binding) { b.Action = "" }},
{"arguments", func(b *Binding) { b.Input = nil }},
{"approvers", func(b *Binding) { b.Approvers = nil }},
{"expiry", func(b *Binding) { b.Expires = time.Time{} }},
}
for _, tt := range missing {
t.Run("a missing "+tt.name+" has no digest", func(t *testing.T) {
b := baseBinding()
tt.remove(&b)
if got, err := b.Digest(); !errors.Is(err, errUnbound) || got != "" {
t.Fatalf("digest = %q, %v; want errUnbound", got, err)
}
})
}
}
// approvalFixture is one approved chat action waiting to run, with the judge,
// approver and store fakes that record what happens to it.
type approvalFixture struct {
m *Module
d Deps
action store.Action
judge *runJudge
approver *runApprover
store *runStore
}
type runJudge struct {
Judge
fresh judgement.Decision
assessed int
executed []string
}
func (j *runJudge) Assess(context.Context, judgement.Request) (judgement.Decision, error) {
j.assessed++
return j.fresh, nil
}
func (j *runJudge) Execute(_ context.Context, _ judgement.Decision, _ jsontext.Value, _ string) (string, error) {
j.executed = append(j.executed, "execute")
return "ran", nil
}
func (j *runJudge) ExecuteApproved(_ context.Context, _ judgement.Decision, _ judgement.Approval, _ jsontext.Value, _ string) (string, error) {
j.executed = append(j.executed, "execute approved")
return "ran", nil
}
type runApprover struct {
Approver
discarded []string
accepted int
}
func (a *runApprover) Discard(_ context.Context, _ uuid.UUID, because string) error {
a.discarded = append(a.discarded, because)
return nil
}
func (a *runApprover) Accept(context.Context, uuid.UUID) error { a.accepted++; return nil }
type runSettings struct {
Settings
path []governance.PathStep
err error
}
func (s runSettings) EscalationPath(context.Context, string, bool) ([]governance.PathStep, error) {
return s.path, s.err
}
type runNotifier struct{}
func (runNotifier) Notify(context.Context, deliveries.Notification) error { return nil }
// runStore moves an action only from the state it is in, as the SQL does.
type runStore struct {
*fakeStore
state string
moves []string
}
func (s *runStore) Move(_ context.Context, _ uuid.UUID, from, to, _ string) (bool, error) {
if s.state != from {
return false, nil
}
s.state = to
s.moves = append(s.moves, to)
return true, nil
}
func heldDecision() judgement.Decision {
input := jsontext.Value(`{"to":"a@example.com","body":"hi"}`)
return judgement.Decision{
ID: uuid.New(), Key: "k", Level: judgement.ProposeAndWait,
Action: judgement.Action{
Connector: "mail", Name: "send", Input: input, Digest: connectors.Digest("send", input),
Target: connectors.Target{Kind: "mailbox", ID: "inbox", Environment: "prod"},
Effect: connectors.Effect{Reversibility: connectors.Irreversible, Summary: "sends mail"},
},
}
}
func newApprovalFixture(t *testing.T) *approvalFixture {
t.Helper()
held := heldDecision()
binding := baseBinding()
digest, err := binding.Digest()
if err != nil {
t.Fatal(err)
}
rawBinding, _ := json.Marshal(binding)
rawDecision, _ := json.Marshal(held)
rawAnswer, _ := json.Marshal(approvals.Answer{RequestID: bindRequest, Approved: true, By: "alice", At: bindExpiry.Add(-time.Hour)})
f := &approvalFixture{
action: store.Action{
ID: bindAction, TurnID: bindTurn, Owner: alice, Key: "approval:k", Decision: rawDecision, RequestID: bindRequest,
State: actionApproved, Answer: rawAnswer, Binding: rawBinding, BindingDigest: digest,
},
judge: &runJudge{fresh: held},
approver: &runApprover{},
}
f.store = &runStore{fakeStore: &fakeStore{}, state: actionApproved}
f.m = &Module{orgID: "default", store: f.store, log: slog.New(slog.DiscardHandler), hub: hub.New()}
f.d = Deps{
People: fakePeople{alice: person(alice, governance.RoleAdmin)},
Access: governance.NewEngine(governance.ShippedOrgPolicies(governance.DefaultOrgID)),
Settings: runSettings{path: []governance.PathStep{{Person: alice}}},
Judge: f.judge, Approver: f.approver, Notifier: runNotifier{},
}
return f
}
// TestRunApprovedRunsOnlyWhatWasApprovedAndOnlyOnce guards the dispatch-time
// recheck: an approval is discarded, and nothing runs, when the owner has lost
// access, when the target, effect, arguments or approvers changed, when the
// binding is missing, altered or expired, or when the answer belongs to
// another request. An action that still matches runs exactly once.
func TestRunApprovedRunsOnlyWhatWasApprovedAndOnlyOnce(t *testing.T) {
tests := []struct {
name string
change func(*approvalFixture)
wantRuns int
wantDiscard string
}{
{name: "an action that still matches runs", wantRuns: 1},
{
name: "the owner's access revoked while pending",
change: func(f *approvalFixture) { f.d.People = fakePeople{alice: person(alice, governance.RoleViewer)} },
wantDiscard: "you may not run connector mail",
},
{
name: "the target changed while pending",
change: func(f *approvalFixture) {
f.judge.fresh.Action.Target = connectors.Target{Kind: "mailbox", ID: "outbox", Environment: "prod"}
},
wantDiscard: "its target changed",
},
{
name: "a target appeared where there was none",
change: func(f *approvalFixture) {
b := baseBinding()
b.Target = connectors.Target{}
f.action.Binding, _ = json.Marshal(b)
f.action.BindingDigest, _ = b.Digest()
},
wantDiscard: "its target changed",
},
{
name: "the target changed and would now run unattended",
change: func(f *approvalFixture) {
f.judge.fresh.Action.Target.ID = "outbox"
f.judge.fresh.Level = judgement.ActQuietly
},
wantDiscard: "its target changed",
},
{
name: "the effect changed while pending",
change: func(f *approvalFixture) {
f.judge.fresh.Action.Effect.Summary = "deletes the mailbox"
},
wantDiscard: "its effect changed",
},
{
name: "the approvers changed while pending",
change: func(f *approvalFixture) {
f.d.Settings = runSettings{path: []governance.PathStep{{Person: bob}}}
},
wantDiscard: "the people who may approve it changed",
},
{
name: "the action is now refused",
change: func(f *approvalFixture) { f.judge.fresh.Level, f.judge.fresh.Reason = judgement.Never, "blackout" },
wantDiscard: "it is now refused",
},
{
name: "judgement is now stricter",
change: func(f *approvalFixture) { f.judge.fresh.Level = judgement.Escalate },
wantDiscard: "judgement is stricter",
},
{
name: "the stored binding was altered",
change: func(f *approvalFixture) { f.action.BindingDigest = strings.Repeat("0", 64) },
wantDiscard: "binding is incomplete or was altered",
},
{
name: "an action held before bindings existed",
change: func(f *approvalFixture) {
f.action.Binding, f.action.BindingDigest = nil, ""
},
wantDiscard: "carries no binding",
},
{
name: "the answer belongs to another request",
change: func(f *approvalFixture) {
f.action.Answer, _ = json.Marshal(approvals.Answer{RequestID: uuid.New(), Approved: true})
},
wantDiscard: "another request",
},
{
name: "the binding expired",
change: func(f *approvalFixture) {
b := baseBinding()
b.Expires = time.Now().Add(-time.Minute)
f.action.Binding, _ = json.Marshal(b)
f.action.BindingDigest, _ = b.Digest()
},
wantDiscard: "it expired",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := newApprovalFixture(t)
if tt.change != nil {
tt.change(f)
}
if err := f.m.runApproved(t.Context(), f.d, f.action); err != nil {
t.Fatal(err)
}
if got := len(f.judge.executed); got != tt.wantRuns {
t.Fatalf("ran %d times (%v), want %d", got, f.judge.executed, tt.wantRuns)
}
switch {
case tt.wantDiscard == "" && len(f.approver.discarded) != 0:
t.Fatalf("discarded %v, want the approval kept", f.approver.discarded)
case tt.wantDiscard != "" && (len(f.approver.discarded) != 1 || !strings.Contains(f.approver.discarded[0], tt.wantDiscard)):
t.Fatalf("discarded %v, want one containing %q", f.approver.discarded, tt.wantDiscard)
}
})
}
t.Run("a second pass over the same action runs nothing", func(t *testing.T) {
f := newApprovalFixture(t)
for range 2 {
if err := f.m.runApproved(t.Context(), f.d, f.action); err != nil {
t.Fatal(err)
}
}
if len(f.judge.executed) != 1 {
t.Fatalf("ran %d times, want once", len(f.judge.executed))
}
})
t.Run("who may approve can't be read", func(t *testing.T) {
f := newApprovalFixture(t)
f.d.Settings = runSettings{err: errors.New("settings unavailable")}
if err := f.m.runApproved(t.Context(), f.d, f.action); err != nil {
t.Fatal(err)
}
if len(f.judge.executed) != 0 || len(f.approver.discarded) != 0 {
t.Fatalf("ran %v and discarded %v, want nothing to run and the approval kept", f.judge.executed, f.approver.discarded)
}
})
}