Files
archie/modules/approvals/approvals_test.go
T
samandCopilot 64dfad6d53 feat(runs): add typed results and model aliases (#2043)
Also fix repository-free message.send validation (#2046) and add a single-binary development smoke path (#1977).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-18 23:47:35 +11:00

96 lines
4.6 KiB
Go

package approvals
import (
"context"
"errors"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/modules/approvals/internal/store"
"github.com/samcharles93/archie-core/modules/governance"
"github.com/samcharles93/archie-core/modules/judgement"
)
type fakePeople map[string]governance.Verified
func (f fakePeople) Verify(_ context.Context, identity string) (governance.Verified, bool, error) {
p, ok := f[identity]
return p, ok, nil
}
// TestVerifyAcceptsAnAnswerOnlyFromAPersonWhoMayGiveIt checks that a verified
// identity alone is not enough: the request kind, escalation step and required
// authority also determine who can respond.
func TestVerifyAcceptsAnAnswerOnlyFromAPersonWhoMayGiveIt(t *testing.T) {
people := fakePeople{
"telegram:1001": {ID: "owner", Name: "Owner", Approver: true},
"telegram:1002": {ID: "lead", Name: "Authority", Approver: true, Authority: true},
"telegram:1003": {ID: "bystander", Name: "Bystander"},
"telegram:1004": {ID: "second", Name: "Second", Approver: true},
}
action := func(level string, asked ...string) store.Request {
return store.Request{Kind: KindAction, Level: level, Asked: `["` + strings.Join(asked, `","`) + `"]`}
}
propose, escalate := judgement.ProposeAndWait.String(), judgement.Escalate.String()
tests := []struct {
name string
identity string
row store.Request
wantErr error
}{
{name: "an approver can respond once notified", identity: "telegram:1001", row: action(propose, "owner")},
{name: "an unmapped identity is refused", identity: "telegram:9999", row: action(propose, "owner"), wantErr: ErrUnverified},
{name: "an unmapped identity can't answer a raise", identity: "telegram:9999", row: store.Request{Kind: KindRaise}, wantErr: ErrUnverified},
{name: "an unlisted person who isn't an approver cannot respond", identity: "telegram:1003", row: action(propose, "owner"), wantErr: ErrNotApprover},
{name: "the target owner can respond when explicitly asked", identity: "telegram:1003", row: action(propose, "bystander")},
{name: "an approver without authority cannot respond to a raise", identity: "telegram:1001", row: store.Request{Kind: KindRaise}, wantErr: ErrNoAuthority},
{name: "a person with authority can respond to a raise", identity: "telegram:1002", row: store.Request{Kind: KindRaise}},
{name: "a later approver cannot respond before escalation", identity: "telegram:1004", row: action(propose, "owner"), wantErr: ErrNotAsked},
{name: "a later approver can respond after escalation", identity: "telegram:1004", row: action(propose, "owner", "second")},
{name: "a person with authority can respond without being asked", identity: "telegram:1002", row: action(propose, "owner")},
{name: "the escalate level requires authority even when the approver was asked", identity: "telegram:1001", row: action(escalate, "owner"), wantErr: ErrNeedsAuthority},
{name: "a person with authority can respond at the escalate level", identity: "telegram:1002", row: action(escalate, "owner")},
}
m := &Module{people: people}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
_, err := m.verify(context.Background(), tt.identity, tt.row)
if !errors.Is(err, tt.wantErr) {
t.Fatalf("err = %v, want %v", err, tt.wantErr)
}
if tt.wantErr != nil && !refusal(err) {
t.Fatalf("%v isn't recorded as a refusal", err)
}
})
}
}
// TestSettleableRefusesASecondAnswerOrALateOne checks that a settled request or
// one at its deadline cannot accept a response.
func TestSettleableRefusesASecondAnswerOrALateOne(t *testing.T) {
deadline := time.Date(2026, 11, 16, 12, 0, 0, 0, time.UTC)
request := func(state string) store.Request {
return store.Request{State: state, Deadline: deadline}
}
tests := []struct {
name string
row store.Request
now time.Time
wantErr error
}{
{name: "a pending request accepts a response before the deadline", row: request(StatePending), now: deadline.Add(-time.Minute)},
{name: "a pending request rejects a response at the deadline", row: request(StatePending), now: deadline, wantErr: ErrExpired},
{name: "an approved request doesn't settle again", row: request(StateApproved), now: deadline.Add(-time.Minute), wantErr: ErrAnswered},
{name: "a denied request doesn't settle again", row: request(StateDenied), now: deadline.Add(-time.Minute), wantErr: ErrAnswered},
{name: "an expired request doesn't settle", row: request(StateExpired), now: deadline.Add(-time.Minute), wantErr: ErrAnswered},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := settleable(tt.row, tt.now); !errors.Is(err, tt.wantErr) {
t.Fatalf("err = %v, want %v", err, tt.wantErr)
}
})
}
}