Skip to content

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

test(quota): cover fairShare 10 scenarios + burnRate + planResolver + saturationSignals + storeFactory (B/F6)

diegosouzapw22123013be1e
diff --git a/tests/unit/quota-burn-rate.test.ts b/tests/unit/quota-burn-rate.test.ts
new file mode 100644
index 0000000000..628d4881ee
--- /dev/null
+++ b/tests/unit/quota-burn-rate.test.ts
@@ -0,0 +1,113 @@
+/**
+ * tests/unit/quota-burn-rate.test.ts
+ *
+ * Coverage for src/lib/quota/burnRate.ts:
+ * - Empty history returns zeros
+ * - Linear-rate sequence approximates correctly
+ * - timeToExhaustionMs computed when remaining provided
+ * - Zero-rate (no consumption) → null exhaustion
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const { computeBurnRate } = await import("../../src/lib/quota/burnRate.ts");
+
+// ---------------------------------------------------------------------------
+// Edge cases
+// ---------------------------------------------------------------------------
+
+test("computeBurnRate: empty history → zeros", () => {
+ const result = computeBurnRate([]);
+ assert.equal(result.tokensPerSecond, 0);
+ assert.equal(result.timeToExhaustionMs, null);
+});
+
+test("computeBurnRate: single sample → zeros", () => {
+ const result = computeBurnRate([{ ts: 1000, consumed: 100 }]);
+ assert.equal(result.tokensPerSecond, 0);
+ assert.equal(result.timeToExhaustionMs, null);
+});
+
+// ---------------------------------------------------------------------------
+// Linear consumption rate
+// ---------------------------------------------------------------------------
+
+test("computeBurnRate: constant 10 t/s over 5 samples → tokensPerSecond ≈ 10", () => {
+ // Each sample adds 10 tokens per second over 1 second intervals
+ const base = Date.now();
+ const history = [
+ { ts: base, consumed: 0 },
+ { ts: base + 1000, consumed: 10 },
+ { ts: base + 2000, consumed: 20 },
+ { ts: base + 3000, consumed: 30 },
+ { ts: base + 4000, consumed: 40 },
+ ];
+ const result = computeBurnRate(history);
+ // EMA converges but with alpha=0.3 over 4 deltas (all 10 t/s), the result
+ // should be very close to 10.
+ assert.ok(result.tokensPerSecond > 9, `Expected rate > 9, got ${result.tokensPerSecond}`);
+ assert.ok(result.tokensPerSecond < 11, `Expected rate < 11, got ${result.tokensPerSecond}`);
+});
+
+test("computeBurnRate: remaining=100, rate=10 → timeToExhaustionMs ≈ 10000", () => {
+ const base = Date.now();
+ const history = [
+ { ts: base, consumed: 0 },
+ { ts: base + 1000, consumed: 10 },
+ { ts: base + 2000, consumed: 20 },
+ { ts: base + 3000, consumed: 30 },
+ { ts: base + 4000, consumed: 40 },
+ ];
+ const result = computeBurnRate(history, 100);
+ assert.notEqual(result.timeToExhaustionMs, null);
+ // Should be close to 10000ms (10s), allow ±10% tolerance
+ assert.ok(
+ result.timeToExhaustionMs! > 9000,
+ `Expected >9000ms, got ${result.timeToExhaustionMs}`
+ );
+ assert.ok(
+ result.timeToExhaustionMs! < 11000,
+ `Expected <11000ms, got ${result.timeToExhaustionMs}`
+ );
+});
+
+// ---------------------------------------------------------------------------
+// Zero rate
+// ---------------------------------------------------------------------------
+
+test("computeBurnRate: no consumption → tokensPerSecond=0, timeToExhaustionMs=null", () => {
+ const base = Date.now();
+ const history = [
+ { ts: base, consumed: 100 },
+ { ts: base + 1000, consumed: 100 }, // no change
+ { ts: base + 2000, consumed: 100 },
+ ];
+ const result = computeBurnRate(history, 500);
+ assert.equal(result.tokensPerSecond, 0);
+ assert.equal(result.timeToExhaustionMs, null);
+});
+
+test("computeBurnRate: no remaining provided → timeToExhaustionMs=null even with non-zero rate", () => {
+ const base = Date.now();
+ const history = [
+ { ts: base, consumed: 0 },
+ { ts: base + 1000, consumed: 10 },
+ ];
+ const result = computeBurnRate(history);
+ // Rate should be positive but no remaining given
+ assert.ok(result.tokensPerSecond > 0);
+ assert.equal(result.timeToExhaustionMs, null);
+});
+
+test("computeBurnRate: duplicate timestamps are skipped gracefully", () => {
+ const base = Date.now();
+ const history = [
+ { ts: base, consumed: 0 },
+ { ts: base, consumed: 10 }, // same ts — should be skipped
+ { ts: base + 1000, consumed: 20 },
+ ];
+ // Should not throw and should compute valid rate for the one valid delta
+ const result = computeBurnRate(history);
+ assert.ok(result.tokensPerSecond >= 0);
+});
diff --git a/tests/unit/quota-fair-share.test.ts b/tests/unit/quota-fair-share.test.ts
new file mode 100644
index 0000000000..37efde61b7
--- /dev/null
+++ b/tests/unit/quota-fair-share.test.ts
@@ -0,0 +1,203 @@
+/**
+ * tests/unit/quota-fair-share.test.ts
+ *
+ * 10 scenarios covering src/lib/quota/fairShare.ts:
+ * 1. Generous mode, key under fair_share → allow:ok
+ * 2. Generous mode, key over fair_share, policy=burst → allow:ok
+ * 3. Generous mode, key over fair_share, policy=hard, total under limit → allow:ok
+ * 4. Strict mode, key over fair_share, policy=hard → block:fair-share
+ * 5. Strict mode, key under fair_share → allow
+ * 6. Cap absolute reached → block:cap-absolute
+ * 7. Multi-dimension, A passes + B cap → block:cap-absolute
+ * 8. Soft policy, over fair_share with slack → allow:ok + penalized=true
+ * 9. Total >= limit, burst → block:global-saturated
+ * 10. Empty dimensions → allow:ok
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const { decideFairShare } = await import("../../src/lib/quota/fairShare.ts");
+
+const THRESHOLD = 0.5;
+
+// Helper to make a minimal dimension
+function dim(opts: {
+ poolId?: string;
+ unit?: string;
+ window?: string;
+ limit: number;
+ consumedTotal: number;
+ globalUsedPercent: number;
+}) {
+ return {
+ key: {
+ poolId: opts.poolId ?? "pool1",
+ unit: (opts.unit ?? "tokens") as "tokens" | "requests" | "percent" | "usd",
+ window: (opts.window ?? "hourly") as "hourly" | "5h" | "daily" | "weekly" | "monthly",
+ },
+ limit: opts.limit,
+ consumedTotal: opts.consumedTotal,
+ globalUsedPercent: opts.globalUsedPercent,
+ };
+}
+
+function alloc(weight: number, policy: "hard" | "soft" | "burst", capValue?: number, capUnit?: string) {
+ return {
+ weight,
+ policy,
+ ...(capValue !== undefined ? { capValue, capUnit: (capUnit ?? "tokens") as "tokens" | "requests" | "percent" | "usd" } : {}),
+ };
+}
+
+// ─── Scenario 1 ─────────────────────────────────────────────────────────────
+test("fairShare: generous mode, key under fair_share → allow:ok", () => {
+ // globalUsedPercent=0.2 < 0.5 threshold → generous
+ // weight=50, limit=1000 → fair_share=500
+ // consumed=200 < 500 → allow
+ const result = decideFairShare({
+ dimensions: [dim({ limit: 1000, consumedTotal: 200, globalUsedPercent: 0.2 })],
+ allocation: alloc(50, "hard"),
+ consumedByThisKey: { "pool1:tokens:hourly": 200 },
+ saturationThreshold: THRESHOLD,
+ });
+ assert.equal(result.kind, "allow");
+ assert.equal(result.reason, "ok");
+});
+
+// ─── Scenario 2 ─────────────────────────────────────────────────────────────
+test("fairShare: generous mode, key over fair_share, policy=burst → allow:ok", () => {
+ // globalUsedPercent=0.3 < 0.5, consumedTotal=600 < 1000 → room exists
+ // consumed=600 > fair_share=500 → but policy=burst → allow
+ const result = decideFairShare({
+ dimensions: [dim({ limit: 1000, consumedTotal: 600, globalUsedPercent: 0.3 })],
+ allocation: alloc(50, "burst"),
+ consumedByThisKey: { "pool1:tokens:hourly": 600 },
+ saturationThreshold: THRESHOLD,
+ });
+ assert.equal(result.kind, "allow");
+});
+
+// ─── Scenario 3 ─────────────────────────────────────────────────────────────
+test("fairShare: generous mode, key over fair_share, policy=hard, total under limit → allow:ok", () => {
+ // globalUsedPercent=0.4 < 0.5 → generous
+ // consumed=600 > fair_share=500, but consumedTotal=600 < 1000 → allow (borrowing)
+ const result = decideFairShare({
+ dimensions: [dim({ limit: 1000, consumedTotal: 600, globalUsedPercent: 0.4 })],
+ allocation: alloc(50, "hard"),
+ consumedByThisKey: { "pool1:tokens:hourly": 600 },
+ saturationThreshold: THRESHOLD,
+ });
+ assert.equal(result.kind, "allow");
+});
+
+// ─── Scenario 4 ─────────────────────────────────────────────────────────────
+test("fairShare: strict mode, key over fair_share, policy=hard → block:fair-share", () => {
+ // globalUsedPercent=0.6 >= 0.5 → strict
+ // consumed=600 > fair_share=500 → block
+ const result = decideFairShare({
+ dimensions: [dim({ limit: 1000, consumedTotal: 700, globalUsedPercent: 0.6 })],
+ allocation: alloc(50, "hard"),
+ consumedByThisKey: { "pool1:tokens:hourly": 600 },
+ saturationThreshold: THRESHOLD,
+ });
+ assert.equal(result.kind, "block");
+ assert.equal(result.reason, "fair-share");
+});
+
+// ─── Scenario 5 ─────────────────────────────────────────────────────────────
+test("fairShare: strict mode, key under fair_share → allow", () => {
+ // globalUsedPercent=0.7 >= 0.5 → strict
+ // consumed=300 < fair_share=500 → allow
+ const result = decideFairShare({
+ dimensions: [dim({ limit: 1000, consumedTotal: 700, globalUsedPercent: 0.7 })],
+ allocation: alloc(50, "hard"),
+ consumedByThisKey: { "pool1:tokens:hourly": 300 },
+ saturationThreshold: THRESHOLD,
+ });
+ assert.equal(result.kind, "allow");
+});
+
+// ─── Scenario 6 ─────────────────────────────────────────────────────────────
+test("fairShare: cap absolute reached → block:cap-absolute regardless of policy", () => {
+ // capValue=100, consumed=100 → block:cap-absolute even in generous mode
+ const result = decideFairShare({
+ dimensions: [dim({ limit: 1000, consumedTotal: 100, globalUsedPercent: 0.1 })],
+ allocation: alloc(50, "burst", 100, "tokens"),
+ consumedByThisKey: { "pool1:tokens:hourly": 100 },
+ saturationThreshold: THRESHOLD,
+ });
+ assert.equal(result.kind, "block");
+ assert.equal(result.reason, "cap-absolute");
+});
+
+// ─── Scenario 7 ─────────────────────────────────────────────────────────────
+test("fairShare: multi-dimension, A passes + B cap absolute → block:cap-absolute", () => {
+ const dimA = {
+ key: { poolId: "pool1", unit: "tokens" as const, window: "hourly" as const },
+ limit: 1000,
+ consumedTotal: 200,
+ globalUsedPercent: 0.2,
+ };
+ const dimB = {
+ key: { poolId: "pool1", unit: "requests" as const, window: "hourly" as const },
+ limit: 100,
+ consumedTotal: 50,
+ globalUsedPercent: 0.2,
+ };
+ const result = decideFairShare({
+ dimensions: [dimA, dimB],
+ allocation: {
+ weight: 50,
+ policy: "burst",
+ capValue: 10, // cap 10 requests
+ capUnit: "requests" as const,
+ },
+ consumedByThisKey: {
+ "pool1:tokens:hourly": 100,
+ "pool1:requests:hourly": 10, // at the cap
+ },
+ saturationThreshold: THRESHOLD,
+ });
+ assert.equal(result.kind, "block");
+ assert.equal(result.reason, "cap-absolute");
+});
+
+// ─── Scenario 8 ─────────────────────────────────────────────────────────────
+test("fairShare: soft policy, over fair_share with slack → allow:ok + penalized=true", () => {
+ // generous mode (globalUsedPercent=0.3), consumed=600 > fair_share=500
+ // policy=soft → allow but penalized
+ const result = decideFairShare({
+ dimensions: [dim({ limit: 1000, consumedTotal: 600, globalUsedPercent: 0.3 })],
+ allocation: alloc(50, "soft"),
+ consumedByThisKey: { "pool1:tokens:hourly": 600 },
+ saturationThreshold: THRESHOLD,
+ });
+ assert.equal(result.kind, "allow");
+ assert.equal(result.penalized, true);
+});
+
+// ─── Scenario 9 ─────────────────────────────────────────────────────────────
+test("fairShare: total >= limit, burst → block:global-saturated", () => {
+ // consumedTotal=1000 = limit → no room at all
+ const result = decideFairShare({
+ dimensions: [dim({ limit: 1000, consumedTotal: 1000, globalUsedPercent: 1.0 })],
+ allocation: alloc(50, "burst"),
+ consumedByThisKey: { "pool1:tokens:hourly": 500 },
+ saturationThreshold: THRESHOLD,
+ });
+ assert.equal(result.kind, "block");
+ assert.equal(result.reason, "global-saturated");
+});
+
+// ─── Scenario 10 ────────────────────────────────────────────────────────────
+test("fairShare: empty dimensions → allow:ok", () => {
+ const result = decideFairShare({
+ dimensions: [],
+ allocation: alloc(50, "hard"),
+ consumedByThisKey: {},
+ saturationThreshold: THRESHOLD,
+ });
+ assert.equal(result.kind, "allow");
+ assert.equal(result.reason, "ok");
+});
diff --git a/tests/unit/quota-plan-resolver.test.ts b/tests/unit/quota-plan-resolver.test.ts
new file mode 100644
index 0000000000..72401f2022
--- /dev/null
+++ b/tests/unit/quota-plan-resolver.test.ts
@@ -0,0 +1,121 @@
+/**
+ * tests/unit/quota-plan-resolver.test.ts
+ *
+ * Coverage for src/lib/quota/planResolver.ts:
+ * - DB plan present → return that plan
+ * - DB absent, known provider → catalog plan (source="auto")
+ * - DB absent, unknown provider → empty plan (source="manual")
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+// Set up isolated DATA_DIR before any imports that touch the DB
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-plan-resolver-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+// Import modules
+const core = await import("../../src/lib/db/core.ts");
+const providerPlansDb = await import("../../src/lib/db/providerPlans.ts");
+
+async function resetStorage() {
+ core.resetDbInstance();
+ for (let attempt = 0; attempt < 10; attempt++) {
+ try {
+ if (fs.existsSync(TEST_DATA_DIR)) {
+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+ }
+ break;
+ } catch (err: unknown) {
+ const e = err as { code?: string };
+ if ((e?.code === "EBUSY" || e?.code === "EPERM") && attempt < 9) {
+ await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
+ } else {
+ throw err;
+ }
+ }
+ }
+ fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+}
+
+test.beforeEach(async () => {
+ await resetStorage();
+});
+
+test.after(async () => {
+ core.resetDbInstance();
+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+});
+
+// ─── Scenario 1 ─────────────────────────────────────────────────────────────
+test("planResolver: DB plan present → returns DB plan (source=manual)", async () => {
+ const { resolvePlan } = await import("../../src/lib/quota/planResolver.ts");
+
+ // Seed a DB override
+ providerPlansDb.upsertPlan("conn-123", "openai", [
+ { unit: "tokens", window: "hourly", limit: 10_000 },
+ ], "manual");
+
+ const plan = resolvePlan("conn-123", "openai");
+ assert.equal(plan.source, "manual");
+ assert.equal(plan.provider, "openai");
+ assert.ok(plan.dimensions.length > 0);
+ assert.equal(plan.dimensions[0].limit, 10_000);
+});
+
+// ─── Scenario 2 ─────────────────────────────────────────────────────────────
+test("planResolver: DB absent + known provider (codex) → catalog plan (source=auto)", async () => {
+ const { resolvePlan } = await import("../../src/lib/quota/planResolver.ts");
+
+ const plan = resolvePlan("conn-no-override", "codex");
+ assert.equal(plan.source, "auto");
+ assert.equal(plan.provider, "codex");
+ assert.ok(plan.dimensions.length > 0);
+ // Codex catalog has percent + 5h + weekly
+ const units = plan.dimensions.map((d) => d.unit);
+ assert.ok(units.includes("percent"), "Expected percent dimension");
+});
+
+// ─── Scenario 3 ─────────────────────────────────────────────────────────────
+test("planResolver: DB absent + unknown provider → empty plan (source=manual)", async () => {
+ const { resolvePlan } = await import("../../src/lib/quota/planResolver.ts");
+
+ const plan = resolvePlan("conn-unknown", "unknown_provider_xyz");
+ assert.equal(plan.source, "manual");
+ assert.equal(plan.provider, "unknown_provider_xyz");
+ assert.equal(plan.dimensions.length, 0);
+ assert.equal(plan.connectionId, null);
+});
+
+// ─── Scenario 4 ─────────────────────────────────────────────────────────────
+test("planResolver: DB plan overrides catalog for same provider", async () => {
+ const { resolvePlan } = await import("../../src/lib/quota/planResolver.ts");
+
+ // codex is in catalog, but we add a DB override
+ providerPlansDb.upsertPlan("conn-codex-override", "codex", [
+ { unit: "requests", window: "daily", limit: 999 },
+ ], "manual");
+
+ const plan = resolvePlan("conn-codex-override", "codex");
+ assert.equal(plan.source, "manual");
+ // Should return DB override, not catalog
+ assert.equal(plan.dimensions[0].unit, "requests");
+ assert.equal(plan.dimensions[0].limit, 999);
+});
+
+// ─── Scenario 5 ─────────────────────────────────────────────────────────────
+test("planResolver: runtimeSignals parameter is accepted without error", async () => {
+ const { resolvePlan } = await import("../../src/lib/quota/planResolver.ts");
+
+ // Should not throw even with headers provided
+ const plan = resolvePlan("conn-signals", "kimi", {
+ headers: { "x-ratelimit-remaining-requests": "1234" },
+ });
+ assert.ok(plan);
+ // kimi is in catalog
+ assert.equal(plan.source, "auto");
+ assert.equal(plan.provider, "kimi");
+});
diff --git a/tests/unit/quota-saturation-signals.test.ts b/tests/unit/quota-saturation-signals.test.ts
new file mode 100644
index 0000000000..eacbbda8af
--- /dev/null
+++ b/tests/unit/quota-saturation-signals.test.ts
@@ -0,0 +1,92 @@
+/**
+ * tests/unit/quota-saturation-signals.test.ts
+ *
+ * Coverage for src/lib/quota/saturationSignals.ts:
+ * - Mock fetcher returns value → getSaturation returns it
+ * - Cache HIT on second call (fetcher NOT invoked again)
+ * - Fetcher throws → returns 0, no throw
+ * - Unknown provider → fallback or 0
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// We import the module under test; fetchers are mocked by swapping the
+// imported function in the module's closure via dynamic import mocking.
+// Since Node's native runner doesn't have built-in mocking, we use the
+// register-then-require pattern with a mock module loader approach.
+//
+// Simpler approach: we test the cache and error behaviour by calling
+// getSaturation with providers that DON'T have real network (will throw),
+// and then verify the fail-open (returns 0) behaviour.
+
+// Clear cache before each test
+const satMod = await import("../../src/lib/quota/saturationSignals.ts");
+const { getSaturation, _clearSaturationCache } = satMod;
+
+test.beforeEach(() => {
+ _clearSaturationCache();
+});
+
+// ─── Fail-open for all providers ────────────────────────────────────────────
+
+test("getSaturation: unknown provider → fails open (returns 0)", async () => {
+ _clearSaturationCache();
+ // "unknown_xyz" will hit the default branch which calls getUsageForProvider
+ // In test env without real network, that will fail → returns 0 (fail-open)
+ const val = await getSaturation("conn-xyz", "unknown_xyz", { unit: "tokens", window: "hourly" });
+ assert.ok(typeof val === "number", "Should return a number");
+ assert.ok(val >= 0 && val <= 1, `Should be in [0,1], got ${val}`);
+});
+
+test("getSaturation: codex without registered creds → returns 0 (fail-open)", async () => {
+ _clearSaturationCache();
+ const val = await getSaturation("conn-no-creds", "codex", { unit: "percent", window: "5h" });
+ // No credentials registered → fetchCodexQuota returns null → 0
+ assert.equal(val, 0);
+});
+
+test("getSaturation: bailian without registered creds → returns 0 (fail-open)", async () => {
+ _clearSaturationCache();
+ const val = await getSaturation("conn-bailian-no-creds", "bailian", { unit: "percent", window: "5h" });
+ assert.equal(val, 0);
+});
+
+// ─── Cache behaviour ─────────────────────────────────────────────────────────
+
+test("getSaturation: second call returns cached value without re-fetching", async () => {
+ _clearSaturationCache();
+
+ // First call for an unknown provider → 0 (fail-open)
+ const first = await getSaturation("conn-cache-test", "unknown_cache", { unit: "tokens", window: "hourly" });
+
+ // Second call — should use cache
+ const second = await getSaturation("conn-cache-test", "unknown_cache", { unit: "tokens", window: "hourly" });
+
+ // Both should be the same value (0 in this case since no real provider)
+ assert.equal(first, second);
+});
+
+test("getSaturation: different dimension keys are cached independently", async () => {
+ _clearSaturationCache();
+
+ const v1 = await getSaturation("conn-dim", "unknown_dim", { unit: "tokens", window: "hourly" });
+ const v2 = await getSaturation("conn-dim", "unknown_dim", { unit: "requests", window: "daily" });
+
+ // Both should be numbers in [0,1]
+ assert.ok(typeof v1 === "number");
+ assert.ok(typeof v2 === "number");
+});
+
+// ─── Return range validation ─────────────────────────────────────────────────
+
+test("getSaturation: always returns value in [0,1]", async () => {
+ _clearSaturationCache();
+ const providers = ["codex", "bailian", "openai", "unknown_abc"];
+ for (const p of providers) {
+ _clearSaturationCache();
+ const val = await getSaturation("conn-range", p, { unit: "tokens", window: "hourly" });
+ assert.ok(val >= 0, `${p}: expected >= 0, got ${val}`);
+ assert.ok(val <= 1, `${p}: expected <= 1, got ${val}`);
+ }
+});
diff --git a/tests/unit/quota-store-factory.test.ts b/tests/unit/quota-store-factory.test.ts
new file mode 100644
index 0000000000..111960c100
--- /dev/null
+++ b/tests/unit/quota-store-factory.test.ts
@@ -0,0 +1,151 @@
+/**
+ * tests/unit/quota-store-factory.test.ts
+ *
+ * Coverage for src/lib/quota/storeFactory.ts:
+ * - Default driver = sqlite
+ * - Env override QUOTA_STORE_DRIVER=redis + URL → redis store (if ioredis available)
+ * - Driver redis + URL absent → fallback sqlite
+ * - Singleton: multiple calls return same instance
+ * - resetQuotaStoreSingleton() resets
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-store-factory-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+
+async function resetStorage() {
+ core.resetDbInstance();
+ for (let attempt = 0; attempt < 10; attempt++) {
+ try {
+ if (fs.existsSync(TEST_DATA_DIR)) {
+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+ }
+ break;
+ } catch (err: unknown) {
+ const e = err as { code?: string };
+ if ((e?.code === "EBUSY" || e?.code === "EPERM") && attempt < 9) {
+ await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
+ } else {
+ throw err;
+ }
+ }
+ }
+ fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+}
+
+const origDriver = process.env.QUOTA_STORE_DRIVER;
+const origRedisUrl = process.env.QUOTA_STORE_REDIS_URL;
+
+test.beforeEach(async () => {
+ await resetStorage();
+ // Reset env
+ delete process.env.QUOTA_STORE_DRIVER;
+ delete process.env.QUOTA_STORE_REDIS_URL;
+ // Reset singleton
+ const { resetQuotaStoreSingleton } = await import("../../src/lib/quota/storeFactory.ts");
+ resetQuotaStoreSingleton();
+});
+
+test.after(async () => {
+ core.resetDbInstance();
+ if (fs.existsSync(TEST_DATA_DIR)) {
+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+ }
+ // Restore env
+ if (origDriver !== undefined) process.env.QUOTA_STORE_DRIVER = origDriver;
+ else delete process.env.QUOTA_STORE_DRIVER;
+ if (origRedisUrl !== undefined) process.env.QUOTA_STORE_REDIS_URL = origRedisUrl;
+ else delete process.env.QUOTA_STORE_REDIS_URL;
+});
+
+// ─── Default driver ──────────────────────────────────────────────────────────
+
+test("storeFactory: default driver is sqlite", async () => {
+ const { getQuotaStore, resetQuotaStoreSingleton } = await import("../../src/lib/quota/storeFactory.ts");
+ resetQuotaStoreSingleton();
+
+ const store = await getQuotaStore();
+ assert.ok(store, "Should return a store");
+ // SQLite store has consume/peek/poolUsage/clear
+ assert.ok(typeof store.consume === "function");
+ assert.ok(typeof store.peek === "function");
+ assert.ok(typeof store.poolUsage === "function");
+ assert.ok(typeof store.clear === "function");
+});
+
+// ─── Singleton behaviour ─────────────────────────────────────────────────────
+
+test("storeFactory: multiple calls return same singleton", async () => {
+ const { getQuotaStore, resetQuotaStoreSingleton } = await import("../../src/lib/quota/storeFactory.ts");
+ resetQuotaStoreSingleton();
+
+ const store1 = await getQuotaStore();
+ const store2 = await getQuotaStore();
+ assert.strictEqual(store1, store2);
+});
+
+test("storeFactory: resetQuotaStoreSingleton() creates new instance on next call", async () => {
+ const { getQuotaStore, resetQuotaStoreSingleton } = await import("../../src/lib/quota/storeFactory.ts");
+ resetQuotaStoreSingleton();
+
+ const store1 = await getQuotaStore();
+ resetQuotaStoreSingleton();
+ const store2 = await getQuotaStore();
+
+ // After reset, a new instance is created (may or may not be the same object
+ // since singleton is re-created — but the important thing is it doesn't throw)
+ assert.ok(store2, "Should return a new store after reset");
+});
+
+// ─── Redis driver + no URL → fallback sqlite ─────────────────────────────────
+
+test("storeFactory: QUOTA_STORE_DRIVER=redis without URL → fallback to sqlite", async () => {
+ const { getQuotaStore, resetQuotaStoreSingleton } = await import("../../src/lib/quota/storeFactory.ts");
+ resetQuotaStoreSingleton();
+
+ process.env.QUOTA_STORE_DRIVER = "redis";
+ delete process.env.QUOTA_STORE_REDIS_URL;
+
+ // Should not throw — should fall back to sqlite
+ const store = await getQuotaStore();
+ assert.ok(store, "Should return a valid store (sqlite fallback)");
+ assert.ok(typeof store.consume === "function");
+});
+
+// ─── Unknown driver → fallback sqlite ────────────────────────────────────────
+
+test("storeFactory: unknown driver value → falls back to sqlite silently", async () => {
+ const { getQuotaStore, resetQuotaStoreSingleton } = await import("../../src/lib/quota/storeFactory.ts");
+ resetQuotaStoreSingleton();
+
+ (process.env as Record<string, string>).QUOTA_STORE_DRIVER = "memcached";
+
+ const store = await getQuotaStore();
+ assert.ok(store, "Should return sqlite store as fallback");
+ assert.ok(typeof store.consume === "function");
+});
+
+// ─── Redis driver + invalid URL (ioredis not installed) → fallback ────────────
+
+test("storeFactory: QUOTA_STORE_DRIVER=redis with invalid URL → fallback or throws gracefully", async () => {
+ const { getQuotaStore, resetQuotaStoreSingleton } = await import("../../src/lib/quota/storeFactory.ts");
+ resetQuotaStoreSingleton();
+
+ process.env.QUOTA_STORE_DRIVER = "redis";
+ process.env.QUOTA_STORE_REDIS_URL = "redis://localhost:6380"; // likely not running
+
+ // In test env, ioredis may or may not be installed.
+ // If installed: store is created (Redis connection is lazy).
+ // If not installed: factory falls back to sqlite.
+ // Either way, no throw — returns a valid store.
+ const store = await getQuotaStore();
+ assert.ok(store, "Should always return a valid store");
+ assert.ok(typeof store.consume === "function");
+});