Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
import { describe, it } from "node:test";
import assert from "node:assert/strict";
import {
isKeyActive,
isExpired,
isRestricted,
classifyKeyStatus,
classifyKeyType,
computeApiKeyCounts,
} from "../../src/app/(dashboard)/dashboard/api-manager/apiManagerPageUtils.js";
import type { ApiKeyShape } from "../../src/app/(dashboard)/dashboard/api-manager/apiManagerPageUtils.js";
// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------
const futureDate = new Date(Date.now() + 86_400_000).toISOString(); // +1 day
const pastDate = new Date(Date.now() - 86_400_000).toISOString(); // -1 day
function makeKey(overrides: Partial<ApiKeyShape> = {}): ApiKeyShape {
return {
isActive: true,
isBanned: false,
expiresAt: null,
scopes: [],
allowedModels: null,
allowedConnections: null,
...overrides,
};
}
// ---------------------------------------------------------------------------
// Scenario 1 — isKeyActive
// ---------------------------------------------------------------------------
describe("isKeyActive", () => {
it("returns true for a fully active key", () => {
assert.equal(isKeyActive(makeKey()), true);
});
it("returns false when isBanned is true", () => {
assert.equal(isKeyActive(makeKey({ isBanned: true })), false);
});
it("returns false when isActive is false", () => {
assert.equal(isKeyActive(makeKey({ isActive: false })), false);
});
it("returns false when expiresAt is in the past", () => {
assert.equal(isKeyActive(makeKey({ expiresAt: pastDate })), false);
});
it("returns true when expiresAt is in the future", () => {
assert.equal(isKeyActive(makeKey({ expiresAt: futureDate })), true);
});
it("returns false when banned even if isActive true and not expired", () => {
assert.equal(
isKeyActive(makeKey({ isBanned: true, isActive: true, expiresAt: futureDate })),
false
);
});
});
// ---------------------------------------------------------------------------
// Scenario 2 — isExpired
// ---------------------------------------------------------------------------
describe("isExpired", () => {
it("returns false when expiresAt is null", () => {
assert.equal(isExpired(makeKey({ expiresAt: null })), false);
});
it("returns false when expiresAt is in the future", () => {
assert.equal(isExpired(makeKey({ expiresAt: futureDate })), false);
});
it("returns true when expiresAt is in the past", () => {
assert.equal(isExpired(makeKey({ expiresAt: pastDate })), true);
});
it("returns false for an invalid date string (NaN)", () => {
assert.equal(isExpired(makeKey({ expiresAt: "not-a-date" })), false);
});
});
// ---------------------------------------------------------------------------
// Scenario 3 — isRestricted
// ---------------------------------------------------------------------------
describe("isRestricted", () => {
it("returns false when both allowedModels and allowedConnections are null", () => {
assert.equal(isRestricted(makeKey()), false);
});
it("returns false when allowedModels is an empty array", () => {
assert.equal(isRestricted(makeKey({ allowedModels: [] })), false);
});
it("returns true when allowedModels has entries", () => {
assert.equal(isRestricted(makeKey({ allowedModels: ["gpt-4"] })), true);
});
it("returns true when allowedConnections has entries", () => {
assert.equal(isRestricted(makeKey({ allowedConnections: ["conn-1"] })), true);
});
it("returns true when both have entries", () => {
assert.equal(
isRestricted(makeKey({ allowedModels: ["gpt-4"], allowedConnections: ["conn-1"] })),
true
);
});
});
// ---------------------------------------------------------------------------
// Scenario 4 — classifyKeyStatus (banned takes highest priority)
// ---------------------------------------------------------------------------
describe("classifyKeyStatus", () => {
it("returns 'banned' for a banned key (highest priority)", () => {
assert.equal(classifyKeyStatus(makeKey({ isBanned: true })), "banned");
});
it("returns 'banned' even if also expired", () => {
assert.equal(classifyKeyStatus(makeKey({ isBanned: true, expiresAt: pastDate })), "banned");
});
it("returns 'expired' before 'disabled' when key has past expiry and isActive false", () => {
// expiresAt in the past AND isActive false — expired is checked before disabled
assert.equal(classifyKeyStatus(makeKey({ expiresAt: pastDate, isActive: false })), "expired");
});
it("returns 'expired' for a non-banned, expired key", () => {
assert.equal(classifyKeyStatus(makeKey({ expiresAt: pastDate })), "expired");
});
it("returns 'disabled' when isActive false and not expired/banned", () => {
assert.equal(classifyKeyStatus(makeKey({ isActive: false })), "disabled");
});
it("returns 'active' for a healthy key", () => {
assert.equal(classifyKeyStatus(makeKey()), "active");
});
it("returns 'active' for key with future expiry and no bans", () => {
assert.equal(classifyKeyStatus(makeKey({ expiresAt: futureDate })), "active");
});
});
// ---------------------------------------------------------------------------
// Scenario 4 continued — classifyKeyType
// ---------------------------------------------------------------------------
describe("classifyKeyType", () => {
it("returns 'standard' for a plain key", () => {
assert.equal(classifyKeyType(makeKey()), "standard");
});
it("returns 'manage' when scopes includes manage", () => {
assert.equal(classifyKeyType(makeKey({ scopes: ["manage"] })), "manage");
});
it("returns 'manage' even if also restricted (manage takes priority)", () => {
assert.equal(
classifyKeyType(makeKey({ scopes: ["manage"], allowedModels: ["gpt-4"] })),
"manage"
);
});
it("returns 'restricted' when has allowedModels and no manage scope", () => {
assert.equal(classifyKeyType(makeKey({ allowedModels: ["gpt-4"] })), "restricted");
});
it("returns 'restricted' when has allowedConnections and no manage scope", () => {
assert.equal(classifyKeyType(makeKey({ allowedConnections: ["c1"] })), "restricted");
});
});
// ---------------------------------------------------------------------------
// Scenario 5 — computeApiKeyCounts with 10 varied keys
// ---------------------------------------------------------------------------
describe("computeApiKeyCounts", () => {
it("returns all zeros for empty array (edge case)", () => {
const counts = computeApiKeyCounts([]);
assert.equal(counts.total, 0);
assert.equal(counts.active, 0);
assert.equal(counts.banned, 0);
assert.equal(counts.expired, 0);
assert.equal(counts.disabled, 0);
assert.equal(counts.standard, 0);
assert.equal(counts.manage, 0);
assert.equal(counts.restricted, 0);
});
it("correctly tallies 10 mixed keys", () => {
const keys: ApiKeyShape[] = [
makeKey(), // active + standard
makeKey({ expiresAt: futureDate }), // active + standard
makeKey({ scopes: ["manage"] }), // active + manage
makeKey({ allowedModels: ["gpt-4"] }), // active + restricted
makeKey({ isActive: false }), // disabled + standard
makeKey({ isBanned: true }), // banned + standard
makeKey({ expiresAt: pastDate }), // expired + standard
makeKey({ expiresAt: pastDate, allowedModels: ["gpt-4"] }), // expired + restricted (type=restricted)
makeKey({ scopes: ["manage"], allowedConnections: ["c1"] }), // active + manage (manage priority)
makeKey({ allowedConnections: ["c1"] }), // active + restricted
];
const counts = computeApiKeyCounts(keys);
assert.equal(counts.total, 10);
// statuses: active(6: keys 1,2,3,4,9,10), disabled(1), banned(1), expired(2)
assert.equal(counts.active, 6);
assert.equal(counts.disabled, 1);
assert.equal(counts.banned, 1);
assert.equal(counts.expired, 2);
// types: manage(2), restricted(3), standard(5 — active×2, disabled, banned, expired×1)
assert.equal(counts.manage, 2);
assert.equal(counts.restricted, 3);
assert.equal(counts.standard, 5);
});
});
// ---------------------------------------------------------------------------
// Scenario 6 — filteredKeys logic (inline simulation of useMemo)
// ---------------------------------------------------------------------------
function applyFilters(
keys: ApiKeyShape[],
opts: {
activeOnly?: boolean;
statusFilter?: string | null;
typeFilter?: string | null;
searchQuery?: string;
}
): ApiKeyShape[] {
let list = keys;
if (opts.activeOnly) list = list.filter(isKeyActive);
if (opts.statusFilter === "active") list = list.filter(isKeyActive);
else if (opts.statusFilter === "disabled") list = list.filter((k) => k.isActive === false);
else if (opts.statusFilter === "banned") list = list.filter((k) => k.isBanned === true);
else if (opts.statusFilter === "expired") list = list.filter(isExpired);
if (opts.typeFilter === "manage") list = list.filter((k) => k.scopes?.includes("manage"));
else if (opts.typeFilter === "restricted") list = list.filter(isRestricted);
else if (opts.typeFilter === "standard")
list = list.filter((k) => !k.scopes?.includes("manage") && !isRestricted(k));
if (opts.searchQuery?.trim()) {
const q = opts.searchQuery.toLowerCase();
// We cast to any to allow name/key fields for the filter simulation
list = list.filter(
(k) =>
((k as Record<string, unknown>)["name"] as string | undefined)?.toLowerCase().includes(q) ||
((k as Record<string, unknown>)["key"] as string | undefined)?.toLowerCase().includes(q)
);
}
return list;
}
interface TestApiKey extends ApiKeyShape {
name: string;
key: string;
}
function makeTestKey(name: string, key: string, overrides: Partial<ApiKeyShape> = {}): TestApiKey {
return { ...makeKey(overrides), name, key };
}
describe("filter composition", () => {
const testKeys: TestApiKey[] = [
makeTestKey("Alpha", "sk-alpha", {}),
makeTestKey("Beta", "sk-beta", { isBanned: true }),
makeTestKey("Gamma", "sk-gamma", { isActive: false }),
makeTestKey("Delta", "sk-delta", { expiresAt: pastDate }),
makeTestKey("Epsilon", "sk-epsilon", { scopes: ["manage"] }),
];
it("activeOnly=true excludes banned and inactive keys", () => {
const result = applyFilters(testKeys, { activeOnly: true });
const names = result.map((k) => (k as TestApiKey).name);
assert.ok(names.includes("Alpha"), "Active key should be included");
assert.ok(names.includes("Epsilon"), "Manage key should be included");
assert.ok(!names.includes("Beta"), "Banned should be excluded");
assert.ok(!names.includes("Gamma"), "Disabled should be excluded");
assert.ok(!names.includes("Delta"), "Expired should be excluded");
});
it("statusFilter='banned' returns only banned keys", () => {
const result = applyFilters(testKeys, { statusFilter: "banned" });
assert.equal(result.length, 1);
assert.equal((result[0] as TestApiKey).name, "Beta");
});
it("statusFilter='disabled' returns only disabled keys", () => {
const result = applyFilters(testKeys, { statusFilter: "disabled" });
assert.equal(result.length, 1);
assert.equal((result[0] as TestApiKey).name, "Gamma");
});
it("typeFilter='manage' returns only manage-scoped keys", () => {
const result = applyFilters(testKeys, { typeFilter: "manage" });
assert.equal(result.length, 1);
assert.equal((result[0] as TestApiKey).name, "Epsilon");
});
});
// ---------------------------------------------------------------------------
// Scenario 7 — searchQuery filters by name case-insensitively
// ---------------------------------------------------------------------------
describe("searchQuery filtering", () => {
const testKeys: TestApiKey[] = [
makeTestKey("Production Key", "sk-prod-abc123", {}),
makeTestKey("Development Key", "sk-dev-xyz789", {}),
makeTestKey("Staging", "sk-stg-qwerty", {}),
];
it("matches by name case-insensitively", () => {
const result = applyFilters(testKeys, { searchQuery: "production" });
assert.equal(result.length, 1);
assert.equal((result[0] as TestApiKey).name, "Production Key");
});
it("matches by key prefix case-insensitively", () => {
const result = applyFilters(testKeys, { searchQuery: "SK-DEV" });
assert.equal(result.length, 1);
assert.equal((result[0] as TestApiKey).name, "Development Key");
});
it("returns all keys when searchQuery is empty", () => {
const result = applyFilters(testKeys, { searchQuery: "" });
assert.equal(result.length, 3);
});
it("returns empty when no key matches", () => {
const result = applyFilters(testKeys, { searchQuery: "zzznomatch" });
assert.equal(result.length, 0);
});
it("matches multiple keys with partial substring", () => {
const result = applyFilters(testKeys, { searchQuery: "key" });
assert.equal(result.length, 2);
});
});