Files
archie/internal/pairing/store_test.go
T
sam f73b2d1c8c feat: memory manager sync/prefetch/scan/shutdown + broad in-flight epic work
Checkpoint commit covering concurrent work across several archie-core-abg
epics to avoid losing in-progress state:

- Memory manager (18.7-18.16): background sync pipeline, prefetch with
  timeout, memory-write notification, threat scanning, shutdown drain
  with abandoned-write tracking, frozen snapshot pattern. Wired
  ScanContent and NotifyMemoryToolWrite into HandleToolCall so scanning
  and notification actually apply to writes, not just exist as unused
  primitives.
- Fixed a literal unresolved merge-conflict that had been committed to
  internal/memory/scrubber/scrubber.go.
- Tool provider/registry, MCP client/transport (stdio, HTTP, SSE),
  multimodal results, disclosure.
- Pairing device auth store, rate limiting.
- Gateway compression, session store, tasks.
- Various workflow, plugin host, and agentexec updates.
2026-07-27 03:34:46 +10:00

457 lines
13 KiB
Go

package pairing
import (
"errors"
"fmt"
"os"
"path/filepath"
"testing"
"time"
)
func newTestStore(t *testing.T) (*Store, *fakeClock) {
t.Helper()
dir := t.TempDir()
s, err := New(dir)
if err != nil {
t.Fatal(err)
}
clock := &fakeClock{t: time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)}
s.now = clock.Now
return s, clock
}
type fakeClock struct{ t time.Time }
func (c *fakeClock) Now() time.Time { return c.t }
func (c *fakeClock) Advance(d time.Duration) { c.t = c.t.Add(d) }
// ── RequestCode ──────────────────────────────────────────────────────
func TestRequestCodeReturnsVerifiableCode(t *testing.T) {
s, _ := newTestStore(t)
code, err := s.RequestCode("user1")
if err != nil {
t.Fatal(err)
}
if len(code) != CodeLength {
t.Errorf("len(code) = %d, want %d", len(code), CodeLength)
}
ok, err := s.VerifyCode("user1", code)
if err != nil {
t.Fatal(err)
}
if !ok {
t.Error("VerifyCode(correct code) = false, want true")
}
}
func TestRequestCodeEnforcesRateLimit(t *testing.T) {
s, clock := newTestStore(t)
if _, err := s.RequestCode("user1"); err != nil {
t.Fatal(err)
}
if _, err := s.RequestCode("user1"); !errors.Is(err, ErrRateLimited) {
t.Fatalf("second immediate request: err = %v, want ErrRateLimited", err)
}
clock.Advance(10*time.Minute + time.Second)
if _, err := s.RequestCode("user1"); err != nil {
t.Fatalf("request after rate limit window: %v", err)
}
}
func TestRequestCodeRateLimitIsPerUser(t *testing.T) {
s, _ := newTestStore(t)
if _, err := s.RequestCode("user1"); err != nil {
t.Fatal(err)
}
if _, err := s.RequestCode("user2"); err != nil {
t.Fatalf("a different user must not be rate limited by user1's request: %v", err)
}
}
func TestRequestCodeEnforcesPlatformWideQuota(t *testing.T) {
s, _ := newTestStore(t)
for i, user := range []string{"user1", "user2", "user3"} {
if _, err := s.RequestCode(user); err != nil {
t.Fatalf("request %d (%s): %v", i, user, err)
}
}
if _, err := s.RequestCode("user4"); !errors.Is(err, ErrQuotaExceeded) {
t.Fatalf("4th pending code: err = %v, want ErrQuotaExceeded", err)
}
}
func TestRequestCodeReplacingOwnPendingCodeDoesNotCountAgainstQuota(t *testing.T) {
s, clock := newTestStore(t)
for _, user := range []string{"user1", "user2", "user3"} {
if _, err := s.RequestCode(user); err != nil {
t.Fatal(err)
}
}
// user1 requests again after their rate limit window -- replacing
// their own pending code, not adding a 4th.
clock.Advance(10*time.Minute + time.Second)
if _, err := s.RequestCode("user1"); err != nil {
t.Fatalf("user1 replacing their own pending code: %v", err)
}
}
func TestRequestCodeExpiredPendingCodesDoNotCountAgainstQuota(t *testing.T) {
s, clock := newTestStore(t)
for _, user := range []string{"user1", "user2", "user3"} {
if _, err := s.RequestCode(user); err != nil {
t.Fatal(err)
}
}
clock.Advance(CodeTTL + time.Second) // all three now expired
if _, err := s.RequestCode("user4"); err != nil {
t.Fatalf("expired pending codes should free up quota: %v", err)
}
}
// ── VerifyCode ───────────────────────────────────────────────────────
func TestVerifyCodeRejectsWrongCode(t *testing.T) {
s, _ := newTestStore(t)
if _, err := s.RequestCode("user1"); err != nil {
t.Fatal(err)
}
ok, err := s.VerifyCode("user1", "WRONGCOD")
if err != nil {
t.Fatal(err)
}
if ok {
t.Error("VerifyCode(wrong code) = true, want false")
}
}
func TestVerifyCodeRejectsUnknownUser(t *testing.T) {
s, _ := newTestStore(t)
ok, err := s.VerifyCode("nobody", "ANYCODE1")
if ok || !errors.Is(err, ErrNoPendingCode) {
t.Errorf("VerifyCode(unknown user) = (%v, %v), want (false, ErrNoPendingCode)", ok, err)
}
}
func TestVerifyCodeRejectsExpiredCode(t *testing.T) {
s, clock := newTestStore(t)
code, err := s.RequestCode("user1")
if err != nil {
t.Fatal(err)
}
clock.Advance(CodeTTL + time.Second)
ok, err := s.VerifyCode("user1", code)
if ok || !errors.Is(err, ErrNoPendingCode) {
t.Errorf("VerifyCode(expired code) = (%v, %v), want (false, ErrNoPendingCode)", ok, err)
}
}
func TestVerifyCodeLocksOutAfterFiveFailures(t *testing.T) {
s, _ := newTestStore(t)
if _, err := s.RequestCode("user1"); err != nil {
t.Fatal(err)
}
for i := range MaxFailures {
ok, err := s.VerifyCode("user1", "WRONGCOD")
if ok {
t.Fatalf("attempt %d: unexpectedly succeeded", i)
}
if i < MaxFailures-1 && errors.Is(err, ErrLockedOut) {
t.Fatalf("attempt %d: locked out too early", i)
}
}
// One more attempt, now locked out, even with the CORRECT code.
code, err := s.RequestCode("user1")
_ = code
if err == nil || !errors.Is(err, ErrLockedOut) {
// user1 is locked out, so even a legitimate new code request
// (or a verify attempt) must be rejected.
t.Fatalf("expected lockout to block further requests, got err = %v", err)
}
}
func TestVerifyCodeEscalatesLockoutDurationOnRepeatOffenses(t *testing.T) {
s, clock := newTestStore(t)
lockOut := func() {
if _, err := s.RequestCode("user1"); err != nil {
t.Fatalf("RequestCode: %v", err)
}
for i := range MaxFailures {
if _, err := s.VerifyCode("user1", "WRONGCOD"); err != nil && !errors.Is(err, ErrLockedOut) {
t.Fatalf("attempt %d: unexpected error %v", i, err)
}
}
}
lockOut()
first := s.limits["user1"].LockedUntil.Sub(clock.Now())
if first != LockoutDuration {
t.Fatalf("1st lockout duration = %v, want %v (base)", first, LockoutDuration)
}
clock.Advance(first + time.Second)
lockOut()
second := s.limits["user1"].LockedUntil.Sub(clock.Now())
if second != 2*LockoutDuration {
t.Fatalf("2nd lockout duration = %v, want %v (2x base)", second, 2*LockoutDuration)
}
clock.Advance(second + time.Second)
lockOut()
third := s.limits["user1"].LockedUntil.Sub(clock.Now())
if third != 4*LockoutDuration {
t.Fatalf("3rd lockout duration = %v, want %v (4x base)", third, 4*LockoutDuration)
}
}
func TestVerifyCodeEscalatedLockoutDurationIsCapped(t *testing.T) {
s, clock := newTestStore(t)
lockOut := func() {
if _, err := s.RequestCode("user1"); err != nil {
t.Fatalf("RequestCode: %v", err)
}
for i := range MaxFailures {
if _, err := s.VerifyCode("user1", "WRONGCOD"); err != nil && !errors.Is(err, ErrLockedOut) {
t.Fatalf("attempt %d: unexpected error %v", i, err)
}
}
}
var last time.Duration
for i := range 10 {
lockOut()
last = s.limits["user1"].LockedUntil.Sub(clock.Now())
if last > MaxLockoutDuration {
t.Fatalf("offense %d: lockout duration %v exceeds cap %v", i, last, MaxLockoutDuration)
}
clock.Advance(last + time.Second)
}
if last != MaxLockoutDuration {
t.Errorf("after repeated offenses, lockout duration = %v, want cap %v", last, MaxLockoutDuration)
}
}
func TestVerifyCodeSuccessResetsLockoutEscalation(t *testing.T) {
s, clock := newTestStore(t)
// Lock out once, then succeed after it expires -- escalation state
// must reset, not carry over into a future unrelated offense.
if _, err := s.RequestCode("user1"); err != nil {
t.Fatal(err)
}
for range MaxFailures {
_, _ = s.VerifyCode("user1", "WRONGCOD")
}
clock.Advance(LockoutDuration + time.Second)
code, err := s.RequestCode("user1")
if err != nil {
t.Fatalf("RequestCode after lockout expired: %v", err)
}
if ok, err := s.VerifyCode("user1", code); err != nil || !ok {
t.Fatalf("VerifyCode(correct code): (%v, %v)", ok, err)
}
if got := s.limits["user1"].LockoutCount; got != 0 {
t.Errorf("LockoutCount after a successful verify = %d, want 0", got)
}
// Offend again from scratch: must be back at the base duration, not
// escalated from the earlier (now-resolved) lockout.
clock.Advance(RateLimitWindow + time.Second)
if _, err := s.RequestCode("user1"); err != nil {
t.Fatal(err)
}
for range MaxFailures {
_, _ = s.VerifyCode("user1", "WRONGCOD")
}
if got := s.limits["user1"].LockedUntil.Sub(clock.Now()); got != LockoutDuration {
t.Errorf("post-reset lockout duration = %v, want base %v", got, LockoutDuration)
}
}
func TestLockoutCountPersistsAcrossStoreReload(t *testing.T) {
dir := t.TempDir()
s1, err := New(dir)
if err != nil {
t.Fatal(err)
}
if _, err := s1.RequestCode("user1"); err != nil {
t.Fatal(err)
}
for range MaxFailures {
if _, err := s1.VerifyCode("user1", "WRONGCOD"); err != nil {
t.Fatal(err)
}
}
want := s1.limits["user1"].LockoutCount
if want == 0 {
t.Fatal("test setup: expected a nonzero LockoutCount after a lockout")
}
s2, err := New(dir)
if err != nil {
t.Fatal(err)
}
if got := s2.limits["user1"].LockoutCount; got != want {
t.Errorf("LockoutCount after reload = %d, want %d (must survive a restart, not reset escalation progress)", got, want)
}
}
func TestVerifyCodeSuccessResetsFailureCount(t *testing.T) {
s, _ := newTestStore(t)
code, err := s.RequestCode("user1")
if err != nil {
t.Fatal(err)
}
// A few failures, but not enough to lock out.
for range MaxFailures - 1 {
if _, err := s.VerifyCode("user1", "WRONGCOD"); err != nil {
t.Fatal(err)
}
}
ok, err := s.VerifyCode("user1", code)
if err != nil || !ok {
t.Fatalf("VerifyCode(correct code) = (%v, %v), want (true, nil)", ok, err)
}
if !s.IsApproved("user1") {
t.Error("user1 should be approved after a successful verify")
}
}
func TestVerifyCodeConsumesPendingCodeOnSuccess(t *testing.T) {
s, _ := newTestStore(t)
code, err := s.RequestCode("user1")
if err != nil {
t.Fatal(err)
}
if ok, err := s.VerifyCode("user1", code); err != nil || !ok {
t.Fatalf("first verify: (%v, %v)", ok, err)
}
// The code must not be usable a second time.
if ok, err := s.VerifyCode("user1", code); ok || !errors.Is(err, ErrNoPendingCode) {
t.Errorf("second verify with the same code: (%v, %v), want (false, ErrNoPendingCode)", ok, err)
}
}
// ── Persistence ──────────────────────────────────────────────────────
func TestStorePersistsAndReloadsApprovedUsers(t *testing.T) {
dir := t.TempDir()
s1, err := New(dir)
if err != nil {
t.Fatal(err)
}
code, err := s1.RequestCode("user1")
if err != nil {
t.Fatal(err)
}
if ok, err := s1.VerifyCode("user1", code); err != nil || !ok {
t.Fatalf("verify: (%v, %v)", ok, err)
}
s2, err := New(dir)
if err != nil {
t.Fatal(err)
}
if !s2.IsApproved("user1") {
t.Error("a freshly loaded Store should see the persisted approval")
}
}
func TestStorePersistsFilesWithExpectedNames(t *testing.T) {
dir := t.TempDir()
s, err := New(dir)
if err != nil {
t.Fatal(err)
}
if _, err := s.RequestCode("user1"); err != nil {
t.Fatal(err)
}
for _, name := range []string{"pending.json", "rate_limits.json"} {
if _, err := os.Stat(filepath.Join(dir, name)); err != nil {
t.Errorf("expected %s to exist: %v", name, err)
}
}
}
func TestNewCreatesDirIfMissing(t *testing.T) {
dir := filepath.Join(t.TempDir(), "nested", "pairing-state")
if _, err := New(dir); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(dir); err != nil {
t.Fatalf("expected directory to be created: %v", err)
}
}
func TestStorePersistsAndReloadsOutstandingPendingCode(t *testing.T) {
dir := t.TempDir()
s1, err := New(dir)
if err != nil {
t.Fatal(err)
}
code, err := s1.RequestCode("user1")
if err != nil {
t.Fatal(err)
}
s2, err := New(dir)
if err != nil {
t.Fatal(err)
}
// The pending code's HashedCode{Salt, Hash []byte} must round-trip
// through JSON (base64) intact, byte for byte, or this fails.
ok, err := s2.VerifyCode("user1", code)
if err != nil {
t.Fatal(err)
}
if !ok {
t.Error("VerifyCode against a reloaded Store's pending code = false, want true")
}
}
// ── Concurrency ──────────────────────────────────────────────────────
func TestConcurrentRequestCodeRespectsQuota(t *testing.T) {
s, _ := newTestStore(t)
const n = 10
results := make(chan error, n)
for i := range n {
go func(i int) {
_, err := s.RequestCode(fmt.Sprintf("user%d", i))
results <- err
}(i)
}
successes := 0
for range n {
if err := <-results; err == nil {
successes++
} else if !errors.Is(err, ErrQuotaExceeded) {
t.Errorf("unexpected error: %v", err)
}
}
if successes != MaxPendingPerPlatform {
t.Errorf("successes = %d, want %d", successes, MaxPendingPerPlatform)
}
if len(s.pending) != MaxPendingPerPlatform {
t.Errorf("len(s.pending) = %d, want %d", len(s.pending), MaxPendingPerPlatform)
}
}