wehub-resource-sync
1503 lines
49 KiB
TypeScript
1503 lines
49 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
const usageService = await import("../../open-sse/services/usage.ts");
|
|
const { __testing } = usageService;
|
|
const { getAntigravityLoadCodeAssistMetadata } =
|
|
await import("../../open-sse/services/antigravityHeaders.ts");
|
|
const { getAntigravityFetchAvailableModelsUrls } =
|
|
await import("../../open-sse/config/antigravityUpstream.ts");
|
|
|
|
const originalFetch = globalThis.fetch;
|
|
const originalCreditsMode = process.env.ANTIGRAVITY_CREDITS;
|
|
|
|
test.afterEach(() => {
|
|
globalThis.fetch = originalFetch;
|
|
if (originalCreditsMode === undefined) {
|
|
delete process.env.ANTIGRAVITY_CREDITS;
|
|
} else {
|
|
process.env.ANTIGRAVITY_CREDITS = originalCreditsMode;
|
|
}
|
|
});
|
|
|
|
test("usage service covers GitHub free-plan parsing, auth denial and unsupported providers", async () => {
|
|
// Free-plan fixture aligned with the upstream protocol (#2876): in
|
|
// `copilot_internal/user`, `limited_user_quotas[name]` is the REMAINING
|
|
// count for the month and counts down toward 0; `monthly_quotas[name]`
|
|
// is the total allowance. The chat numbers below (410 / 500) are the
|
|
// example values from robinebers/openusage docs/providers/copilot.md.
|
|
// We also keep an out-of-range premium_interactions remaining (70 > 50)
|
|
// to assert the defensive clamp at the upstream boundary.
|
|
const calls: any[] = [];
|
|
globalThis.fetch = async (_url, init = {}) => {
|
|
calls.push(init);
|
|
return new Response(
|
|
JSON.stringify({
|
|
copilot_plan: "free",
|
|
limited_user_reset_date: new Date(Date.now() + 60_000).toISOString(),
|
|
monthly_quotas: {
|
|
premium_interactions: 50,
|
|
chat: 500,
|
|
completions: 4000,
|
|
},
|
|
limited_user_quotas: {
|
|
premium_interactions: 70,
|
|
chat: 410,
|
|
completions: 4000,
|
|
},
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
};
|
|
|
|
const freeUsage: any = await usageService.getUsageForProvider({
|
|
provider: "github",
|
|
accessToken: "gho-free",
|
|
});
|
|
|
|
assert.equal(freeUsage.plan, "Copilot Free");
|
|
// premium_interactions: upstream remaining=70 clamped to total=50 → fully
|
|
// available, 0 used, 100% remaining.
|
|
assert.equal(freeUsage.quotas.premium_interactions.total, 50);
|
|
assert.equal(freeUsage.quotas.premium_interactions.remaining, 50);
|
|
assert.equal(freeUsage.quotas.premium_interactions.used, 0);
|
|
assert.equal(freeUsage.quotas.premium_interactions.remainingPercentage, 100);
|
|
// chat: 410 remaining of 500 → 82% remaining, 90 used.
|
|
assert.equal(freeUsage.quotas.chat.total, 500);
|
|
assert.equal(freeUsage.quotas.chat.remaining, 410);
|
|
assert.equal(freeUsage.quotas.chat.used, 90);
|
|
assert.equal(freeUsage.quotas.chat.remainingPercentage, 82);
|
|
// completions: untouched → 100% remaining.
|
|
assert.equal(freeUsage.quotas.completions.remaining, 4000);
|
|
assert.equal(freeUsage.quotas.completions.used, 0);
|
|
assert.equal(freeUsage.quotas.completions.remainingPercentage, 100);
|
|
assert.equal(calls[0].headers.Authorization, "token gho-free");
|
|
assert.equal(calls[0].headers["User-Agent"], "GitHubCopilotChat/0.54.0");
|
|
assert.equal(calls[0].headers["Editor-Version"], "vscode/1.126.0");
|
|
assert.equal(calls[0].headers["Editor-Plugin-Version"], "copilot-chat/0.54.0");
|
|
assert.equal(calls[0].headers["X-GitHub-Api-Version"], "2026-06-01");
|
|
|
|
globalThis.fetch = async () => new Response("forbidden", { status: 403 });
|
|
const forbidden: any = await usageService.getUsageForProvider({
|
|
provider: "github",
|
|
accessToken: "gho-expired",
|
|
});
|
|
assert.match(forbidden.message, /re-authenticate/i);
|
|
|
|
const unsupported: any = await usageService.getUsageForProvider({
|
|
provider: "unknown-provider",
|
|
accessToken: "token",
|
|
});
|
|
assert.match(unsupported.message, /not implemented/i);
|
|
});
|
|
|
|
test("usage service covers GitHub paid snapshot edge cases, missing quota payloads and hard failures", async () => {
|
|
globalThis.fetch = async () =>
|
|
new Response(
|
|
JSON.stringify({
|
|
copilot_plan: "student",
|
|
quota_reset_date: new Date(Date.now() + 60_000).toISOString(),
|
|
quota_snapshots: {
|
|
premium_interactions: {
|
|
percent_remaining: 30,
|
|
total: 0,
|
|
},
|
|
chat: {
|
|
used: 10,
|
|
total: 40,
|
|
},
|
|
completions: {
|
|
entitlement: 20,
|
|
remaining: 5,
|
|
},
|
|
},
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
|
|
const paidUsage: any = await usageService.getUsageForProvider({
|
|
provider: "github",
|
|
accessToken: "gho-paid",
|
|
});
|
|
assert.equal(paidUsage.plan, "Copilot Student");
|
|
assert.equal(paidUsage.quotas.premium_interactions.total, 100);
|
|
assert.equal(paidUsage.quotas.premium_interactions.used, 70);
|
|
assert.equal(paidUsage.quotas.chat.remaining, 30);
|
|
assert.equal(paidUsage.quotas.completions.used, 15);
|
|
|
|
globalThis.fetch = async () =>
|
|
new Response(JSON.stringify({ access_type_sku: "odd_tier" }), { status: 200 });
|
|
const missingQuotaPayload: any = await usageService.getUsageForProvider({
|
|
provider: "github",
|
|
accessToken: "gho-odd",
|
|
});
|
|
assert.match(missingQuotaPayload.message, /Unable to parse quota data/i);
|
|
|
|
await assert.rejects(
|
|
() =>
|
|
usageService.getUsageForProvider({
|
|
provider: "github",
|
|
accessToken: "",
|
|
}),
|
|
/No GitHub access token available/i
|
|
);
|
|
|
|
globalThis.fetch = async () => new Response("server down", { status: 500 });
|
|
await assert.rejects(
|
|
() =>
|
|
usageService.getUsageForProvider({
|
|
provider: "github",
|
|
accessToken: "gho-broken",
|
|
}),
|
|
/GitHub API error: server down/i
|
|
);
|
|
});
|
|
|
|
test("usage service covers Antigravity quota parsing, exclusions and forbidden access", async () => {
|
|
const calls: any[] = [];
|
|
|
|
globalThis.fetch = async (url, init = {}) => {
|
|
calls.push({ url: String(url), init });
|
|
|
|
if (String(url).includes("loadCodeAssist")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
allowedTiers: [{ id: "tier_ultra", isDefault: true }],
|
|
cloudaicompanionProject: "ag-project",
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
if (String(url).includes("fetchAvailableModels")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
models: {
|
|
"claude-sonnet-4-6": {
|
|
quotaInfo: {
|
|
remainingFraction: 0.4,
|
|
resetTime: new Date(Date.now() + 60_000).toISOString(),
|
|
},
|
|
},
|
|
tab_flash_lite_preview: {
|
|
quotaInfo: { remainingFraction: 0.1 },
|
|
},
|
|
"gemini-unlimited": {
|
|
quotaInfo: {},
|
|
},
|
|
"gemini-pro-agent": {
|
|
quotaInfo: { remainingFraction: 1 },
|
|
},
|
|
"internal-model": {
|
|
isInternal: true,
|
|
quotaInfo: { remainingFraction: 0.1 },
|
|
},
|
|
},
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
|
|
const usage: any = await usageService.getUsageForProvider({
|
|
provider: "antigravity",
|
|
accessToken: "ag-token",
|
|
});
|
|
|
|
assert.equal(usage.plan, "Ultra");
|
|
// #3184: claude-sonnet-4-6 is user-callable on the Antigravity backend, so its quota is
|
|
// surfaced. tab_flash_lite_preview (not chat-callable), gemini-unlimited (no quota), and
|
|
// internal-model (internal) are still filtered out by the hardening logic.
|
|
assert.deepEqual(Object.keys(usage.quotas).sort(), ["claude-sonnet-4-6", "gemini-pro-agent"]);
|
|
assert.equal(usage.quotas["gemini-pro-agent"].total, 0);
|
|
assert.equal(usage.quotas["gemini-pro-agent"].remainingPercentage, 100);
|
|
assert.equal(usage.quotas["claude-sonnet-4-6"].remainingPercentage, 40);
|
|
const loadCodeAssistCall = calls.find((call) => call.url.includes("loadCodeAssist"));
|
|
assert.match(loadCodeAssistCall?.url, /daily-cloudcode-pa\.sandbox\.googleapis\.com/);
|
|
assert.match(loadCodeAssistCall?.init.headers["User-Agent"], /^vscode\/1\.X\.X \(Antigravity\//);
|
|
assert.equal(loadCodeAssistCall?.init.headers["X-Goog-Api-Client"], undefined);
|
|
assert.equal(loadCodeAssistCall?.init.headers["Client-Metadata"], undefined);
|
|
assert.deepEqual(
|
|
JSON.parse(loadCodeAssistCall?.init.body).metadata,
|
|
getAntigravityLoadCodeAssistMetadata()
|
|
);
|
|
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url).includes("loadCodeAssist")) {
|
|
return new Response("{}", { status: 200 });
|
|
}
|
|
return new Response("forbidden", { status: 403 });
|
|
};
|
|
|
|
const forbidden: any = await usageService.getUsageForProvider({
|
|
provider: "antigravity",
|
|
accessToken: "ag-forbidden",
|
|
});
|
|
assert.match(forbidden.message, /forbidden/i);
|
|
});
|
|
|
|
test("usage service prefers Antigravity retrieveUserQuota over catalog quotaInfo", async () => {
|
|
globalThis.fetch = async (url) => {
|
|
const urlString = String(url);
|
|
|
|
if (urlString.includes("loadCodeAssist")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
allowedTiers: [{ id: "tier_pro", isDefault: true }],
|
|
cloudaicompanionProject: "ag-project",
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
if (urlString.includes("fetchAvailableModels")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
models: {
|
|
"gemini-3.5-flash-high": {
|
|
quotaInfo: {
|
|
remainingFraction: 1,
|
|
resetTime: new Date(Date.now() + 60_000).toISOString(),
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
if (urlString.includes("retrieveUserQuota")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
buckets: [
|
|
{
|
|
modelId: "gemini-3.5-flash-high",
|
|
remainingFraction: 0.25,
|
|
resetTime: new Date(Date.now() + 60_000).toISOString(),
|
|
},
|
|
],
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
|
|
const usage: any = await usageService.getUsageForProvider({
|
|
provider: "antigravity",
|
|
accessToken: `ag-token-live-quota-${Date.now()}`,
|
|
});
|
|
|
|
assert.equal(usage.quotas["gemini-3.5-flash-high"].remainingPercentage, 25);
|
|
assert.equal(usage.quotas["gemini-3.5-flash-high"].used, 750);
|
|
assert.equal(usage.quotas["gemini-3.5-flash-high"].quotaSource, "retrieveUserQuota");
|
|
});
|
|
|
|
test("usage service normalizes retired Antigravity quota bucket ids", async () => {
|
|
globalThis.fetch = async (url) => {
|
|
const urlString = String(url);
|
|
|
|
if (urlString.includes("loadCodeAssist")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
allowedTiers: [{ id: "tier_pro", isDefault: true }],
|
|
cloudaicompanionProject: "ag-project",
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
if (urlString.includes("fetchAvailableModels")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
models: {
|
|
"gemini-3.5-flash-low": { quotaInfo: { remainingFraction: 1 } },
|
|
"gemini-3.5-flash-high": { quotaInfo: { remainingFraction: 1 } },
|
|
"gemini-3-flash-agent": { quotaInfo: { remainingFraction: 1 } },
|
|
"gemini-3.5-flash-extra-low": { quotaInfo: { remainingFraction: 1 } },
|
|
},
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
if (urlString.includes("retrieveUserQuota")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
buckets: [
|
|
{ modelId: "gemini-3-flash-agent", remainingFraction: 0.5 },
|
|
{ modelId: "gemini-3.5-flash-extra-low", remainingFraction: 0.25 },
|
|
],
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
|
|
const usage: any = await usageService.getUsageForProvider({
|
|
provider: "antigravity",
|
|
accessToken: `ag-token-legacy-buckets-${Date.now()}`,
|
|
});
|
|
|
|
assert.equal(usage.quotas["gemini-3-flash-agent"], undefined);
|
|
assert.equal(usage.quotas["gemini-3.5-flash-extra-low"], undefined);
|
|
assert.equal(usage.quotas["gemini-3.5-flash-high"].remainingPercentage, 50);
|
|
assert.equal(usage.quotas["gemini-3.5-flash-medium"].remainingPercentage, 100);
|
|
assert.equal(usage.quotas["gemini-3.5-flash-low"].remainingPercentage, 25);
|
|
});
|
|
|
|
test("usage service retries Antigravity fetchAvailableModels across the shared fallback order", async () => {
|
|
const calls: any[] = [];
|
|
const expectedQuotaUrls = getAntigravityFetchAvailableModelsUrls();
|
|
const finalQuotaUrl = expectedQuotaUrls.at(-1);
|
|
|
|
globalThis.fetch = async (url, init = {}) => {
|
|
calls.push({ url: String(url), init });
|
|
|
|
if (String(url).includes("loadCodeAssist")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
allowedTiers: [{ id: "tier_business", isDefault: true }],
|
|
cloudaicompanionProject: "ag-project",
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
const urlString = String(url);
|
|
if (expectedQuotaUrls.includes(urlString) && urlString !== finalQuotaUrl) {
|
|
return new Response("bad gateway", { status: 502 });
|
|
}
|
|
|
|
return new Response(
|
|
JSON.stringify({
|
|
models: {
|
|
"gemini-pro-agent": {
|
|
quotaInfo: {
|
|
remainingFraction: 0.5,
|
|
resetTime: new Date(Date.now() + 60_000).toISOString(),
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
};
|
|
|
|
const usage: any = await usageService.getUsageForProvider({
|
|
provider: "antigravity",
|
|
accessToken: "ag-fallback",
|
|
});
|
|
|
|
const quotaCalls = calls.filter((call) => call.url.includes("fetchAvailableModels"));
|
|
// ANTIGRAVITY_BASE_URLS order changed: daily first, then cloudcode-pa, then sandbox last
|
|
assert.deepEqual(
|
|
quotaCalls.map((call) => call.url),
|
|
expectedQuotaUrls
|
|
);
|
|
assert.match(quotaCalls[2].init.headers["User-Agent"], /^Antigravity\//);
|
|
assert.equal(usage.plan, "Business");
|
|
assert.ok(usage.quotas["gemini-pro-agent"] !== undefined);
|
|
});
|
|
|
|
test("usage service manual Antigravity refresh bypasses usage TTL caches", async () => {
|
|
process.env.ANTIGRAVITY_CREDITS = "retry";
|
|
let probeCalls = 0;
|
|
let modelCalls = 0;
|
|
let loadCodeAssistCalls = 0;
|
|
|
|
globalThis.fetch = async (url) => {
|
|
const urlStr = String(url);
|
|
if (urlStr.includes("loadCodeAssist")) {
|
|
loadCodeAssistCalls++;
|
|
return new Response(JSON.stringify({ cloudaicompanionProject: "ag-project" }), {
|
|
status: 200,
|
|
});
|
|
}
|
|
|
|
if (urlStr.includes("streamGenerateContent")) {
|
|
probeCalls++;
|
|
return new Response(
|
|
`data: ${JSON.stringify({ remainingCredits: [{ creditType: "GOOGLE_ONE_AI", creditAmount: String(100 - probeCalls) }] })}\n\n`,
|
|
{ status: 200, headers: { "Content-Type": "text/event-stream" } }
|
|
);
|
|
}
|
|
|
|
if (urlStr.includes("fetchAvailableModels")) {
|
|
modelCalls++;
|
|
return new Response(
|
|
JSON.stringify({
|
|
models: {
|
|
"claude-sonnet-4-6": {
|
|
quotaInfo: { remainingFraction: 1 },
|
|
},
|
|
},
|
|
}),
|
|
{ status: 200, headers: { "Content-Type": "application/json" } }
|
|
);
|
|
}
|
|
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
|
|
const connection = {
|
|
id: "ag-manual-refresh-service-test",
|
|
provider: "antigravity",
|
|
accessToken: "ag-manual-service-token",
|
|
projectId: "ag-project",
|
|
};
|
|
|
|
await usageService.getUsageForProvider(connection, { forceRefresh: true });
|
|
await usageService.getUsageForProvider(connection, { forceRefresh: true });
|
|
|
|
assert.equal(probeCalls, 2);
|
|
assert.equal(modelCalls, 2);
|
|
assert.equal(loadCodeAssistCalls, 2);
|
|
});
|
|
|
|
test("usage service handles missing Antigravity access tokens without probing upstream", async () => {
|
|
let fetchCalls = 0;
|
|
|
|
globalThis.fetch = async () => {
|
|
fetchCalls++;
|
|
return new Response("unexpected", { status: 500 });
|
|
};
|
|
|
|
const usage: any = await usageService.getUsageForProvider({
|
|
provider: "antigravity",
|
|
accessToken: undefined,
|
|
});
|
|
|
|
assert.equal(fetchCalls, 0);
|
|
assert.equal(usage.plan, "Free");
|
|
assert.match(usage.message, /Antigravity access token not available/i);
|
|
});
|
|
|
|
test("usage service covers Antigravity tier fallbacks and non-403 upstream failures", async () => {
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url).includes("loadCodeAssist")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
currentTier: { displayName: "Standard" },
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
return new Response("upstream failed", { status: 500 });
|
|
};
|
|
|
|
const failedUsage: any = await usageService.getUsageForProvider({
|
|
provider: "antigravity",
|
|
accessToken: "ag-failed",
|
|
});
|
|
assert.match(failedUsage.message, /Antigravity error: Antigravity API error: 500/i);
|
|
});
|
|
|
|
test("usage service covers Claude OAuth success, legacy fallback and permissions message", async () => {
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url).includes("/api/oauth/usage")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
tier: "Claude Max",
|
|
five_hour: { utilization: 90, resets_at: new Date(Date.now() + 60_000).toISOString() },
|
|
seven_day: { utilization: 20, resets_at: new Date(Date.now() + 120_000).toISOString() },
|
|
seven_day_sonnet: {
|
|
utilization: 35,
|
|
resets_at: new Date(Date.now() + 120_000).toISOString(),
|
|
},
|
|
extra_usage: { queued: true },
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
|
|
const oauthUsage: any = await usageService.getUsageForProvider({
|
|
provider: "claude",
|
|
accessToken: "claude-oauth",
|
|
});
|
|
assert.equal(oauthUsage.plan, "Claude Max");
|
|
assert.equal(oauthUsage.quotas["session (5h)"].remaining, 10);
|
|
assert.equal(oauthUsage.quotas["weekly (7d)"].remaining, 80);
|
|
assert.equal(oauthUsage.quotas["weekly sonnet (7d)"].remaining, 65);
|
|
assert.deepEqual(oauthUsage.extraUsage, { queued: true });
|
|
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url).includes("/api/oauth/usage")) {
|
|
return new Response("fallback", { status: 500 });
|
|
}
|
|
if (String(url).endsWith("/v1/settings")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
organization_id: "org_123",
|
|
organization_name: "Anthropic Org",
|
|
plan: "team",
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
if (String(url).includes("/organizations/org_123/usage")) {
|
|
return new Response(JSON.stringify({ weekly: { used: 10 } }), { status: 200 });
|
|
}
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
|
|
const legacyUsage: any = await usageService.getUsageForProvider({
|
|
provider: "claude",
|
|
accessToken: "claude-legacy",
|
|
});
|
|
assert.equal(legacyUsage.plan, "team");
|
|
assert.equal(legacyUsage.organization, "Anthropic Org");
|
|
assert.deepEqual(legacyUsage.quotas, { weekly: { used: 10 } });
|
|
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url).includes("/api/oauth/usage")) {
|
|
return new Response("fallback", { status: 500 });
|
|
}
|
|
return new Response("denied", { status: 403 });
|
|
};
|
|
|
|
const permissionsMessage: any = await usageService.getUsageForProvider({
|
|
provider: "claude",
|
|
accessToken: "claude-denied",
|
|
});
|
|
assert.match(permissionsMessage.message, /admin permissions/i);
|
|
});
|
|
|
|
test("usage service covers Claude default-plan fallback, legacy org denial and fetch failures", async () => {
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url).includes("/api/oauth/usage")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
five_hour: { utilization: 45, resets_at: new Date(Date.now() + 60_000).toISOString() },
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
|
|
const defaultPlan: any = await usageService.getUsageForProvider({
|
|
provider: "claude",
|
|
accessToken: "claude-default",
|
|
});
|
|
assert.equal(defaultPlan.plan, undefined);
|
|
assert.equal(defaultPlan.extraUsage, null);
|
|
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url).includes("/api/oauth/usage")) {
|
|
return new Response("fallback", { status: 500 });
|
|
}
|
|
if (String(url).endsWith("/v1/settings")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
organization_id: "org_denied",
|
|
organization_name: "Denied Org",
|
|
plan: "enterprise",
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
return new Response("forbidden", { status: 403 });
|
|
};
|
|
|
|
const orgDenied: any = await usageService.getUsageForProvider({
|
|
provider: "claude",
|
|
accessToken: "claude-org-denied",
|
|
});
|
|
assert.equal(orgDenied.plan, "enterprise");
|
|
assert.match(orgDenied.message, /admin access/i);
|
|
|
|
globalThis.fetch = async () => {
|
|
throw new Error("claude usage offline");
|
|
};
|
|
const fetchFailure: any = await usageService.getUsageForProvider({
|
|
provider: "claude",
|
|
accessToken: "claude-offline",
|
|
});
|
|
assert.match(fetchFailure.message, /Unable to fetch usage: claude usage offline/i);
|
|
});
|
|
|
|
test("usage service covers Codex, Kiro and Kimi usage parsing and error branches", async () => {
|
|
globalThis.fetch = async (url, init = {}) => {
|
|
if (String(url).includes("/backend-api/wham/usage")) {
|
|
assert.equal((init as any).headers["chatgpt-account-id"], "workspace-123");
|
|
return new Response(
|
|
JSON.stringify({
|
|
plan_type: "plus",
|
|
rate_limit: {
|
|
limit_reached: false,
|
|
primary_window: {
|
|
used_percent: 25,
|
|
reset_after_seconds: 30,
|
|
},
|
|
secondary_window: {
|
|
used_percent: 50,
|
|
reset_at: Math.floor(Date.now() / 1000) + 120,
|
|
},
|
|
},
|
|
code_review_rate_limit: {
|
|
primary_window: {
|
|
used_percent: 40,
|
|
remaining_count: 6,
|
|
reset_after_seconds: 45,
|
|
},
|
|
},
|
|
additional_rate_limits: [
|
|
{
|
|
limit_id: "codex_bengalfox",
|
|
limit_name: "GPT-5.3-Codex-Spark",
|
|
metered_feature: "gpt_5_3_codex_spark",
|
|
rate_limit: {
|
|
primary_window: {
|
|
used_percent: 90,
|
|
reset_after_seconds: 60,
|
|
},
|
|
secondary_window: {
|
|
used_percent: 20,
|
|
reset_after_seconds: 600,
|
|
},
|
|
},
|
|
},
|
|
],
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
if (String(url) === "https://codewhisperer.us-east-1.amazonaws.com") {
|
|
return new Response(
|
|
JSON.stringify({
|
|
subscriptionInfo: { subscriptionTitle: "Kiro Pro" },
|
|
nextDateReset: new Date(Date.now() + 300_000).toISOString(),
|
|
usageBreakdownList: [
|
|
{
|
|
resourceType: "AGENTIC_REQUEST",
|
|
currentUsageWithPrecision: 12,
|
|
usageLimitWithPrecision: 20,
|
|
freeTrialInfo: {
|
|
currentUsageWithPrecision: 2,
|
|
usageLimitWithPrecision: 5,
|
|
},
|
|
},
|
|
],
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
if (String(url).includes("/coding/v1/usages")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
user: { membership: { level: "LEVEL_ADVANCED" } },
|
|
usage: {
|
|
limit: "100",
|
|
used: "92",
|
|
remaining: "8",
|
|
resetTime: new Date(Date.now() + 600_000).toISOString(),
|
|
},
|
|
limits: [
|
|
{
|
|
detail: {
|
|
limit: "20",
|
|
remaining: "3",
|
|
reset_at: new Date(Date.now() + 30_000).toISOString(),
|
|
},
|
|
},
|
|
],
|
|
five_hour: {
|
|
utilization: 25,
|
|
resets_at: new Date(Date.now() + 600_000).toISOString(),
|
|
},
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
|
|
const codex: any = await usageService.getUsageForProvider({
|
|
provider: "codex",
|
|
accessToken: "codex-token",
|
|
providerSpecificData: { workspaceId: "workspace-123" },
|
|
});
|
|
assert.equal(codex.plan, "plus");
|
|
assert.equal(codex.quotas.session.remaining, 75);
|
|
assert.equal(codex.quotas.weekly.remaining, 50);
|
|
assert.equal(codex.quotas.code_review.remaining, 60);
|
|
assert.equal(codex.quotas.gpt_5_3_codex_spark_session.remaining, 10);
|
|
assert.equal(codex.quotas.gpt_5_3_codex_spark_session.displayName, "GPT-5.3-Codex-Spark");
|
|
assert.equal(codex.quotas.gpt_5_3_codex_spark_weekly.remaining, 80);
|
|
assert.equal(codex.quotas.gpt_5_3_codex_spark_weekly.displayName, "GPT-5.3-Codex-Spark Weekly");
|
|
|
|
const kiroNoArn: any = await usageService.getUsageForProvider({
|
|
provider: "kiro",
|
|
accessToken: "kiro-token",
|
|
providerSpecificData: {},
|
|
});
|
|
assert.match(kiroNoArn.message, /Profile ARN not available/i);
|
|
|
|
const kiro: any = await usageService.getUsageForProvider({
|
|
provider: "kiro",
|
|
accessToken: "kiro-token",
|
|
providerSpecificData: { profileArn: "arn:test:kiro" },
|
|
});
|
|
assert.equal(kiro.plan, "Kiro Pro");
|
|
assert.equal(kiro.quotas.agentic_request.used, 12);
|
|
assert.equal(kiro.quotas.agentic_request_freetrial.remaining, 3);
|
|
|
|
const amazonQ: any = await usageService.getUsageForProvider({
|
|
provider: "amazon-q",
|
|
accessToken: "amazon-q-token",
|
|
providerSpecificData: { profileArn: "arn:test:amazon-q" },
|
|
});
|
|
assert.equal(amazonQ.plan, "Kiro Pro");
|
|
assert.equal(amazonQ.quotas.agentic_request.used, 12);
|
|
assert.equal(amazonQ.quotas.agentic_request_freetrial.remaining, 3);
|
|
|
|
const kimi: any = await usageService.getUsageForProvider({
|
|
provider: "kimi-coding",
|
|
accessToken: "kimi-token",
|
|
});
|
|
assert.equal(kimi.plan, "Allegro");
|
|
assert.equal(kimi.quotas.Weekly.remaining, 8);
|
|
assert.equal(kimi.quotas.Ratelimit.remaining, 3);
|
|
assert.equal(kimi.quotas["session (5h)"].remaining, 25);
|
|
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url).includes("/coding/v1/usages")) {
|
|
return new Response("bad gateway", { status: 502 });
|
|
}
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
|
|
const kimiError: any = await usageService.getUsageForProvider({
|
|
provider: "kimi-coding",
|
|
accessToken: "kimi-error",
|
|
});
|
|
assert.match(kimiError.message, /API Error 502/i);
|
|
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url).includes("/coding/v1/usages")) {
|
|
return new Response("not-json", { status: 200 });
|
|
}
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
|
|
const kimiInvalidJson: any = await usageService.getUsageForProvider({
|
|
provider: "kimi-coding",
|
|
accessToken: "kimi-invalid-json",
|
|
});
|
|
assert.match(kimiInvalidJson.message, /Invalid JSON response/i);
|
|
});
|
|
|
|
test("usage service covers Codex auth failures, Kiro hard failures, Kimi no-quota fallbacks and Qwen catch branch", async () => {
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url).includes("/backend-api/wham/usage")) {
|
|
return new Response("nope", { status: 401 });
|
|
}
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
const codexDenied: any = await usageService.getUsageForProvider({
|
|
provider: "codex",
|
|
accessToken: "codex-denied",
|
|
});
|
|
assert.match(codexDenied.message, /re-authenticate/i);
|
|
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url).includes("/backend-api/wham/usage")) {
|
|
return new Response("boom", { status: 500 });
|
|
}
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
const codexBroken: any = await usageService.getUsageForProvider({
|
|
provider: "codex",
|
|
accessToken: "codex-broken",
|
|
});
|
|
assert.match(codexBroken.message, /Codex API error: 500/i);
|
|
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url) === "https://codewhisperer.us-east-1.amazonaws.com") {
|
|
return new Response("bad request", { status: 400 });
|
|
}
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
await assert.rejects(
|
|
() =>
|
|
usageService.getUsageForProvider({
|
|
provider: "kiro",
|
|
accessToken: "kiro-broken",
|
|
providerSpecificData: { profileArn: "arn:test:broken" },
|
|
}),
|
|
/Failed to fetch Kiro usage: Kiro API error \(400\): bad request/
|
|
);
|
|
|
|
globalThis.fetch = async (url) => {
|
|
if (String(url).includes("/coding/v1/usages")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
user: { membership: { level: "LEVEL_EXPERIMENTAL" } },
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
const kimiNoQuota: any = await usageService.getUsageForProvider({
|
|
provider: "kimi-coding",
|
|
accessToken: "kimi-no-quota",
|
|
});
|
|
assert.equal(kimiNoQuota.plan, "experimental");
|
|
assert.match(kimiNoQuota.message, /Usage tracked per request/i);
|
|
|
|
globalThis.fetch = async () => {
|
|
throw new Error("kimi offline");
|
|
};
|
|
const kimiOffline: any = await usageService.getUsageForProvider({
|
|
provider: "kimi-coding",
|
|
accessToken: "kimi-offline",
|
|
});
|
|
assert.match(kimiOffline.message, /Unable to fetch usage: kimi offline/i);
|
|
|
|
const qwenCatch: any = await usageService.getUsageForProvider({
|
|
provider: "qwen",
|
|
accessToken: "qwen-catch",
|
|
providerSpecificData: {
|
|
get resourceUrl() {
|
|
throw new Error("resource lookup failed");
|
|
},
|
|
},
|
|
});
|
|
assert.equal(qwenCatch.message, "Unable to fetch Qwen usage.");
|
|
});
|
|
|
|
test("usage service covers Qwen, Qoder, GLM, Z.AI and GLMT branches", async () => {
|
|
const qwenMissingUrl: any = await usageService.getUsageForProvider({
|
|
provider: "qwen",
|
|
accessToken: "qwen-token",
|
|
providerSpecificData: {},
|
|
});
|
|
assert.match(qwenMissingUrl.message, /No resource URL/i);
|
|
|
|
const qwen: any = await usageService.getUsageForProvider({
|
|
provider: "qwen",
|
|
accessToken: "qwen-token",
|
|
providerSpecificData: { resourceUrl: "https://example.com/resource" },
|
|
});
|
|
assert.match(qwen.message, /Usage tracked per request/i);
|
|
|
|
// Qoder now reads its PAT from `apiKey` (not `accessToken`); with no PAT the
|
|
// usage fetcher returns a friendly prompt instead of hitting the network.
|
|
const qoder: any = await usageService.getUsageForProvider({
|
|
provider: "qoder",
|
|
accessToken: "qoder-token",
|
|
});
|
|
assert.match(qoder.message, /Personal Access Token/i);
|
|
|
|
const glmMissingKey: any = await usageService.getUsageForProvider({
|
|
provider: "glm",
|
|
apiKey: "",
|
|
});
|
|
assert.equal(
|
|
glmMissingKey.message,
|
|
"API key not available. Add a coding plan API key to view usage."
|
|
);
|
|
|
|
globalThis.fetch = async (url, init = {}) => {
|
|
if (String(url).includes("/api/monitor/usage/quota/limit")) {
|
|
assert.equal((init as any).headers.Authorization, "Bearer glm-key");
|
|
return new Response(
|
|
JSON.stringify({
|
|
data: {
|
|
level: "pro",
|
|
limits: [
|
|
{
|
|
type: "TIME_LIMIT",
|
|
usage: 1000,
|
|
currentValue: 12,
|
|
remaining: 988,
|
|
percentage: "1.2",
|
|
nextResetTime: Date.now() + 30 * 24 * 60 * 60 * 1000,
|
|
usageDetails: [
|
|
{ modelCode: "search-prime", usage: 5 },
|
|
{ modelCode: "web-reader", usage: 7 },
|
|
{ modelCode: "zread", usage: 0 },
|
|
],
|
|
},
|
|
{
|
|
type: "TOKENS_LIMIT",
|
|
unit: 3,
|
|
number: 5,
|
|
percentage: "64",
|
|
nextResetTime: Date.now() + 120_000,
|
|
},
|
|
{
|
|
type: "TOKENS_LIMIT",
|
|
unit: 4,
|
|
number: 7,
|
|
percentage: "25",
|
|
nextResetTime: Date.now() + 7 * 24 * 60 * 60 * 1000,
|
|
},
|
|
{
|
|
type: "OTHER_LIMIT",
|
|
percentage: "10",
|
|
},
|
|
],
|
|
},
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
|
|
const glm: any = await usageService.getUsageForProvider({
|
|
provider: "glm",
|
|
apiKey: "glm-key",
|
|
providerSpecificData: { apiRegion: "invalid-region" },
|
|
});
|
|
assert.equal(glm.plan, "Pro");
|
|
assert.equal(glm.quotas.session.used, 64);
|
|
assert.equal(glm.quotas.session.remaining, 36);
|
|
assert.equal(glm.quotas.weekly.used, 25);
|
|
assert.equal(glm.quotas.weekly.remaining, 75);
|
|
assert.equal(glm.quotas.mcp_monthly.used, 12);
|
|
assert.equal(glm.quotas.mcp_monthly.remaining, 988);
|
|
assert.equal(glm.quotas.mcp_monthly.remainingPercentage, 99);
|
|
assert.equal(glm.quotas.mcp_monthly.displayName, "Monthly");
|
|
assert.deepEqual(glm.quotas.mcp_monthly.details, [
|
|
{ name: "search-prime", used: 5 },
|
|
{ name: "web-reader", used: 7 },
|
|
{ name: "zread", used: 0 },
|
|
]);
|
|
|
|
const glmt: any = await usageService.getUsageForProvider({
|
|
provider: "glmt",
|
|
apiKey: "glm-key",
|
|
providerSpecificData: { apiRegion: "international" },
|
|
});
|
|
assert.equal(glmt.plan, "Pro");
|
|
assert.equal(glmt.quotas.session.used, 64);
|
|
assert.equal(glmt.quotas.session.displayName, "5 Hours Quota");
|
|
assert.equal(glmt.quotas.weekly.remaining, 75);
|
|
assert.equal(glmt.quotas.weekly.displayName, "Weekly Quota");
|
|
|
|
let glmCnUrl = "";
|
|
globalThis.fetch = async (url) => {
|
|
glmCnUrl = String(url);
|
|
return new Response(
|
|
JSON.stringify({
|
|
data: {
|
|
planName: "Lite Plan",
|
|
limits: [{ type: "TOKENS_LIMIT", percentage: "64" }],
|
|
},
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
};
|
|
const glmCn: any = await usageService.getUsageForProvider({
|
|
provider: "glm-cn",
|
|
apiKey: "glm-cn-key",
|
|
providerSpecificData: { apiRegion: "international" },
|
|
});
|
|
assert.match(glmCnUrl, /open\.bigmodel\.cn/);
|
|
assert.equal(glmCn.plan, "Lite");
|
|
assert.equal(glmCn.quotas.session.remaining, 36);
|
|
|
|
globalThis.fetch = async () => new Response("nope", { status: 401 });
|
|
await assert.rejects(
|
|
() =>
|
|
usageService.getUsageForProvider({
|
|
provider: "glm",
|
|
apiKey: "glm-bad",
|
|
}),
|
|
/Invalid API key/
|
|
);
|
|
});
|
|
|
|
test("GLM usage maps unit=6 one-week token limits to the weekly quota window", async () => {
|
|
const resetAtMs = Date.now() + 7 * 24 * 60 * 60 * 1000;
|
|
globalThis.fetch = async () =>
|
|
new Response(
|
|
JSON.stringify({
|
|
data: {
|
|
planName: "Pro Plan",
|
|
limits: [
|
|
{
|
|
type: "TOKENS_LIMIT",
|
|
unit: 6,
|
|
number: 1,
|
|
percentage: "100",
|
|
nextResetTime: resetAtMs,
|
|
},
|
|
],
|
|
},
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
|
|
const usage: any = await usageService.getUsageForProvider({
|
|
provider: "glm",
|
|
apiKey: "glm-weekly-key",
|
|
});
|
|
|
|
assert.ok(usage.quotas.weekly, "unit=6/number=1 should be treated as weekly quota");
|
|
assert.equal(usage.quotas.weekly.used, 100);
|
|
assert.equal(usage.quotas.weekly.remaining, 0);
|
|
assert.equal(usage.quotas.weekly.resetAt, new Date(resetAtMs).toISOString());
|
|
assert.equal(usage.quotas.session, undefined);
|
|
});
|
|
|
|
test("usage service covers MiniMax usage parsing, documented endpoint fallback and auth errors", async () => {
|
|
const calls: any[] = [];
|
|
const beforeCall = Date.now();
|
|
|
|
globalThis.fetch = async (url, init = {}) => {
|
|
calls.push({ url: String(url), init });
|
|
|
|
if (String(url) === "https://www.minimax.io/v1/token_plan/remains") {
|
|
return new Response("missing", { status: 404 });
|
|
}
|
|
|
|
if (String(url) === "https://api.minimax.io/v1/api/openplatform/coding_plan/remains") {
|
|
assert.equal((init as any).headers.Authorization, "Bearer minimax-key");
|
|
assert.equal((init as any).headers.Accept, "application/json");
|
|
|
|
return new Response(
|
|
JSON.stringify({
|
|
base_resp: { status_code: 0, status_msg: "ok" },
|
|
plan_name: "MiniMax Coding Plan Lite",
|
|
model_remains: [
|
|
{
|
|
model_name: "MiniMax-M2.7",
|
|
remains_time: 300_000,
|
|
current_interval_total_count: 1500,
|
|
current_interval_usage_count: 1100,
|
|
current_weekly_total_count: 15000,
|
|
current_weekly_usage_count: 13800,
|
|
weekly_remains_time: 1_800_000,
|
|
},
|
|
{
|
|
model_name: "image-01",
|
|
remains_time: 86_400_000,
|
|
current_interval_total_count: 50,
|
|
current_interval_usage_count: 45,
|
|
},
|
|
],
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
}
|
|
|
|
if (String(url) === "https://www.minimaxi.com/v1/api/openplatform/coding_plan/remains") {
|
|
return new Response(
|
|
JSON.stringify({
|
|
base_resp: {
|
|
status_code: 1004,
|
|
status_msg: "token plan api key invalid",
|
|
},
|
|
}),
|
|
{ status: 403 }
|
|
);
|
|
}
|
|
|
|
throw new Error(`unexpected fetch: ${url}`);
|
|
};
|
|
|
|
const usage: any = await usageService.getUsageForProvider({
|
|
provider: "minimax",
|
|
apiKey: "minimax-key",
|
|
});
|
|
|
|
assert.deepEqual(
|
|
calls.map((call) => call.url),
|
|
[
|
|
"https://www.minimax.io/v1/token_plan/remains",
|
|
"https://api.minimax.io/v1/api/openplatform/coding_plan/remains",
|
|
]
|
|
);
|
|
assert.equal(usage.plan, "Lite");
|
|
assert.equal(usage.quotas["session (5h)"].used, 400);
|
|
assert.equal(usage.quotas["session (5h)"].total, 1500);
|
|
assert.equal(usage.quotas["session (5h)"].remaining, 1100);
|
|
assert.equal(usage.quotas["weekly (7d)"].used, 1200);
|
|
assert.equal(usage.quotas["weekly (7d)"].total, 15000);
|
|
assert.equal(usage.quotas["weekly (7d)"].remainingPercentage, 92);
|
|
assert.ok(Date.parse(usage.quotas["session (5h)"].resetAt) >= beforeCall + 240_000);
|
|
|
|
const invalid: any = await usageService.getUsageForProvider({
|
|
provider: "minimax-cn",
|
|
apiKey: "bad-minimax-key",
|
|
});
|
|
assert.match(invalid.message, /Token Plan API key/i);
|
|
});
|
|
|
|
test("usage service treats MiniMax token-plan counts as used usage", async () => {
|
|
const beforeCall = Date.now();
|
|
|
|
globalThis.fetch = async (url, init = {}) => {
|
|
assert.equal(String(url), "https://www.minimax.io/v1/token_plan/remains");
|
|
assert.equal((init as any).headers.Authorization, "Bearer minimax-key");
|
|
|
|
return new Response(
|
|
JSON.stringify({
|
|
base_resp: { status_code: 0, status_msg: "ok" },
|
|
model_remains: [
|
|
{
|
|
model_name: "MiniMax-M2.7",
|
|
remains_time: 300_000,
|
|
current_interval_total_count: 15000,
|
|
current_interval_usage_count: 13,
|
|
current_weekly_total_count: 150000,
|
|
current_weekly_usage_count: 66,
|
|
weekly_remains_time: 604_800_000,
|
|
},
|
|
],
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
};
|
|
|
|
const usage: any = await usageService.getUsageForProvider({
|
|
provider: "minimax",
|
|
apiKey: "minimax-key",
|
|
});
|
|
|
|
assert.equal(usage.plan, "Max");
|
|
assert.equal(usage.quotas["session (5h)"].used, 13);
|
|
assert.equal(usage.quotas["session (5h)"].remaining, 14987);
|
|
assert.equal(usage.quotas["session (5h)"].remainingPercentage, 99.91333333333333);
|
|
assert.equal(usage.quotas["weekly (7d)"].used, 66);
|
|
assert.equal(usage.quotas["weekly (7d)"].remaining, 149934);
|
|
assert.equal(usage.quotas["weekly (7d)"].remainingPercentage, 99.956);
|
|
assert.ok(Date.parse(usage.quotas["session (5h)"].resetAt) >= beforeCall + 240_000);
|
|
});
|
|
|
|
test("usage helper branches cover reset parsing, GitHub quota math, and plan inference fallbacks", () => {
|
|
const fixedDate = new Date("2026-01-02T03:04:05.000Z");
|
|
|
|
assert.equal(__testing.parseResetTime(null), null);
|
|
assert.equal(__testing.parseResetTime(0), null);
|
|
assert.equal(__testing.parseResetTime(fixedDate), fixedDate.toISOString());
|
|
assert.equal(__testing.parseResetTime(fixedDate.getTime()), fixedDate.toISOString());
|
|
assert.equal(__testing.parseResetTime("not-a-date"), null);
|
|
|
|
assert.equal(__testing.formatGitHubQuotaSnapshot({}), null);
|
|
assert.deepEqual(
|
|
__testing.formatGitHubQuotaSnapshot({ entitlement: 20, remaining: 5 }, fixedDate.toISOString()),
|
|
{
|
|
used: 15,
|
|
total: 20,
|
|
remaining: 5,
|
|
remainingPercentage: 25,
|
|
resetAt: fixedDate.toISOString(),
|
|
unlimited: false,
|
|
}
|
|
);
|
|
assert.deepEqual(__testing.formatGitHubQuotaSnapshot({ total: 10, used: 4 }), {
|
|
used: 4,
|
|
total: 10,
|
|
remaining: 6,
|
|
remainingPercentage: 60,
|
|
resetAt: null,
|
|
unlimited: false,
|
|
});
|
|
assert.deepEqual(__testing.formatGitHubQuotaSnapshot({ percent_remaining: 30 }), {
|
|
used: 70,
|
|
total: 100,
|
|
remaining: 30,
|
|
remainingPercentage: 30,
|
|
resetAt: null,
|
|
unlimited: false,
|
|
});
|
|
assert.deepEqual(__testing.formatGitHubQuotaSnapshot({ unlimited: true }), {
|
|
used: 0,
|
|
total: 0,
|
|
remaining: undefined,
|
|
remainingPercentage: undefined,
|
|
resetAt: null,
|
|
unlimited: true,
|
|
});
|
|
|
|
assert.equal(
|
|
__testing.inferGitHubPlanName(
|
|
{ access_type_sku: "copilot_pro_plus" },
|
|
{ used: 0, total: 0, resetAt: null, unlimited: false }
|
|
),
|
|
"Copilot Pro+"
|
|
);
|
|
assert.equal(
|
|
__testing.inferGitHubPlanName(
|
|
{ copilot_plan: "enterprise" },
|
|
{ used: 0, total: 0, resetAt: null, unlimited: false }
|
|
),
|
|
"Copilot Enterprise"
|
|
);
|
|
assert.equal(
|
|
__testing.inferGitHubPlanName(
|
|
{
|
|
copilot_plan: "individual",
|
|
monthly_quotas: { premium_interactions: 300 },
|
|
},
|
|
{ used: 10, total: 300, resetAt: null, unlimited: false }
|
|
),
|
|
"Copilot Pro"
|
|
);
|
|
assert.equal(
|
|
__testing.inferGitHubPlanName(
|
|
{
|
|
monthly_quotas: { premium_interactions: 300 },
|
|
},
|
|
{ used: 10, total: 300, resetAt: null, unlimited: false }
|
|
),
|
|
"Copilot Business"
|
|
);
|
|
assert.equal(
|
|
__testing.inferGitHubPlanName(
|
|
{
|
|
monthly_quotas: { chat: 50 },
|
|
},
|
|
null
|
|
),
|
|
"Copilot Free"
|
|
);
|
|
assert.equal(
|
|
__testing.inferGitHubPlanName(
|
|
{
|
|
access_type_sku: "student_seat",
|
|
},
|
|
null
|
|
),
|
|
"Copilot Student"
|
|
);
|
|
assert.equal(__testing.inferGitHubPlanName({}, null), "GitHub Copilot");
|
|
});
|
|
|
|
test("usage helper branches cover Antigravity plan label fallbacks", () => {
|
|
assert.equal(__testing.getAntigravityPlanLabel(null), "Free");
|
|
assert.equal(
|
|
__testing.getMiniMaxPlanLabel({}, [{ current_interval_total_count: 1500 }]),
|
|
"Starter"
|
|
);
|
|
assert.equal(__testing.getMiniMaxPlanLabel({}, [{ current_interval_total_count: 4500 }]), "Plus");
|
|
assert.equal(__testing.getMiniMaxPlanLabel({}, [{ current_interval_total_count: 15000 }]), "Max");
|
|
assert.equal(
|
|
__testing.getAntigravityPlanLabel({
|
|
paidTier: { name: "Google One AI Premium" },
|
|
currentTier: { id: "free-tier" },
|
|
}),
|
|
"Pro"
|
|
);
|
|
assert.equal(
|
|
__testing.getAntigravityPlanLabel({
|
|
currentTier: { id: "tier_google_one_ai_pro" },
|
|
allowedTiers: [{ id: "free-tier", isDefault: true }],
|
|
}),
|
|
"Pro"
|
|
);
|
|
assert.equal(
|
|
__testing.getAntigravityPlanLabel({
|
|
allowedTiers: [{ id: "tier_pro", isDefault: true }],
|
|
}),
|
|
"Pro"
|
|
);
|
|
assert.equal(
|
|
__testing.getAntigravityPlanLabel({
|
|
currentTier: { displayName: "Standard" },
|
|
}),
|
|
"Business"
|
|
);
|
|
assert.equal(
|
|
__testing.getAntigravityPlanLabel({
|
|
currentTier: { id: "tier_legacy" },
|
|
}),
|
|
"Free"
|
|
);
|
|
assert.equal(
|
|
__testing.getAntigravityPlanLabel({
|
|
currentTier: { name: "custom sky" },
|
|
}),
|
|
"Custom sky"
|
|
);
|
|
assert.equal(
|
|
__testing.getAntigravityPlanLabel(
|
|
{ currentTier: { name: "TIER_UNKNOWN_CUSTOM" } },
|
|
{ allowedTiers: [{ id: "tier_pro", isDefault: true }] }
|
|
),
|
|
"Pro"
|
|
);
|
|
});
|
|
|
|
test("usage service covers NanoGPT PRO weekly token quota, FREE plan, auth denial and fetch failures", async () => {
|
|
const resetAt = Date.now() + 7 * 24 * 60 * 60 * 1000;
|
|
globalThis.fetch = async (url, init = {}) => {
|
|
assert.equal(String(url), "https://nano-gpt.com/api/subscription/v1/usage");
|
|
assert.equal((init as any).headers.Authorization, "Bearer nanogpt-pro-key");
|
|
return new Response(
|
|
JSON.stringify({
|
|
active: true,
|
|
limits: {
|
|
weeklyInputTokens: 60_000_000,
|
|
dailyInputTokens: null,
|
|
dailyImages: 100,
|
|
},
|
|
dailyInputTokens: null,
|
|
weeklyInputTokens: {
|
|
used: 31_157_321,
|
|
remaining: 28_842_679,
|
|
percentUsed: 0.5192886833333333,
|
|
resetAt,
|
|
},
|
|
dailyImages: {
|
|
used: 0,
|
|
remaining: 100,
|
|
percentUsed: 0,
|
|
resetAt: Date.now() + 24 * 60 * 60 * 1000,
|
|
},
|
|
state: "active",
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
};
|
|
|
|
const proUsage: any = await usageService.getUsageForProvider({
|
|
provider: "nanogpt",
|
|
apiKey: "nanogpt-pro-key",
|
|
});
|
|
|
|
assert.equal(proUsage.plan, "PRO");
|
|
assert.ok(proUsage.quotas["Weekly Tokens"]);
|
|
assert.equal(proUsage.quotas["Weekly Tokens"].used, 31_157_321);
|
|
assert.equal(proUsage.quotas["Weekly Tokens"].total, 60_000_000);
|
|
assert.equal(proUsage.quotas["Weekly Tokens"].remaining, 28_842_679);
|
|
assert.ok(proUsage.quotas["Weekly Tokens"].remainingPercentage < 100);
|
|
assert.equal(proUsage.quotas["Weekly Tokens"].resetAt, new Date(resetAt).toISOString());
|
|
assert.equal(proUsage.quotas["Daily Images"].used, 0);
|
|
assert.equal(proUsage.quotas["Daily Images"].remaining, 100);
|
|
assert.equal(proUsage.quotas["Daily Images"].remainingPercentage, 100);
|
|
|
|
globalThis.fetch = async (url, init = {}) => {
|
|
assert.equal(String(url), "https://nano-gpt.com/api/subscription/v1/usage");
|
|
assert.equal((init as any).headers.Authorization, "Bearer nanogpt-free-key");
|
|
return new Response(
|
|
JSON.stringify({
|
|
active: false,
|
|
limits: {},
|
|
state: "cancelled",
|
|
}),
|
|
{ status: 200 }
|
|
);
|
|
};
|
|
|
|
const freeUsage: any = await usageService.getUsageForProvider({
|
|
provider: "nanogpt",
|
|
apiKey: "nanogpt-free-key",
|
|
});
|
|
|
|
assert.equal(freeUsage.plan, "FREE");
|
|
assert.deepEqual(freeUsage.quotas, {});
|
|
|
|
const noKey: any = await usageService.getUsageForProvider({
|
|
provider: "nanogpt",
|
|
apiKey: "",
|
|
});
|
|
assert.match(noKey.message, /NanoGPT API key not available/i);
|
|
|
|
globalThis.fetch = async () => new Response("unauthorized", { status: 401 });
|
|
const invalidKey: any = await usageService.getUsageForProvider({
|
|
provider: "nanogpt",
|
|
apiKey: "nanogpt-bad-key",
|
|
});
|
|
assert.match(invalidKey.message, /Invalid NanoGPT API key/i);
|
|
|
|
globalThis.fetch = async () => {
|
|
throw new Error("nano-gpt.com unreachable");
|
|
};
|
|
const fetchError: any = await usageService.getUsageForProvider({
|
|
provider: "nanogpt",
|
|
apiKey: "nanogpt-fail-key",
|
|
});
|
|
assert.match(fetchError.message, /Unable to fetch usage: nano-gpt.com unreachable/i);
|
|
});
|
|
|
|
test("usage service opencode happy path returns plan and three quota windows", async () => {
|
|
globalThis.fetch = async () =>
|
|
new Response(
|
|
JSON.stringify({
|
|
quota: {
|
|
window_5h: { used: 3.0, limit: 12.0, reset_at: null },
|
|
window_weekly: { used: 10.0, limit: 30.0, reset_at: null },
|
|
window_monthly: { used: 25.0, limit: 60.0, reset_at: null },
|
|
},
|
|
}),
|
|
{ status: 200, headers: { "content-type": "application/json" } }
|
|
);
|
|
|
|
const result: any = await usageService.getUsageForProvider({
|
|
provider: "opencode",
|
|
apiKey: "oc-happy-key",
|
|
});
|
|
|
|
assert.equal(result.plan, "OpenCode Go");
|
|
assert.ok(result.quotas["window_5h"], "should have window_5h quota");
|
|
assert.ok(result.quotas["window_weekly"], "should have window_weekly quota");
|
|
assert.ok(result.quotas["window_monthly"], "should have window_monthly quota");
|
|
assert.equal(result.quotas["window_5h"].total, 12);
|
|
assert.equal(result.quotas["window_weekly"].total, 30);
|
|
assert.equal(result.quotas["window_monthly"].total, 60);
|
|
});
|
|
|
|
test("usage service opencode no-key returns missing-key message", async () => {
|
|
const result: any = await usageService.getUsageForProvider({
|
|
provider: "opencode",
|
|
apiKey: "",
|
|
});
|
|
|
|
assert.match(result.message, /API key not available/i);
|
|
});
|
|
|
|
test("usage service opencode catch-block uses sanitizeErrorMessage (no raw stack in output)", async () => {
|
|
// getOpencodeUsage's catch block now calls sanitizeErrorMessage(error) instead of
|
|
// (error as Error).message. Verify the sanitization contract by directly invoking
|
|
// the exposed __testing.getOpencodeUsage with a fake fetchOpencodeQuota that
|
|
// throws an error whose message embeds a stack-trace path.
|
|
//
|
|
// Because fetchOpencodeQuota is fail-open (always returns null on error), the
|
|
// only way to exercise the catch branch inside getOpencodeUsage is to import the
|
|
// sanitization function directly and assert it behaves correctly for the exact
|
|
// error format used in that catch block — confirming the fix is load-bearing.
|
|
const { sanitizeErrorMessage } = await import("../../open-sse/utils/error.ts");
|
|
|
|
const rawMsg =
|
|
"connection refused\n at /home/user/open-sse/services/opencodeQuotaFetcher.ts:42:10\n at /home/user/open-sse/services/usage.ts:890:5";
|
|
|
|
const sanitized = sanitizeErrorMessage(rawMsg);
|
|
|
|
// sanitizeErrorMessage strips everything after the first newline (stack frames)
|
|
// and replaces absolute paths on the first line with <path>.
|
|
assert.ok(
|
|
!sanitized.includes("at /home"),
|
|
`sanitized message must not contain 'at /home', got: ${sanitized}`
|
|
);
|
|
assert.ok(
|
|
!sanitized.includes(".ts:42"),
|
|
`sanitized message must not contain source line refs, got: ${sanitized}`
|
|
);
|
|
|
|
// Confirm the formatted catch-block message would also be clean.
|
|
const catchBlockOutput = `OpenCode error: ${sanitized}`;
|
|
assert.match(catchBlockOutput, /^OpenCode error:/);
|
|
assert.ok(
|
|
!catchBlockOutput.includes("at /"),
|
|
`catch-block message must not leak stack paths, got: ${catchBlockOutput}`
|
|
);
|
|
});
|