Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

4.3 KB
Raw Blame
package maskrec

import (
	"fmt"
	"math/rand/v2"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"
)

// The body a request went with is kept in memory for the latest keepSent
// requests only, never on disk, and not past sentMax; what the answer put
// back is memory's too, added to as it is told.
func TestSentAndBackInMemory(t *testing.T) {
	now := time.Date(2026, 10, 24, 9, 0, 0, 0, time.Local)
	dir := sandbox(t, now)
	const p = "{{API_KEY_ccccdddd}}"
	body := `{"messages":[{"role":"user","content":"key ` + p + ` here"}]}`
	first := Add(Record{Time: now, What: "chat", N: 1, Took: 812, Sent: body,
		Values: []Value{{Placeholder: p, Kind: "API_KEY", By: "rule", Head: "sk-", Len: 40}}})
	if first.Sent != "" {
		t.Fatal("Add handed the body back")
	}
	if got, ok := SentOf(first.Key); !ok || got != body {
		t.Fatalf("SentOf: %q %v", got, ok)
	}
	Restored(first.Key, map[string]int{p: 2})
	Restored(first.Key, map[string]int{p: 1})
	got, ok := Get(first.Key)
	if !ok || got.Back[p] != 3 || got.Took != 812 || got.Sent != "" {
		t.Fatalf("Get: %+v", got)
	}
	b, err := os.ReadFile(filepath.Join(dir, "2026-10-24.jsonl"))
	if err != nil {
		t.Fatal(err)
	}
	if strings.Contains(string(b), "here") || strings.Contains(string(b), `"back"`) || !strings.Contains(string(b), `"took":812`) {
		t.Fatalf("disk: %s", b)
	}

	// too large: the record is kept, its body isn't
	big := Add(Record{Time: now, What: "chat", N: 1, Sent: strings.Repeat("x", sentMax+1),
		Values: []Value{{Placeholder: p, Kind: "API_KEY", By: "rule", Len: 40}}})
	if _, ok := SentOf(big.Key); ok {
		t.Fatal("a body over sentMax was kept")
	}
	// keepSent more: the first's body goes, its record and snips stay
	for range keepSent {
		Add(Record{Time: now, What: "chat", N: 1, Sent: body,
			Values: []Value{{Placeholder: p, Kind: "API_KEY", By: "rule", Len: 40}}})
	}
	if _, ok := SentOf(first.Key); ok {
		t.Fatal("the oldest body outlived keepSent")
	}
	if got, ok := Get(first.Key); !ok || got.Back[p] != 3 {
		t.Fatalf("the record went with its body: %+v %v", got, ok)
	}
	store.mu.Lock()
	n := len(store.sent)
	for _, r := range store.snips {
		if r.Sent != "" {
			t.Fatal("a record in memory holds its body whole")
		}
	}
	store.mu.Unlock()
	if n != keepSent {
		t.Fatalf("%d bodies kept, want %d", n, keepSent)
	}
	// sentBudget in all, as stored: the oldest go first. Random bytes
	// don't compress, so each takes about sentMax.
	sandbox(t, now)
	rnd := rand.New(rand.NewPCG(1, 2))
	var keys []int64
	for range 20 {
		raw := make([]byte, sentMax)
		for i := range raw {
			raw[i] = byte(rnd.Uint32())
		}
		r := Add(Record{Time: now, What: "chat", N: 1, Sent: string(raw),
			Values: []Value{{Placeholder: p, Kind: "API_KEY", By: "rule", Len: 40}}})
		keys = append(keys, r.Key)
	}
	store.mu.Lock()
	n, stored := len(store.sent), store.sentBytes
	store.mu.Unlock()
	if stored > sentBudget || n < sentBudget/sentMax-1 || n > sentBudget/sentMax {
		t.Fatalf("%d bodies of %d bytes kept, budget %d", n, stored, sentBudget)
	}
	if _, ok := SentOf(keys[len(keys)-n-1]); ok {
		t.Fatal("bodies over sentBudget kept")
	}
	if _, ok := SentOf(keys[len(keys)-n]); !ok {
		t.Fatal("a body within sentBudget dropped")
	}
	// a key nobody has
	Restored(12345, map[string]int{p: 1})
	if _, ok := SentOf(12345); ok {
		t.Fatal("SentOf an unknown key")
	}
}

// A request is JSON that repeats itself: memory keeps it compressed, a
// tenth of its size or less, and hands it back whole (#2278).
func TestSentKeptCompressed(t *testing.T) {
	now := time.Date(2026, 10, 24, 9, 0, 0, 0, time.Local)
	sandbox(t, now)
	const p = "{{API_KEY_ccccdddd}}"
	var b strings.Builder
	b.WriteString(`{"model":"gpt-6.1-sol","input":[`)
	for i := 0; b.Len() < 1<<20; i++ {
		fmt.Fprintf(&b, `{"type":"function_call_output","call_id":"call_%d","output":"line %d of the build log, key %s, ok\\n"},`, i, i*7, p)
	}
	b.WriteString(`{"role":"user","content":"go on"}]}`)
	body := b.String()
	r := Add(Record{Time: now, What: "chat", N: 1, Sent: body,
		Values: []Value{{Placeholder: p, Kind: "API_KEY", By: "rule", Len: 40}}})
	store.mu.Lock()
	stored := store.sentBytes
	store.mu.Unlock()
	if stored == 0 || stored > len(body)/10 {
		t.Fatalf("a %d-byte request is kept in %d bytes", len(body), stored)
	}
	if got, ok := SentOf(r.Key); !ok || got != body {
		t.Fatalf("SentOf: %d bytes, %v; want %d", len(got), ok, len(body))
	}
}