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.
457 lines
13 KiB
Go
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)
|
|
}
|
|
}
|