Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
package provider
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"slices"
"testing"
"time"
"github.com/yetone/magpie/internal/settings"
)
// The credits a ChatGPT account holds besides its windows are its balance
// (#571), shown when it has some to spend and they are not unlimited.
// Routing is told the account goes on past its windows on them (onCredits:
// every window's Credits, and the allowance's OnCredits) when it holds
// some or they are unlimited, as the Codex app reads has_credits; a
// balance said and spent is none.
func TestCodexCreditsBalance(t *testing.T) {
for _, c := range []struct {
name string
credits any
want string
onCredits bool
}{
{"none said", nil, "", false},
{"held", map[string]any{"has_credits": true, "unlimited": false, "balance": "1234.5"}, "1234.5 credits", true},
{"a few", map[string]any{"has_credits": true, "unlimited": false, "balance": "42"}, "42 credits", true},
{"none held", map[string]any{"has_credits": false, "unlimited": false, "balance": "0"}, "", false},
{"spent", map[string]any{"has_credits": true, "unlimited": false, "balance": "0"}, "", false},
{"unlimited", map[string]any{"has_credits": true, "unlimited": true, "balance": ""}, "", true},
{"unreadable", map[string]any{"has_credits": true, "balance": "lots"}, "", true},
} {
t.Run(c.name, func(t *testing.T) {
fake := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
body := map[string]any{"plan_type": "plus", "rate_limit": map[string]any{
"primary_window": map[string]any{"used_percent": 100, "limit_window_seconds": 18000}}}
if c.credits != nil {
body["credits"] = c.credits
}
json.NewEncoder(w).Encode(body)
}))
defer fake.Close()
old := CodexBase
CodexBase = fake.URL + "/backend-api/codex"
defer func() { CodexBase = old }()
plan, windows, _, credits, _, err := codexWindows(context.Background(), "tok", "acct-1")
if err != nil || plan != "plus" || len(windows) != 1 {
t.Fatalf("plan %q, windows %v, err %v", plan, windows, err)
}
if credits != c.want {
t.Errorf("credits %q, want %q", credits, c.want)
}
if windows[0].Credits != c.onCredits || allowanceOf(windows, time.Now()).OnCredits() != c.onCredits {
t.Errorf("on credits %v / %v, want %v", windows[0].Credits, allowanceOf(windows, time.Now()).OnCredits(), c.onCredits)
}
})
}
}
// Whether an account spends its credits is kept by account, whatever its
// case: on unless turned off. Turned off, a Codex account is held at 100%
// of its windows; a cap holds it sooner, and nothing holds another
// vendor's account for its credits.
func TestCodexCreditsSwitch(t *testing.T) {
signIn(t)
if !CodexCredits("[email protected]") {
t.Fatal("off before it was turned off")
}
if err := SetCodexCredits(" [email protected] ", false); err != nil {
t.Fatal(err)
}
if got := settings.Load().CodexNoCredits; !slices.Equal(got, []string{"[email protected]"}) {
t.Fatalf("kept %v", got)
}
if CodexCredits("[email protected]") || !CodexCredits("[email protected]") {
t.Fatal("read back wrong")
}
p := Provider{ID: "codex", AccountCaps: map[string]int{"[email protected]": 70}}
for _, c := range []struct {
agent, user string
share int
noCredits bool
}{
{"codex", "[email protected]", 100, true},
{"codex", "[email protected]", 0, false},
{"claude", "[email protected]", 0, false},
{"codex", "[email protected]", 70, false},
} {
if share, no := HoldCaps(p, c.agent, c.user).Of("5 hours"); share != c.share || no != c.noCredits {
t.Errorf("%s %s: held at %d (credits %v)", c.agent, c.user, share, no)
}
}
if err := SetCodexCredits("[email protected]", true); err != nil {
t.Fatal(err)
}
if !CodexCredits("[email protected]") || len(settings.Load().CodexNoCredits) != 0 {
t.Fatal("still off")
}
}
// A reset spent starts an account's windows again: what was read of them
// before is forgotten, so what holds the account at a share of them (its
// cap, its credits not spent) holds it no more, and they are read again
// at once; the other accounts' readings stay.
func TestRenewedAccountForgetsItsAllowance(t *testing.T) {
signIn(t)
usedCache.Lock()
usedCache.m, usedCache.at, usedCache.loading = map[string]map[string]Allowance{}, map[string]time.Time{}, map[string]chan struct{}{}
usedCache.stale = nil
usedCache.m["codex"] = map[string]Allowance{
"[email protected]": {{Used: 100, Span: 5 * time.Hour}},
"[email protected]": {{Used: 10, Span: 5 * time.Hour}},
}
usedCache.at["codex"] = time.Now()
handed := usedCache.m["codex"]
usedCache.Unlock()
t.Cleanup(func() {
usedCache.Lock()
usedCache.m, usedCache.at, usedCache.loading = map[string]map[string]Allowance{}, map[string]time.Time{}, map[string]chan struct{}{}
usedCache.stale = nil
usedCache.Unlock()
})
renewedNow("codex", "[email protected]")
usedCache.Lock()
m, at := usedCache.m["codex"], usedCache.at["codex"]
usedCache.Unlock()
if _, ok := m["[email protected]"]; ok {
t.Fatalf("still read as before: %v", m["[email protected]"])
}
if _, ok := m["[email protected]"]; !ok || !at.IsZero() {
t.Fatalf("spare kept %v, read again at once %v", ok, at.IsZero())
}
if _, ok := handed["[email protected]"]; !ok {
t.Fatal("the map handed out before was changed")
}
}