813 lines
26 KiB
TypeScript
813 lines
26 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import type { QuotaWindow } from "@paperclipai/adapter-utils";
|
|
|
|
// Pure utility functions — import directly from adapter source
|
|
import {
|
|
toPercent,
|
|
fetchWithTimeout,
|
|
fetchClaudeQuota,
|
|
parseClaudeCliUsageText,
|
|
readClaudeToken,
|
|
claudeConfigDir,
|
|
} from "@paperclipai/adapter-claude-local/server";
|
|
|
|
import {
|
|
secondsToWindowLabel,
|
|
readCodexAuthInfo,
|
|
readCodexToken,
|
|
fetchCodexQuota,
|
|
mapCodexRpcQuota,
|
|
codexHomeDir,
|
|
} from "@paperclipai/adapter-codex-local/server";
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// toPercent
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe("toPercent", () => {
|
|
it("returns null for null input", () => {
|
|
expect(toPercent(null)).toBe(null);
|
|
});
|
|
|
|
it("returns null for undefined input", () => {
|
|
expect(toPercent(undefined)).toBe(null);
|
|
});
|
|
|
|
it("converts 0 to 0", () => {
|
|
expect(toPercent(0)).toBe(0);
|
|
});
|
|
|
|
it("converts 0.5 to 50", () => {
|
|
expect(toPercent(0.5)).toBe(50);
|
|
});
|
|
|
|
it("converts 1.0 to 100", () => {
|
|
expect(toPercent(1.0)).toBe(100);
|
|
});
|
|
|
|
it("clamps overshoot to 100", () => {
|
|
// floating-point utilization can slightly exceed 1.0
|
|
expect(toPercent(1.001)).toBe(100);
|
|
expect(toPercent(1.01)).toBe(100);
|
|
});
|
|
|
|
it("rounds to nearest integer", () => {
|
|
expect(toPercent(0.333)).toBe(33);
|
|
expect(toPercent(0.666)).toBe(67);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// secondsToWindowLabel
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe("secondsToWindowLabel", () => {
|
|
it("returns fallback for null seconds", () => {
|
|
expect(secondsToWindowLabel(null, "Primary")).toBe("Primary");
|
|
});
|
|
|
|
it("returns fallback for undefined seconds", () => {
|
|
expect(secondsToWindowLabel(undefined, "Secondary")).toBe("Secondary");
|
|
});
|
|
|
|
it("labels windows under 6 hours as '5h'", () => {
|
|
expect(secondsToWindowLabel(3600, "fallback")).toBe("5h"); // 1h
|
|
expect(secondsToWindowLabel(18000, "fallback")).toBe("5h"); // 5h exactly
|
|
});
|
|
|
|
it("labels windows up to 24 hours as '24h'", () => {
|
|
expect(secondsToWindowLabel(21600, "fallback")).toBe("24h"); // 6h (≥6h boundary)
|
|
expect(secondsToWindowLabel(86400, "fallback")).toBe("24h"); // 24h exactly
|
|
});
|
|
|
|
it("labels windows up to 7 days as '7d'", () => {
|
|
expect(secondsToWindowLabel(86401, "fallback")).toBe("7d"); // just over 24h
|
|
expect(secondsToWindowLabel(604800, "fallback")).toBe("7d"); // 7d exactly
|
|
});
|
|
|
|
it("labels windows beyond 7 days with actual day count", () => {
|
|
expect(secondsToWindowLabel(1209600, "fallback")).toBe("14d"); // 14d
|
|
expect(secondsToWindowLabel(2592000, "fallback")).toBe("30d"); // 30d
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// WHAM used_percent normalization (codex / openai)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe("WHAM used_percent normalization via fetchCodexQuota", () => {
|
|
beforeEach(() => {
|
|
vi.stubGlobal("fetch", vi.fn());
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.unstubAllGlobals();
|
|
});
|
|
|
|
function mockFetch(body: unknown) {
|
|
(fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
ok: true,
|
|
json: async () => body,
|
|
} as Response);
|
|
}
|
|
|
|
it("treats values >= 1 as already-percentage (50 → 50%)", async () => {
|
|
mockFetch({
|
|
rate_limit: {
|
|
primary_window: {
|
|
used_percent: 50,
|
|
limit_window_seconds: 18000,
|
|
reset_at: null,
|
|
},
|
|
},
|
|
});
|
|
const windows = await fetchCodexQuota("token", null);
|
|
expect(windows[0]!.usedPercent).toBe(50);
|
|
});
|
|
|
|
it("treats values < 1 as fraction and multiplies by 100 (0.5 → 50%)", async () => {
|
|
mockFetch({
|
|
rate_limit: {
|
|
primary_window: {
|
|
used_percent: 0.5,
|
|
limit_window_seconds: 18000,
|
|
reset_at: null,
|
|
},
|
|
},
|
|
});
|
|
const windows = await fetchCodexQuota("token", null);
|
|
expect(windows[0]!.usedPercent).toBe(50);
|
|
});
|
|
|
|
it("treats value exactly 1.0 as 1% (not 100%) — the < 1 heuristic boundary", async () => {
|
|
// 1.0 is NOT < 1, so it is treated as already-percentage → 1%
|
|
mockFetch({
|
|
rate_limit: {
|
|
primary_window: {
|
|
used_percent: 1.0,
|
|
limit_window_seconds: 18000,
|
|
reset_at: null,
|
|
},
|
|
},
|
|
});
|
|
const windows = await fetchCodexQuota("token", null);
|
|
expect(windows[0]!.usedPercent).toBe(1);
|
|
});
|
|
|
|
it("treats value 0 as 0%", async () => {
|
|
mockFetch({
|
|
rate_limit: {
|
|
primary_window: {
|
|
used_percent: 0,
|
|
limit_window_seconds: 18000,
|
|
reset_at: null,
|
|
},
|
|
},
|
|
});
|
|
const windows = await fetchCodexQuota("token", null);
|
|
expect(windows[0]!.usedPercent).toBe(0);
|
|
});
|
|
|
|
it("clamps 100% to 100 (no overshoot)", async () => {
|
|
mockFetch({
|
|
rate_limit: {
|
|
primary_window: {
|
|
used_percent: 105,
|
|
limit_window_seconds: 18000,
|
|
reset_at: null,
|
|
},
|
|
},
|
|
});
|
|
const windows = await fetchCodexQuota("token", null);
|
|
expect(windows[0]!.usedPercent).toBe(100);
|
|
});
|
|
|
|
it("sets usedPercent to null when used_percent is absent", async () => {
|
|
mockFetch({
|
|
rate_limit: {
|
|
primary_window: {
|
|
limit_window_seconds: 18000,
|
|
reset_at: null,
|
|
},
|
|
},
|
|
});
|
|
const windows = await fetchCodexQuota("token", null);
|
|
expect(windows[0]!.usedPercent).toBe(null);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// readClaudeToken — filesystem paths
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe("readClaudeToken", () => {
|
|
const savedEnv = process.env.CLAUDE_CONFIG_DIR;
|
|
|
|
afterEach(() => {
|
|
if (savedEnv === undefined) {
|
|
delete process.env.CLAUDE_CONFIG_DIR;
|
|
} else {
|
|
process.env.CLAUDE_CONFIG_DIR = savedEnv;
|
|
}
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("returns null when credentials.json does not exist", async () => {
|
|
// Point to a directory that does not have credentials.json
|
|
process.env.CLAUDE_CONFIG_DIR = "/tmp/__no_such_paperclip_dir__";
|
|
const token = await readClaudeToken();
|
|
expect(token).toBe(null);
|
|
});
|
|
|
|
it("returns null for malformed JSON", async () => {
|
|
const tmpDir = path.join(os.tmpdir(), `paperclip-test-claude-${Date.now()}`);
|
|
await import("node:fs/promises").then((fs) =>
|
|
fs.mkdir(tmpDir, { recursive: true }).then(() =>
|
|
fs.writeFile(path.join(tmpDir, "credentials.json"), "not-json"),
|
|
),
|
|
);
|
|
process.env.CLAUDE_CONFIG_DIR = tmpDir;
|
|
const token = await readClaudeToken();
|
|
expect(token).toBe(null);
|
|
await import("node:fs/promises").then((fs) => fs.rm(tmpDir, { recursive: true }));
|
|
});
|
|
|
|
it("returns null when claudeAiOauth key is missing", async () => {
|
|
const tmpDir = path.join(os.tmpdir(), `paperclip-test-claude-${Date.now()}`);
|
|
await import("node:fs/promises").then((fs) =>
|
|
fs.mkdir(tmpDir, { recursive: true }).then(() =>
|
|
fs.writeFile(path.join(tmpDir, "credentials.json"), JSON.stringify({ other: "data" })),
|
|
),
|
|
);
|
|
process.env.CLAUDE_CONFIG_DIR = tmpDir;
|
|
const token = await readClaudeToken();
|
|
expect(token).toBe(null);
|
|
await import("node:fs/promises").then((fs) => fs.rm(tmpDir, { recursive: true }));
|
|
});
|
|
|
|
it("returns null when accessToken is an empty string", async () => {
|
|
const tmpDir = path.join(os.tmpdir(), `paperclip-test-claude-${Date.now()}`);
|
|
const creds = { claudeAiOauth: { accessToken: "" } };
|
|
await import("node:fs/promises").then((fs) =>
|
|
fs.mkdir(tmpDir, { recursive: true }).then(() =>
|
|
fs.writeFile(path.join(tmpDir, "credentials.json"), JSON.stringify(creds)),
|
|
),
|
|
);
|
|
process.env.CLAUDE_CONFIG_DIR = tmpDir;
|
|
const token = await readClaudeToken();
|
|
expect(token).toBe(null);
|
|
await import("node:fs/promises").then((fs) => fs.rm(tmpDir, { recursive: true }));
|
|
});
|
|
|
|
it("returns the token when credentials file is well-formed", async () => {
|
|
const tmpDir = path.join(os.tmpdir(), `paperclip-test-claude-${Date.now()}`);
|
|
const creds = { claudeAiOauth: { accessToken: "my-test-token" } };
|
|
await import("node:fs/promises").then((fs) =>
|
|
fs.mkdir(tmpDir, { recursive: true }).then(() =>
|
|
fs.writeFile(path.join(tmpDir, "credentials.json"), JSON.stringify(creds)),
|
|
),
|
|
);
|
|
process.env.CLAUDE_CONFIG_DIR = tmpDir;
|
|
const token = await readClaudeToken();
|
|
expect(token).toBe("my-test-token");
|
|
await import("node:fs/promises").then((fs) => fs.rm(tmpDir, { recursive: true }));
|
|
});
|
|
|
|
it("reads the token from .credentials.json when that is the available Claude auth file", async () => {
|
|
const tmpDir = path.join(os.tmpdir(), `paperclip-test-claude-${Date.now()}`);
|
|
const creds = { claudeAiOauth: { accessToken: "dotfile-token" } };
|
|
await import("node:fs/promises").then((fs) =>
|
|
fs.mkdir(tmpDir, { recursive: true }).then(() =>
|
|
fs.writeFile(path.join(tmpDir, ".credentials.json"), JSON.stringify(creds)),
|
|
),
|
|
);
|
|
process.env.CLAUDE_CONFIG_DIR = tmpDir;
|
|
const token = await readClaudeToken();
|
|
expect(token).toBe("dotfile-token");
|
|
await import("node:fs/promises").then((fs) => fs.rm(tmpDir, { recursive: true }));
|
|
});
|
|
});
|
|
|
|
describe("parseClaudeCliUsageText", () => {
|
|
it("parses the Claude usage panel layout into quota windows", () => {
|
|
const raw = `
|
|
Settings: Status Config Usage
|
|
Current session
|
|
2% used
|
|
Resets 5pm (America/Chicago)
|
|
|
|
Current week (all models)
|
|
47% used
|
|
Resets Mar 18 at 7:59am (America/Chicago)
|
|
|
|
Current week (Sonnet only)
|
|
0% used
|
|
Resets Mar 18 at 8:59am (America/Chicago)
|
|
|
|
Extra usage
|
|
Extra usage not enabled • /extra-usage to enable
|
|
`;
|
|
|
|
expect(parseClaudeCliUsageText(raw)).toEqual([
|
|
{
|
|
label: "Current session",
|
|
usedPercent: 2,
|
|
resetsAt: null,
|
|
valueLabel: null,
|
|
detail: "Resets 5pm (America/Chicago)",
|
|
},
|
|
{
|
|
label: "Current week (all models)",
|
|
usedPercent: 47,
|
|
resetsAt: null,
|
|
valueLabel: null,
|
|
detail: "Resets Mar 18 at 7:59am (America/Chicago)",
|
|
},
|
|
{
|
|
label: "Current week (Sonnet only)",
|
|
usedPercent: 0,
|
|
resetsAt: null,
|
|
valueLabel: null,
|
|
detail: "Resets Mar 18 at 8:59am (America/Chicago)",
|
|
},
|
|
{
|
|
label: "Extra usage",
|
|
usedPercent: null,
|
|
resetsAt: null,
|
|
valueLabel: null,
|
|
detail: "Extra usage not enabled • /extra-usage to enable",
|
|
},
|
|
]);
|
|
});
|
|
|
|
it("throws a useful error when the Claude CLI panel reports a usage load failure", () => {
|
|
expect(() => parseClaudeCliUsageText("Failed to load usage data")).toThrow(
|
|
"Claude CLI could not load usage data. Open the CLI and retry `/usage`.",
|
|
);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// readCodexAuthInfo / readCodexToken — filesystem paths
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe("readCodexAuthInfo", () => {
|
|
const savedEnv = process.env.CODEX_HOME;
|
|
|
|
afterEach(() => {
|
|
if (savedEnv === undefined) {
|
|
delete process.env.CODEX_HOME;
|
|
} else {
|
|
process.env.CODEX_HOME = savedEnv;
|
|
}
|
|
});
|
|
|
|
it("returns null when auth.json does not exist", async () => {
|
|
process.env.CODEX_HOME = "/tmp/__no_such_paperclip_codex_dir__";
|
|
const result = await readCodexAuthInfo();
|
|
expect(result).toBe(null);
|
|
});
|
|
|
|
it("returns null for malformed JSON", async () => {
|
|
const tmpDir = path.join(os.tmpdir(), `paperclip-test-codex-${Date.now()}`);
|
|
await import("node:fs/promises").then((fs) =>
|
|
fs.mkdir(tmpDir, { recursive: true }).then(() =>
|
|
fs.writeFile(path.join(tmpDir, "auth.json"), "{bad json"),
|
|
),
|
|
);
|
|
process.env.CODEX_HOME = tmpDir;
|
|
const result = await readCodexAuthInfo();
|
|
expect(result).toBe(null);
|
|
await import("node:fs/promises").then((fs) => fs.rm(tmpDir, { recursive: true }));
|
|
});
|
|
|
|
it("returns null when accessToken is absent", async () => {
|
|
const tmpDir = path.join(os.tmpdir(), `paperclip-test-codex-${Date.now()}`);
|
|
await import("node:fs/promises").then((fs) =>
|
|
fs.mkdir(tmpDir, { recursive: true }).then(() =>
|
|
fs.writeFile(path.join(tmpDir, "auth.json"), JSON.stringify({ accountId: "acc-1" })),
|
|
),
|
|
);
|
|
process.env.CODEX_HOME = tmpDir;
|
|
const result = await readCodexAuthInfo();
|
|
expect(result).toBe(null);
|
|
await import("node:fs/promises").then((fs) => fs.rm(tmpDir, { recursive: true }));
|
|
});
|
|
|
|
it("reads the legacy flat auth shape", async () => {
|
|
const tmpDir = path.join(os.tmpdir(), `paperclip-test-codex-${Date.now()}`);
|
|
const auth = { accessToken: "codex-token", accountId: "acc-123" };
|
|
await import("node:fs/promises").then((fs) =>
|
|
fs.mkdir(tmpDir, { recursive: true }).then(() =>
|
|
fs.writeFile(path.join(tmpDir, "auth.json"), JSON.stringify(auth)),
|
|
),
|
|
);
|
|
process.env.CODEX_HOME = tmpDir;
|
|
const result = await readCodexAuthInfo();
|
|
expect(result).toMatchObject({
|
|
accessToken: "codex-token",
|
|
accountId: "acc-123",
|
|
email: null,
|
|
planType: null,
|
|
});
|
|
await import("node:fs/promises").then((fs) => fs.rm(tmpDir, { recursive: true }));
|
|
});
|
|
|
|
it("reads the modern nested auth shape", async () => {
|
|
const tmpDir = path.join(os.tmpdir(), `paperclip-test-codex-${Date.now()}`);
|
|
const jwtPayload = Buffer.from(
|
|
JSON.stringify({
|
|
email: "codex@example.com",
|
|
"https://api.openai.com/auth": {
|
|
chatgpt_plan_type: "pro",
|
|
chatgpt_user_email: "codex@example.com",
|
|
},
|
|
}),
|
|
).toString("base64url");
|
|
const auth = {
|
|
tokens: {
|
|
access_token: `header.${jwtPayload}.sig`,
|
|
account_id: "acc-modern",
|
|
refresh_token: "refresh-me",
|
|
id_token: `header.${jwtPayload}.sig`,
|
|
},
|
|
last_refresh: "2026-03-14T12:00:00Z",
|
|
};
|
|
await import("node:fs/promises").then((fs) =>
|
|
fs.mkdir(tmpDir, { recursive: true }).then(() =>
|
|
fs.writeFile(path.join(tmpDir, "auth.json"), JSON.stringify(auth)),
|
|
),
|
|
);
|
|
process.env.CODEX_HOME = tmpDir;
|
|
const result = await readCodexAuthInfo();
|
|
expect(result).toMatchObject({
|
|
accessToken: `header.${jwtPayload}.sig`,
|
|
accountId: "acc-modern",
|
|
refreshToken: "refresh-me",
|
|
email: "codex@example.com",
|
|
planType: "pro",
|
|
lastRefresh: "2026-03-14T12:00:00Z",
|
|
});
|
|
await import("node:fs/promises").then((fs) => fs.rm(tmpDir, { recursive: true }));
|
|
});
|
|
});
|
|
|
|
describe("readCodexToken", () => {
|
|
const savedEnv = process.env.CODEX_HOME;
|
|
|
|
afterEach(() => {
|
|
if (savedEnv === undefined) {
|
|
delete process.env.CODEX_HOME;
|
|
} else {
|
|
process.env.CODEX_HOME = savedEnv;
|
|
}
|
|
});
|
|
|
|
it("returns token and accountId from the nested auth shape", async () => {
|
|
const tmpDir = path.join(os.tmpdir(), `paperclip-test-codex-${Date.now()}`);
|
|
await import("node:fs/promises").then((fs) =>
|
|
fs.mkdir(tmpDir, { recursive: true }).then(() =>
|
|
fs.writeFile(path.join(tmpDir, "auth.json"), JSON.stringify({
|
|
tokens: {
|
|
access_token: "nested-token",
|
|
account_id: "acc-nested",
|
|
},
|
|
})),
|
|
),
|
|
);
|
|
process.env.CODEX_HOME = tmpDir;
|
|
const result = await readCodexToken();
|
|
expect(result).toEqual({ token: "nested-token", accountId: "acc-nested" });
|
|
await import("node:fs/promises").then((fs) => fs.rm(tmpDir, { recursive: true }));
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// fetchClaudeQuota — response parsing
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe("fetchClaudeQuota", () => {
|
|
beforeEach(() => {
|
|
vi.stubGlobal("fetch", vi.fn());
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.unstubAllGlobals();
|
|
});
|
|
|
|
function mockFetch(body: unknown, ok = true, status = 200) {
|
|
(fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
ok,
|
|
status,
|
|
json: async () => body,
|
|
} as Response);
|
|
}
|
|
|
|
it("throws when the API returns a non-200 status", async () => {
|
|
mockFetch({}, false, 401);
|
|
await expect(fetchClaudeQuota("token")).rejects.toThrow("anthropic usage api returned 401");
|
|
});
|
|
|
|
it("returns an empty array when all window fields are absent", async () => {
|
|
mockFetch({});
|
|
const windows = await fetchClaudeQuota("token");
|
|
expect(windows).toEqual([]);
|
|
});
|
|
|
|
it("parses five_hour window", async () => {
|
|
mockFetch({ five_hour: { utilization: 0.4, resets_at: "2026-01-01T00:00:00Z" } });
|
|
const windows = await fetchClaudeQuota("token");
|
|
expect(windows).toHaveLength(1);
|
|
expect(windows[0]).toMatchObject({
|
|
label: "Current session",
|
|
usedPercent: 40,
|
|
resetsAt: "2026-01-01T00:00:00Z",
|
|
});
|
|
});
|
|
|
|
it("parses seven_day window", async () => {
|
|
mockFetch({ seven_day: { utilization: 0.75, resets_at: null } });
|
|
const windows = await fetchClaudeQuota("token");
|
|
expect(windows).toHaveLength(1);
|
|
expect(windows[0]).toMatchObject({
|
|
label: "Current week (all models)",
|
|
usedPercent: 75,
|
|
resetsAt: null,
|
|
});
|
|
});
|
|
|
|
it("parses seven_day_sonnet and seven_day_opus windows", async () => {
|
|
mockFetch({
|
|
seven_day_sonnet: { utilization: 0.2, resets_at: null },
|
|
seven_day_opus: { utilization: 0.9, resets_at: null },
|
|
});
|
|
const windows = await fetchClaudeQuota("token");
|
|
expect(windows).toHaveLength(2);
|
|
expect(windows[0]!.label).toBe("Current week (Sonnet only)");
|
|
expect(windows[1]!.label).toBe("Current week (Opus only)");
|
|
});
|
|
|
|
it("sets usedPercent to null when utilization is absent", async () => {
|
|
mockFetch({ five_hour: { resets_at: null } });
|
|
const windows = await fetchClaudeQuota("token");
|
|
expect(windows[0]!.usedPercent).toBe(null);
|
|
});
|
|
|
|
it("includes all four windows when all are present", async () => {
|
|
mockFetch({
|
|
five_hour: { utilization: 0.1, resets_at: null },
|
|
seven_day: { utilization: 0.2, resets_at: null },
|
|
seven_day_sonnet: { utilization: 0.3, resets_at: null },
|
|
seven_day_opus: { utilization: 0.4, resets_at: null },
|
|
});
|
|
const windows = await fetchClaudeQuota("token");
|
|
expect(windows).toHaveLength(4);
|
|
const labels = windows.map((w: QuotaWindow) => w.label);
|
|
expect(labels).toEqual([
|
|
"Current session",
|
|
"Current week (all models)",
|
|
"Current week (Sonnet only)",
|
|
"Current week (Opus only)",
|
|
]);
|
|
});
|
|
|
|
it("parses extra usage when the OAuth response includes it", async () => {
|
|
mockFetch({
|
|
extra_usage: {
|
|
is_enabled: false,
|
|
utilization: null,
|
|
},
|
|
});
|
|
const windows = await fetchClaudeQuota("token");
|
|
expect(windows).toEqual([
|
|
{
|
|
label: "Extra usage",
|
|
usedPercent: null,
|
|
resetsAt: null,
|
|
valueLabel: "Not enabled",
|
|
detail: "Extra usage not enabled",
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// fetchCodexQuota — response parsing (credits, windows)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe("fetchCodexQuota", () => {
|
|
beforeEach(() => {
|
|
vi.stubGlobal("fetch", vi.fn());
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.unstubAllGlobals();
|
|
});
|
|
|
|
function mockFetch(body: unknown, ok = true, status = 200) {
|
|
(fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
ok,
|
|
status,
|
|
json: async () => body,
|
|
} as Response);
|
|
}
|
|
|
|
it("throws when the WHAM API returns a non-200 status", async () => {
|
|
mockFetch({}, false, 403);
|
|
await expect(fetchCodexQuota("token", null)).rejects.toThrow("chatgpt wham api returned 403");
|
|
});
|
|
|
|
it("passes ChatGPT-Account-Id header when accountId is provided", async () => {
|
|
mockFetch({});
|
|
await fetchCodexQuota("token", "acc-xyz");
|
|
const callInit = (fetch as ReturnType<typeof vi.fn>).mock.calls[0][1] as RequestInit;
|
|
expect((callInit.headers as Record<string, string>)["ChatGPT-Account-Id"]).toBe("acc-xyz");
|
|
});
|
|
|
|
it("omits ChatGPT-Account-Id header when accountId is null", async () => {
|
|
mockFetch({});
|
|
await fetchCodexQuota("token", null);
|
|
const callInit = (fetch as ReturnType<typeof vi.fn>).mock.calls[0][1] as RequestInit;
|
|
expect((callInit.headers as Record<string, string>)["ChatGPT-Account-Id"]).toBeUndefined();
|
|
});
|
|
|
|
it("returns empty array when response body is empty", async () => {
|
|
mockFetch({});
|
|
const windows = await fetchCodexQuota("token", null);
|
|
expect(windows).toEqual([]);
|
|
});
|
|
|
|
it("normalizes numeric reset timestamps from WHAM", async () => {
|
|
mockFetch({
|
|
rate_limit: {
|
|
primary_window: { used_percent: 30, limit_window_seconds: 86400, reset_at: 1_767_312_000 },
|
|
},
|
|
});
|
|
const windows = await fetchCodexQuota("token", null);
|
|
expect(windows).toHaveLength(1);
|
|
expect(windows[0]).toMatchObject({ label: "5h limit", usedPercent: 30, resetsAt: "2026-01-02T00:00:00.000Z" });
|
|
});
|
|
|
|
it("parses secondary_window alongside primary_window", async () => {
|
|
mockFetch({
|
|
rate_limit: {
|
|
primary_window: { used_percent: 10, limit_window_seconds: 18000 },
|
|
secondary_window: { used_percent: 60, limit_window_seconds: 604800 },
|
|
},
|
|
});
|
|
const windows = await fetchCodexQuota("token", null);
|
|
expect(windows).toHaveLength(2);
|
|
expect(windows[0]!.label).toBe("5h limit");
|
|
expect(windows[1]!.label).toBe("Weekly limit");
|
|
});
|
|
|
|
it("includes Credits window when credits present and not unlimited", async () => {
|
|
mockFetch({
|
|
credits: { balance: 420, unlimited: false },
|
|
});
|
|
const windows = await fetchCodexQuota("token", null);
|
|
expect(windows).toHaveLength(1);
|
|
expect(windows[0]).toMatchObject({ label: "Credits", valueLabel: "$4.20 remaining", usedPercent: null });
|
|
});
|
|
|
|
it("omits Credits window when unlimited is true", async () => {
|
|
mockFetch({
|
|
credits: { balance: 9999, unlimited: true },
|
|
});
|
|
const windows = await fetchCodexQuota("token", null);
|
|
expect(windows).toEqual([]);
|
|
});
|
|
|
|
it("shows 'N/A' valueLabel when credits balance is null", async () => {
|
|
mockFetch({
|
|
credits: { balance: null, unlimited: false },
|
|
});
|
|
const windows = await fetchCodexQuota("token", null);
|
|
expect(windows[0]!.valueLabel).toBe("N/A");
|
|
});
|
|
});
|
|
|
|
describe("mapCodexRpcQuota", () => {
|
|
it("maps account and model-specific Codex limits into quota windows", () => {
|
|
const snapshot = mapCodexRpcQuota(
|
|
{
|
|
rateLimits: {
|
|
limitId: "codex",
|
|
primary: { usedPercent: 1, windowDurationMins: 300, resetsAt: 1_763_500_000 },
|
|
secondary: { usedPercent: 27, windowDurationMins: 10_080 },
|
|
planType: "pro",
|
|
},
|
|
rateLimitsByLimitId: {
|
|
codex_bengalfox: {
|
|
limitId: "codex_bengalfox",
|
|
limitName: "GPT-5.3-Codex-Spark",
|
|
primary: { usedPercent: 8, windowDurationMins: 300 },
|
|
secondary: { usedPercent: 20, windowDurationMins: 10_080 },
|
|
},
|
|
},
|
|
},
|
|
{
|
|
account: {
|
|
email: "codex@example.com",
|
|
planType: "pro",
|
|
},
|
|
},
|
|
);
|
|
|
|
expect(snapshot.email).toBe("codex@example.com");
|
|
expect(snapshot.planType).toBe("pro");
|
|
expect(snapshot.windows).toEqual([
|
|
{
|
|
label: "5h limit",
|
|
usedPercent: 1,
|
|
resetsAt: "2025-11-18T21:06:40.000Z",
|
|
valueLabel: null,
|
|
detail: null,
|
|
},
|
|
{
|
|
label: "Weekly limit",
|
|
usedPercent: 27,
|
|
resetsAt: null,
|
|
valueLabel: null,
|
|
detail: null,
|
|
},
|
|
{
|
|
label: "GPT-5.3-Codex-Spark · 5h limit",
|
|
usedPercent: 8,
|
|
resetsAt: null,
|
|
valueLabel: null,
|
|
detail: null,
|
|
},
|
|
{
|
|
label: "GPT-5.3-Codex-Spark · Weekly limit",
|
|
usedPercent: 20,
|
|
resetsAt: null,
|
|
valueLabel: null,
|
|
detail: null,
|
|
},
|
|
]);
|
|
});
|
|
|
|
it("includes a credits row when the root Codex limit reports finite credits", () => {
|
|
const snapshot = mapCodexRpcQuota({
|
|
rateLimits: {
|
|
limitId: "codex",
|
|
credits: {
|
|
unlimited: false,
|
|
balance: "12.34",
|
|
},
|
|
},
|
|
});
|
|
|
|
expect(snapshot.windows).toEqual([
|
|
{
|
|
label: "Credits",
|
|
usedPercent: null,
|
|
resetsAt: null,
|
|
valueLabel: "$12.34 remaining",
|
|
detail: null,
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// fetchWithTimeout — abort on timeout
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe("fetchWithTimeout", () => {
|
|
afterEach(() => {
|
|
vi.unstubAllGlobals();
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
it("resolves normally when fetch completes before timeout", async () => {
|
|
const mockResponse = { ok: true, status: 200, json: async () => ({}) } as Response;
|
|
vi.stubGlobal("fetch", vi.fn().mockResolvedValue(mockResponse));
|
|
|
|
const result = await fetchWithTimeout("https://example.com", {}, 5000);
|
|
expect(result.ok).toBe(true);
|
|
});
|
|
|
|
it("rejects with abort error when fetch takes too long", async () => {
|
|
vi.useFakeTimers();
|
|
vi.stubGlobal(
|
|
"fetch",
|
|
vi.fn().mockImplementation(
|
|
(_url: string, init: RequestInit) =>
|
|
new Promise((_resolve, reject) => {
|
|
init.signal?.addEventListener("abort", () => {
|
|
reject(new DOMException("The operation was aborted.", "AbortError"));
|
|
});
|
|
}),
|
|
),
|
|
);
|
|
|
|
const promise = fetchWithTimeout("https://example.com", {}, 1000);
|
|
vi.advanceTimersByTime(1001);
|
|
await expect(promise).rejects.toThrow("aborted");
|
|
});
|
|
});
|