Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
package provider
import (
"context"
"encoding/json"
"errors"
"io"
"net/http"
"net/http/httptest"
"strings"
"sync"
"testing"
"time"
)
// Warm up now sends a ChatGPT account the very request the scheduled
// warm-up sends, to that account alone and with the warm-ups off, and
// says why it failed.
func TestWarmNowSendsTheScheduledWarmUp(t *testing.T) {
signIn(t) // [email protected], acct-1, lists gpt-5.5
rememberLogins(true)
var mu sync.Mutex
var bodies []map[string]any
var hdrs []http.Header
refuse := false
fake := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
mu.Lock()
defer mu.Unlock()
switch r.URL.Path {
case "/backend-api/wham/usage":
// a week that hasn't started: nothing used, its reset a week off
json.NewEncoder(w).Encode(map[string]any{"plan_type": "plus", "rate_limit": map[string]any{
"primary_window": map[string]any{"used_percent": 0, "limit_window_seconds": 18000, "reset_after_seconds": 18000},
"secondary_window": map[string]any{"used_percent": 0, "limit_window_seconds": 604800, "reset_after_seconds": 604800}}})
case "/backend-api/codex/responses":
var m map[string]any
b, _ := io.ReadAll(r.Body)
json.Unmarshal(b, &m)
bodies, hdrs = append(bodies, m), append(hdrs, r.Header.Clone())
if refuse {
w.WriteHeader(http.StatusTooManyRequests)
io.WriteString(w, `{"detail":"usage limit reached"}`)
return
}
w.Header().Set("Content-Type", "text/event-stream")
io.WriteString(w, "event: response.completed\ndata: {\"type\":\"response.completed\"}\n\n")
default:
http.NotFound(w, r)
}
}))
defer fake.Close()
old := CodexBase
CodexBase = fake.URL + "/backend-api/codex"
t.Cleanup(func() { CodexBase = old })
sent := func() int { mu.Lock(); defer mu.Unlock(); return len(bodies) }
// the account as its name is typed, whatever its case
if err := WarmNow(context.Background(), "codex", "[email protected]"); err != nil {
t.Fatalf("warm up now: %v", err)
}
if sent() != 1 {
t.Fatalf("%d requests, want 1", sent())
}
// the scheduled warm-up's own request, for the same account
w := codexWarmer{path: codexWarmPath(), now: time.Now, usage: codexWarmUsage, send: warmCodexLogin}
if rs := w.warmNow(context.Background(), "week", nil); len(rs) != 1 || rs[0].Err != "" {
t.Fatalf("scheduled: %+v", rs)
}
if sent() != 2 {
t.Fatalf("%d requests, want 2", sent())
}
now, scheduled := bodies[0], bodies[1]
if a, b := warmJSON(t, now), warmJSON(t, scheduled); a != b {
t.Fatalf("Warm up now sent\n%s\nthe scheduled warm-up sends\n%s", a, b)
}
if now["model"] != "gpt-5.5" || now["store"] != false || now["instructions"] == nil {
t.Fatalf("body: %v", now)
}
for _, h := range []string{"Authorization", "chatgpt-account-id", "originator", "User-Agent", "Content-Encoding"} {
if hdrs[0].Get(h) != hdrs[1].Get(h) {
t.Errorf("%s: %q, the scheduled warm-up sends %q", h, hdrs[0].Get(h), hdrs[1].Get(h))
}
}
// refused: the vendor's reason comes back
refuse = true
err := WarmNow(context.Background(), "codex", "[email protected]")
if err == nil || !strings.Contains(err.Error(), "429") || !strings.Contains(err.Error(), "usage limit reached") {
t.Fatalf("refused: %v", err)
}
// no such account, or no warm-up for the agent: nothing sent
n := sent()
if err := WarmNow(context.Background(), "codex", "[email protected]"); err == nil {
t.Fatal("warmed an account that isn't signed in")
}
if err := WarmNow(context.Background(), "copilot", "octocat"); err == nil {
t.Fatal("warmed a Copilot account")
}
if sent() != n {
t.Fatalf("%d requests for accounts that aren't there", sent()-n)
}
}
// A Claude account's Warm up now is Claude Code's run the scheduled
// warm-up makes (WarmClaudeVia), in that account's own config directory.
func TestWarmNowClaudeRunsClaudeCode(t *testing.T) {
_, side := claudeAuthFixture(t, "")
rememberLogins(true) // the one Claude Code is signed in to, listed beside it
old := claudeWarmSend
t.Cleanup(func() { claudeWarmSend = old })
claudeWarmSend = nil
if err := WarmNow(context.Background(), "claude", side.User); err == nil {
t.Fatal("warmed with no Claude Code to send it")
}
var mu sync.Mutex
var dirs []string
fail := error(nil)
WarmClaudeVia(func(_ context.Context, dir string) error {
mu.Lock()
defer mu.Unlock()
dirs = append(dirs, dir)
return fail
})
if err := WarmNow(context.Background(), "claude", side.User); err != nil {
t.Fatalf("saved account: %v", err)
}
if err := WarmNow(context.Background(), "claude", "[email protected]"); err != nil {
t.Fatalf("own account: %v", err)
}
if len(dirs) != 2 || dirs[0] == "" || dirs[1] != "" {
t.Fatalf("Claude Code run in %q, want the saved account's directory, then its own", dirs)
}
fail = errors.New("Claude Code: You've hit your session limit")
if err := WarmNow(context.Background(), "claude", "[email protected]"); err == nil || !strings.Contains(err.Error(), "session limit") {
t.Fatalf("failed run: %v", err)
}
}
// An account whose sign-in lapsed is sent nothing, and says so.
func TestWarmNowLapsedAccount(t *testing.T) {
_, side := claudeAuthFixture(t, "Failed to authenticate: OAuth token revoked")
old := claudeWarmSend
t.Cleanup(func() { claudeWarmSend = old })
ran := 0
WarmClaudeVia(func(context.Context, string) error { ran++; return nil })
err := WarmNow(context.Background(), "claude", side.User)
if err == nil || !strings.Contains(err.Error(), "signing in again") || ran != 0 {
t.Fatalf("lapsed: %v, %d runs", err, ran)
}
}
func warmJSON(t *testing.T, v any) string {
t.Helper()
b, err := json.Marshal(v)
if err != nil {
t.Fatal(err)
}
return string(b)
}