Files
llmgw/internal/store/claims_test.go
T
Ilker ManapandClaude Opus 5 ccc9aa8b76
CI / test (push) Successful in 2m30s
Route every query through a dialect, before there is a second one
Groundwork for PostgreSQL, with no PostgreSQL in it yet: the store still opens
SQLite and behaves exactly as it did.

One set of queries rather than one per database. The SQL here is almost
entirely portable — ON CONFLICT upserts work in both, and the only construct
that genuinely differs is the placeholder — so two copies of every query would
buy nothing and drift, one query at a time, discovered in production.

The rewrite is a wrapper around the handle rather than a change at each call
site. There are sixty of those and sixty chances to forget one; this way the
only route to the driver goes through the rewrite. Making it a wrapper found
six places that reached past it, including all three manual transactions and
two prepared statements — every one of which would have worked on SQLite and
failed on PostgreSQL, on a path nobody exercises before deploying.

The rewriter skips quoted sections. No query here contains a question mark in
a literal today; this is so that adding one is a test failure rather than a
statement that silently binds the wrong argument.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-25 16:10:35 +02:00

212 lines
5.5 KiB
Go

package store
import (
"context"
"errors"
"path/filepath"
"sync"
"testing"
"time"
)
func claimFixture(t *testing.T) (*SQLite, string, string) {
t.Helper()
ctx := context.Background()
s, err := OpenSQLite(ctx, filepath.Join(t.TempDir(), "c.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = s.Close() })
tree(t, s)
secret, k, err := NewKey("key1", "n", "proj1")
if err != nil {
t.Fatal(err)
}
k.CreatedAt = time.Now()
if err := s.CreateKey(ctx, k); err != nil {
t.Fatal(err)
}
token, err := NewClaimToken()
if err != nil {
t.Fatal(err)
}
if err := s.CreateClaim(ctx, k.ID, token, secret, ClaimTTL); err != nil {
t.Fatal(err)
}
return s, token, secret
}
func TestAClaimDeliversTheKeyExactlyOnce(t *testing.T) {
s, token, secret := claimFixture(t)
ctx := context.Background()
if _, err := s.PeekClaim(ctx, token); err != nil {
t.Fatalf("a fresh link is not valid: %v", err)
}
got, err := s.ConsumeClaim(ctx, token)
if err != nil {
t.Fatal(err)
}
if got != secret {
t.Fatal("the delivered key is not the one that was issued")
}
if _, err := s.ConsumeClaim(ctx, token); !errors.Is(err, ErrClaimed) {
t.Errorf("the link worked twice: %v", err)
}
if _, err := s.PeekClaim(ctx, token); !errors.Is(err, ErrClaimed) {
t.Errorf("a used link still looks valid: %v", err)
}
}
func TestTheDatabaseNeverHoldsAUsableKey(t *testing.T) {
// The property that makes a pending claim safe to store at all: what is in
// the table cannot be opened by anything that can read the table.
s, token, secret := claimFixture(t)
var sealed []byte
if err := s.db.QueryRowContext(context.Background(), `SELECT sealed FROM key_claims`).Scan(&sealed); err != nil {
t.Fatal(err)
}
if len(sealed) == 0 {
t.Fatal("nothing was stored")
}
if string(sealed) == secret {
t.Fatal("the key is sitting in the database in the clear")
}
// And the token itself is not there either, so nothing in the database can
// derive the key that opens it.
var count int
if err := s.db.QueryRowContext(context.Background(), `SELECT COUNT(*) FROM key_claims WHERE token_hash = ?`, []byte(token)).
Scan(&count); err != nil {
t.Fatal(err)
}
if count != 0 {
t.Fatal("the claim token was stored, not just its hash")
}
if _, err := open("wrong token entirely", sealed); !errors.Is(err, ErrSealed) {
t.Errorf("a wrong token opened the blob: %v", err)
}
}
func TestAClaimedLinkLeavesNothingBehind(t *testing.T) {
s, token, _ := claimFixture(t)
if _, err := s.ConsumeClaim(context.Background(), token); err != nil {
t.Fatal(err)
}
var sealed []byte
if err := s.db.QueryRowContext(context.Background(), `SELECT sealed FROM key_claims`).Scan(&sealed); err != nil {
t.Fatal(err)
}
if len(sealed) != 0 {
t.Errorf("a used claim still holds %d bytes", len(sealed))
}
}
func TestOnlyOneOfTwoSimultaneousClaimsWins(t *testing.T) {
// Two people opening the same link at the same moment must produce one key,
// not two copies of it.
s, token, _ := claimFixture(t)
var wg sync.WaitGroup
var mu sync.Mutex
won := 0
for range 16 {
wg.Add(1)
go func() {
defer wg.Done()
if _, err := s.ConsumeClaim(context.Background(), token); err == nil {
mu.Lock()
won++
mu.Unlock()
}
}()
}
wg.Wait()
if won != 1 {
t.Errorf("%d callers each received the key", won)
}
}
func TestAnExpiredLinkIsRefused(t *testing.T) {
ctx := context.Background()
s, err := OpenSQLite(ctx, filepath.Join(t.TempDir(), "c.db"))
if err != nil {
t.Fatal(err)
}
defer s.Close()
tree(t, s)
secret, k, _ := NewKey("key1", "n", "proj1")
k.CreatedAt = time.Now()
must(t, s.CreateKey(ctx, k))
token, _ := NewClaimToken()
must(t, s.CreateClaim(ctx, k.ID, token, secret, ClaimTTL))
// Age it directly. CreateClaim treats a non-positive TTL as "use the
// default", which is the right thing for a caller and no way to build the
// row this test needs.
if _, err := s.db.ExecContext(context.Background(), `UPDATE key_claims SET expires_at = ?`,
time.Now().Add(-time.Hour).UnixMilli()); err != nil {
t.Fatal(err)
}
if _, err := s.PeekClaim(ctx, token); !errors.Is(err, ErrClaimed) {
t.Errorf("an expired link looks valid: %v", err)
}
if _, err := s.ConsumeClaim(ctx, token); !errors.Is(err, ErrClaimed) {
t.Errorf("an expired link delivered a key: %v", err)
}
}
func TestAnUnknownLinkLooksLikeAUsedOne(t *testing.T) {
// Distinguishing them would confirm that a token was once valid.
s, token, _ := claimFixture(t)
ctx := context.Background()
must(t, func() error { _, err := s.ConsumeClaim(ctx, token); return err }())
unknown, _ := NewClaimToken()
_, usedErr := s.PeekClaim(ctx, token)
_, unknownErr := s.PeekClaim(ctx, unknown)
if usedErr.Error() != unknownErr.Error() {
t.Errorf("used says %q, unknown says %q", usedErr, unknownErr)
}
}
func TestPurgeRemovesWhatCannotBeUsed(t *testing.T) {
s, token, _ := claimFixture(t)
ctx := context.Background()
must(t, func() error { _, err := s.ConsumeClaim(ctx, token); return err }())
n, err := s.PurgeClaims(ctx, time.Now())
if err != nil {
t.Fatal(err)
}
if n != 1 {
t.Errorf("purged %d rows", n)
}
}
func TestSealRoundTrips(t *testing.T) {
token, _ := NewClaimToken()
sealed, err := seal(token, []byte("sk-llmgw-secret"))
if err != nil {
t.Fatal(err)
}
got, err := open(token, sealed)
if err != nil {
t.Fatal(err)
}
if string(got) != "sk-llmgw-secret" {
t.Errorf("round trip gave %q", got)
}
// Tampering must fail rather than produce something.
sealed[len(sealed)-1] ^= 0xff
if _, err := open(token, sealed); !errors.Is(err, ErrSealed) {
t.Errorf("a tampered blob opened: %v", err)
}
}