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
test(integration): cover quota REST routes + error sanitization (B/F8)
diegosouzapw37e6570bdb6e
diff --git a/tests/integration/quota-plans-crud.test.ts b/tests/integration/quota-plans-crud.test.tsnew file mode 100644index 0000000000..8f603e5ade--- /dev/null+++ b/tests/integration/quota-plans-crud.test.ts@@ -0,0 +1,253 @@+/**+ * Integration tests: /api/quota/plans CRUD endpoints+ *+ * Verifies:+ * - GET /api/quota/plans returns catalog + DB plans merged+ * - GET /api/quota/plans/[connectionId] returns resolved plan+ * - PUT /api/quota/plans/[connectionId] upserts manual override + audit event+ * - DELETE /api/quota/plans/[connectionId] clears override (reverts to auto)+ * - Error responses never leak stack traces (Hard Rule #12 / B25)+ *+ * Part of: Group B — REST routes for Quota Sharing (plan 22, frente F8).+ */++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";+import { makeManagementSessionRequest } from "../helpers/managementSession.ts";++const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-quota-plans-crud-"));+process.env.DATA_DIR = TEST_DATA_DIR;+process.env.API_KEY_SECRET = "test-quota-plans-secret";++const core = await import("../../src/lib/db/core.ts");+const localDb = await import("../../src/lib/localDb.ts");+const compliance = await import("../../src/lib/compliance/index.ts");+const plansRoute = await import("../../src/app/api/quota/plans/route.ts");+const planIdRoute = await import("../../src/app/api/quota/plans/[connectionId]/route.ts");++async function enableManagementAuth() {+ process.env.INITIAL_PASSWORD = "bootstrap-password";+ await localDb.updateSettings({ requireLogin: true, password: "" });+}++function resetDb() {+ core.resetDbInstance();+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+ fs.mkdirSync(TEST_DATA_DIR, { recursive: true });+}++test.beforeEach(async () => {+ resetDb();+ compliance.initAuditLog();+});++test.after(() => {+ core.resetDbInstance();+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+});++// ---------------------------------------------------------------------------+// GET /api/quota/plans+// ---------------------------------------------------------------------------++test("GET /api/quota/plans without auth → 401", async () => {+ await enableManagementAuth();+ const req = new Request("http://localhost/api/quota/plans");+ const res = await plansRoute.GET(req);+ assert.equal(res.status, 401);+});++test("GET /api/quota/plans returns catalog providers (codex, kimi, etc.)", async () => {+ const req = await makeManagementSessionRequest("http://localhost/api/quota/plans");+ const res = await plansRoute.GET(req);+ assert.equal(res.status, 200);+ const body = (await res.json()) as { plans: Array<{ provider: string; source: string }> };+ assert.ok(Array.isArray(body.plans), "plans should be an array");+ // Known providers from planRegistry+ const providers = body.plans.map((p) => p.provider);+ assert.ok(providers.includes("codex"), "Should include codex from catalog");+ assert.ok(providers.includes("kimi"), "Should include kimi from catalog");+ // Catalog entries have source=auto+ const codexEntry = body.plans.find((p) => p.provider === "codex");+ assert.equal(codexEntry?.source, "auto");+});++test("GET /api/quota/plans includes DB override plans", async () => {+ // First add a manual override+ const putReq = await makeManagementSessionRequest(+ "http://localhost/api/quota/plans/conn-override-1",+ {+ method: "PUT",+ body: {+ dimensions: [{ unit: "tokens", window: "daily", limit: 50000 }],+ },+ }+ );+ await planIdRoute.PUT(putReq, { params: Promise.resolve({ connectionId: "conn-override-1" }) });++ // List should include the override+ const listReq = await makeManagementSessionRequest("http://localhost/api/quota/plans");+ const listRes = await plansRoute.GET(listReq);+ const body = (await listRes.json()) as { plans: Array<{ connectionId: string | null; source: string }> };+ const override = body.plans.find((p) => p.connectionId === "conn-override-1");+ assert.ok(override, "Override plan should appear in list");+ assert.equal(override?.source, "manual");+});++// ---------------------------------------------------------------------------+// GET /api/quota/plans/[connectionId]+// ---------------------------------------------------------------------------++test("GET /api/quota/plans/[connectionId] returns catalog plan when no override", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/quota/plans/conn-no-override"+ );+ const res = await planIdRoute.GET(req, {+ params: Promise.resolve({ connectionId: "conn-no-override" }),+ });+ assert.equal(res.status, 200);+ const body = (await res.json()) as { plan: { source: string } };+ // No DB override, no catalog match → source="manual" (empty plan)+ assert.ok(["auto", "manual"].includes(body.plan.source), "Source should be auto or manual");+});++test("GET /api/quota/plans/[connectionId] returns DB override when present", async () => {+ const connectionId = "conn-with-override";+ // Create override+ const putReq = await makeManagementSessionRequest(+ `http://localhost/api/quota/plans/${connectionId}`,+ {+ method: "PUT",+ body: {+ dimensions: [{ unit: "requests", window: "hourly", limit: 200 }],+ },+ }+ );+ await planIdRoute.PUT(putReq, { params: Promise.resolve({ connectionId }) });++ // GET should return the override+ const getReq = await makeManagementSessionRequest(+ `http://localhost/api/quota/plans/${connectionId}`+ );+ const getRes = await planIdRoute.GET(getReq, { params: Promise.resolve({ connectionId }) });+ assert.equal(getRes.status, 200);+ const body = (await getRes.json()) as {+ plan: { source: string; dimensions: Array<{ unit: string; limit: number }> };+ };+ assert.equal(body.plan.source, "manual");+ assert.equal(body.plan.dimensions[0]?.unit, "requests");+ assert.equal(body.plan.dimensions[0]?.limit, 200);+});++// ---------------------------------------------------------------------------+// PUT /api/quota/plans/[connectionId]+// ---------------------------------------------------------------------------++test("PUT /api/quota/plans/[connectionId] without auth → 401", async () => {+ await enableManagementAuth();+ const req = new Request("http://localhost/api/quota/plans/conn-auth-test", {+ method: "PUT",+ headers: { "content-type": "application/json" },+ body: JSON.stringify({ dimensions: [{ unit: "tokens", window: "daily", limit: 1000 }] }),+ });+ const res = await planIdRoute.PUT(req, {+ params: Promise.resolve({ connectionId: "conn-auth-test" }),+ });+ assert.equal(res.status, 401);+});++test("PUT /api/quota/plans/[connectionId] with invalid body → 400", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/quota/plans/conn-bad-body",+ {+ method: "PUT",+ body: { dimensions: [] }, // PlanUpsertSchema requires min(1) dimensions+ }+ );+ const res = await planIdRoute.PUT(req, {+ params: Promise.resolve({ connectionId: "conn-bad-body" }),+ });+ assert.equal(res.status, 400);+ const body = await res.json();+ // Hard Rule #12+ assert.doesNotMatch(JSON.stringify(body), /\s+at\s+\//, "No stack trace in 400 response");+});++test("PUT /api/quota/plans/[connectionId] with valid body → source=manual + audit event", async () => {+ const connectionId = "conn-put-test";+ const req = await makeManagementSessionRequest(+ `http://localhost/api/quota/plans/${connectionId}`,+ {+ method: "PUT",+ body: {+ dimensions: [{ unit: "usd", window: "monthly", limit: 100 }],+ },+ }+ );+ const res = await planIdRoute.PUT(req, { params: Promise.resolve({ connectionId }) });+ assert.equal(res.status, 200);+ const body = (await res.json()) as { plan: { source: string } };+ assert.equal(body.plan.source, "manual");++ // Audit event+ const logs = compliance.getAuditLog({ action: "quota.plan.updated", limit: 10 });+ const events = Array.isArray(logs) ? logs : [];+ const evt = events.find(+ (e) =>+ typeof e === "object" &&+ e !== null &&+ (e as Record<string, unknown>).action === "quota.plan.updated" &&+ (e as Record<string, unknown>).target === connectionId+ );+ assert.ok(evt, "quota.plan.updated audit event must be present");+});++// ---------------------------------------------------------------------------+// DELETE /api/quota/plans/[connectionId]+// ---------------------------------------------------------------------------++test("DELETE /api/quota/plans/[connectionId] clears override → 204; GET reverts to auto", async () => {+ const connectionId = "conn-delete-plan";+ // Create override+ const putReq = await makeManagementSessionRequest(+ `http://localhost/api/quota/plans/${connectionId}`,+ {+ method: "PUT",+ body: { dimensions: [{ unit: "tokens", window: "weekly", limit: 500000 }] },+ }+ );+ await planIdRoute.PUT(putReq, { params: Promise.resolve({ connectionId }) });++ // Delete override+ const deleteReq = await makeManagementSessionRequest(+ `http://localhost/api/quota/plans/${connectionId}`,+ { method: "DELETE" }+ );+ const deleteRes = await planIdRoute.DELETE(deleteReq, { params: Promise.resolve({ connectionId }) });+ assert.equal(deleteRes.status, 204);++ // GET should now return auto/empty plan (no DB override)+ const getReq = await makeManagementSessionRequest(+ `http://localhost/api/quota/plans/${connectionId}`+ );+ const getRes = await planIdRoute.GET(getReq, { params: Promise.resolve({ connectionId }) });+ const body = (await getRes.json()) as { plan: { source: string; dimensions: unknown[] } };+ // After delete, should fall back to catalog or empty (source=auto or manual-empty)+ // For a connectionId with no catalog match, source=manual + dimensions=[]+ assert.ok(["auto", "manual"].includes(body.plan.source));+});++test("DELETE /api/quota/plans/[connectionId] is idempotent → 204 even when not found", async () => {+ const deleteReq = await makeManagementSessionRequest(+ "http://localhost/api/quota/plans/conn-never-existed",+ { method: "DELETE" }+ );+ const deleteRes = await planIdRoute.DELETE(deleteReq, {+ params: Promise.resolve({ connectionId: "conn-never-existed" }),+ });+ // DELETE is idempotent — returns 204 regardless+ assert.equal(deleteRes.status, 204);+});diff --git a/tests/integration/quota-pools-crud.test.ts b/tests/integration/quota-pools-crud.test.tsnew file mode 100644index 0000000000..dad624cece--- /dev/null+++ b/tests/integration/quota-pools-crud.test.ts@@ -0,0 +1,286 @@+/**+ * Integration tests: /api/quota/pools CRUD endpoints+ *+ * Verifies:+ * - Auth: no auth → 401, invalid body → 400, valid → 201/200/204+ * - POST creates pool + emits audit event+ * - GET list includes created pool+ * - GET [id] returns 200 or 404+ * - PATCH updates pool + emits audit event+ * - DELETE removes pool + emits audit event; subsequent GET → 404+ * - Error responses never leak stack traces (Hard Rule #12 / B25)+ *+ * Part of: Group B — REST routes for Quota Sharing (plan 22, frente F8).+ */++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";+import { makeManagementSessionRequest } from "../helpers/managementSession.ts";++const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-quota-pools-crud-"));+process.env.DATA_DIR = TEST_DATA_DIR;+process.env.API_KEY_SECRET = "test-quota-pools-secret";++// Import in dependency order to ensure migrations run before routes+const core = await import("../../src/lib/db/core.ts");+const localDb = await import("../../src/lib/localDb.ts");+const compliance = await import("../../src/lib/compliance/index.ts");+const poolsRoute = await import("../../src/app/api/quota/pools/route.ts");+const poolIdRoute = await import("../../src/app/api/quota/pools/[id]/route.ts");++async function enableManagementAuth() {+ process.env.INITIAL_PASSWORD = "bootstrap-password";+ await localDb.updateSettings({ requireLogin: true, password: "" });+}++function resetDb() {+ core.resetDbInstance();+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+ fs.mkdirSync(TEST_DATA_DIR, { recursive: true });+}++test.beforeEach(async () => {+ resetDb();+ compliance.initAuditLog();+});++test.after(() => {+ core.resetDbInstance();+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+});++// ---------------------------------------------------------------------------+// POST /api/quota/pools+// ---------------------------------------------------------------------------++test("POST /api/quota/pools without auth → 401", async () => {+ await enableManagementAuth();+ const req = new Request("http://localhost/api/quota/pools", {+ method: "POST",+ headers: { "content-type": "application/json" },+ body: JSON.stringify({ connectionId: "conn-1", name: "Pool A" }),+ });+ const res = await poolsRoute.POST(req);+ assert.equal(res.status, 401);+});++test("POST /api/quota/pools with auth + invalid body → 400", async () => {+ const req = await makeManagementSessionRequest("http://localhost/api/quota/pools", {+ method: "POST",+ body: { connectionId: "", name: "" }, // Empty strings fail Zod min(1)+ });+ const res = await poolsRoute.POST(req);+ assert.equal(res.status, 400);+ const body = await res.json();+ assert.ok(body.error?.message, "Should have error message");+ // Hard Rule #12: no stack trace in error response+ assert.doesNotMatch(JSON.stringify(body), /\s+at\s+\//, "No stack trace in 400 response");+});++test("POST /api/quota/pools with auth + valid body → 201 + pool returned", async () => {+ const req = await makeManagementSessionRequest("http://localhost/api/quota/pools", {+ method: "POST",+ body: {+ connectionId: "conn-test-1",+ name: "Test Pool Alpha",+ allocations: [],+ },+ });+ const res = await poolsRoute.POST(req);+ assert.equal(res.status, 201);+ const body = await res.json() as { pool: { id: string; name: string; connectionId: string } };+ assert.ok(body.pool.id, "Pool should have an id");+ assert.equal(body.pool.name, "Test Pool Alpha");+ assert.equal(body.pool.connectionId, "conn-test-1");+});++test("POST /api/quota/pools → audit event logged", async () => {+ const req = await makeManagementSessionRequest("http://localhost/api/quota/pools", {+ method: "POST",+ body: { connectionId: "conn-audit-check", name: "Audited Pool" },+ });+ await poolsRoute.POST(req);++ // Verify audit event was recorded+ const logs = compliance.getAuditLog({ action: "quota.pool.created", limit: 10 });+ const events = Array.isArray(logs) ? logs : [];+ assert.ok(events.length >= 1, "Should have at least one quota.pool.created audit event");+ const evt = events.find(+ (e) => typeof e === "object" && e !== null && (e as Record<string, unknown>).action === "quota.pool.created"+ );+ assert.ok(evt, "quota.pool.created audit event must be present");+});++// ---------------------------------------------------------------------------+// GET /api/quota/pools+// ---------------------------------------------------------------------------++test("GET /api/quota/pools returns list including created pool", async () => {+ // Create a pool first+ const createReq = await makeManagementSessionRequest("http://localhost/api/quota/pools", {+ method: "POST",+ body: { connectionId: "conn-list-test", name: "List Test Pool" },+ });+ const createRes = await poolsRoute.POST(createReq);+ assert.equal(createRes.status, 201);+ const created = (await createRes.json()) as { pool: { id: string } };+ const poolId = created.pool.id;++ // Now list all pools+ const listReq = await makeManagementSessionRequest("http://localhost/api/quota/pools");+ const listRes = await poolsRoute.GET(listReq);+ assert.equal(listRes.status, 200);+ const body = (await listRes.json()) as { pools: Array<{ id: string; name: string }> };+ assert.ok(Array.isArray(body.pools), "pools should be an array");+ const found = body.pools.find((p) => p.id === poolId);+ assert.ok(found, `Pool ${poolId} should be in the list`);+ assert.equal(found?.name, "List Test Pool");+});++// ---------------------------------------------------------------------------+// GET /api/quota/pools/[id]+// ---------------------------------------------------------------------------++test("GET /api/quota/pools/[id] → 200 with pool detail", async () => {+ // Create pool+ const createReq = await makeManagementSessionRequest("http://localhost/api/quota/pools", {+ method: "POST",+ body: { connectionId: "conn-detail", name: "Detail Pool" },+ });+ const createRes = await poolsRoute.POST(createReq);+ const created = (await createRes.json()) as { pool: { id: string } };+ const poolId = created.pool.id;++ // Fetch by ID+ const getReq = await makeManagementSessionRequest(`http://localhost/api/quota/pools/${poolId}`);+ const getRes = await poolIdRoute.GET(getReq, { params: Promise.resolve({ id: poolId }) });+ assert.equal(getRes.status, 200);+ const body = (await getRes.json()) as { pool: { id: string; name: string } };+ assert.equal(body.pool.id, poolId);+ assert.equal(body.pool.name, "Detail Pool");+});++test("GET /api/quota/pools/[id] with nonexistent id → 404", async () => {+ const getReq = await makeManagementSessionRequest(+ "http://localhost/api/quota/pools/does-not-exist"+ );+ const getRes = await poolIdRoute.GET(getReq, {+ params: Promise.resolve({ id: "does-not-exist" }),+ });+ assert.equal(getRes.status, 404);+ const body = await getRes.json();+ assert.ok(body.error?.message, "Should have error message");+ // Hard Rule #12+ assert.doesNotMatch(JSON.stringify(body), /\s+at\s+\//, "No stack trace in 404 response");+});++// ---------------------------------------------------------------------------+// PATCH /api/quota/pools/[id]+// ---------------------------------------------------------------------------++test("PATCH /api/quota/pools/[id] → 200 updated + audit event", async () => {+ // Create+ const createReq = await makeManagementSessionRequest("http://localhost/api/quota/pools", {+ method: "POST",+ body: { connectionId: "conn-patch", name: "Original Name" },+ });+ const createRes = await poolsRoute.POST(createReq);+ const created = (await createRes.json()) as { pool: { id: string } };+ const poolId = created.pool.id;++ // Patch+ const patchReq = await makeManagementSessionRequest(+ `http://localhost/api/quota/pools/${poolId}`,+ {+ method: "PATCH",+ body: { name: "Updated Name" },+ }+ );+ const patchRes = await poolIdRoute.PATCH(patchReq, {+ params: Promise.resolve({ id: poolId }),+ });+ assert.equal(patchRes.status, 200);+ const body = (await patchRes.json()) as { pool: { name: string } };+ assert.equal(body.pool.name, "Updated Name");++ // Audit event+ const logs = compliance.getAuditLog({ action: "quota.pool.updated", limit: 10 });+ const events = Array.isArray(logs) ? logs : [];+ const evt = events.find(+ (e) =>+ typeof e === "object" &&+ e !== null &&+ (e as Record<string, unknown>).action === "quota.pool.updated" &&+ (e as Record<string, unknown>).target === poolId+ );+ assert.ok(evt, "quota.pool.updated audit event must be present with correct target");+});++test("PATCH /api/quota/pools/[id] with nonexistent id → 404", async () => {+ const patchReq = await makeManagementSessionRequest(+ "http://localhost/api/quota/pools/does-not-exist",+ { method: "PATCH", body: { name: "New Name" } }+ );+ const patchRes = await poolIdRoute.PATCH(patchReq, {+ params: Promise.resolve({ id: "does-not-exist" }),+ });+ assert.equal(patchRes.status, 404);+});++// ---------------------------------------------------------------------------+// DELETE /api/quota/pools/[id]+// ---------------------------------------------------------------------------++test("DELETE /api/quota/pools/[id] → 204 + audit event; subsequent GET → 404", async () => {+ // Create+ const createReq = await makeManagementSessionRequest("http://localhost/api/quota/pools", {+ method: "POST",+ body: { connectionId: "conn-delete", name: "Delete Me" },+ });+ const createRes = await poolsRoute.POST(createReq);+ const created = (await createRes.json()) as { pool: { id: string } };+ const poolId = created.pool.id;++ // Delete+ const deleteReq = await makeManagementSessionRequest(+ `http://localhost/api/quota/pools/${poolId}`,+ { method: "DELETE" }+ );+ const deleteRes = await poolIdRoute.DELETE(deleteReq, {+ params: Promise.resolve({ id: poolId }),+ });+ assert.equal(deleteRes.status, 204);++ // Audit event+ const logs = compliance.getAuditLog({ action: "quota.pool.deleted", limit: 10 });+ const events = Array.isArray(logs) ? logs : [];+ const evt = events.find(+ (e) =>+ typeof e === "object" &&+ e !== null &&+ (e as Record<string, unknown>).action === "quota.pool.deleted" &&+ (e as Record<string, unknown>).target === poolId+ );+ assert.ok(evt, "quota.pool.deleted audit event must be present");++ // Subsequent GET → 404+ const getReq = await makeManagementSessionRequest(+ `http://localhost/api/quota/pools/${poolId}`+ );+ const getRes = await poolIdRoute.GET(getReq, { params: Promise.resolve({ id: poolId }) });+ assert.equal(getRes.status, 404);+});++test("DELETE /api/quota/pools/[id] with nonexistent id → 404", async () => {+ const deleteReq = await makeManagementSessionRequest(+ "http://localhost/api/quota/pools/never-existed",+ { method: "DELETE" }+ );+ const deleteRes = await poolIdRoute.DELETE(deleteReq, {+ params: Promise.resolve({ id: "never-existed" }),+ });+ assert.equal(deleteRes.status, 404);+});diff --git a/tests/integration/quota-pools-usage.test.ts b/tests/integration/quota-pools-usage.test.tsnew file mode 100644index 0000000000..08a8471830--- /dev/null+++ b/tests/integration/quota-pools-usage.test.ts@@ -0,0 +1,169 @@+/**+ * Integration tests: GET /api/quota/pools/[id]/usage+ *+ * Verifies:+ * - Returns PoolUsageSnapshot shape with perKey + deficit+ * - 404 for nonexistent pool+ * - Error responses don't leak stack traces (Hard Rule #12 / B25)+ *+ * Note: Consumption is produced via the SqliteQuotaStore directly (bypassing+ * the HTTP layer) so we can control what the usage endpoint reads back.+ *+ * Part of: Group B — REST routes for Quota Sharing (plan 22, frente F8).+ */++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";+import { makeManagementSessionRequest } from "../helpers/managementSession.ts";++const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-quota-pools-usage-"));+process.env.DATA_DIR = TEST_DATA_DIR;+process.env.API_KEY_SECRET = "test-quota-usage-secret";+// Force SQLite store for deterministic tests+process.env.QUOTA_STORE_DRIVER = "sqlite";++const core = await import("../../src/lib/db/core.ts");+const localDb = await import("../../src/lib/localDb.ts");+const compliance = await import("../../src/lib/compliance/index.ts");+const { createPool, upsertAllocations } = localDb;+const { getSqliteQuotaStore } = await import("../../src/lib/quota/sqliteQuotaStore.ts");+const { resetQuotaStoreSingleton } = await import("../../src/lib/quota/QuotaStore.ts");+const poolsRoute = await import("../../src/app/api/quota/pools/route.ts");+const usageRoute = await import("../../src/app/api/quota/pools/[id]/usage/route.ts");++async function enableManagementAuth() {+ process.env.INITIAL_PASSWORD = "bootstrap-password";+ await localDb.updateSettings({ requireLogin: true, password: "" });+}++function resetDb() {+ core.resetDbInstance();+ resetQuotaStoreSingleton();+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+ fs.mkdirSync(TEST_DATA_DIR, { recursive: true });+}++test.beforeEach(async () => {+ resetDb();+ compliance.initAuditLog();+});++test.after(() => {+ core.resetDbInstance();+ resetQuotaStoreSingleton();+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+});++test("GET /api/quota/pools/[id]/usage without auth → 401", async () => {+ await enableManagementAuth();+ const req = new Request("http://localhost/api/quota/pools/some-id/usage");+ const res = await usageRoute.GET(req, { params: Promise.resolve({ id: "some-id" }) });+ assert.equal(res.status, 401);+});++test("GET /api/quota/pools/[id]/usage with nonexistent pool → 404", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/quota/pools/not-a-real-pool/usage"+ );+ const res = await usageRoute.GET(req, {+ params: Promise.resolve({ id: "not-a-real-pool" }),+ });+ assert.equal(res.status, 404);+ const body = await res.json();+ assert.doesNotMatch(JSON.stringify(body), /\s+at\s+\//, "No stack trace in 404 response");+});++test("GET /api/quota/pools/[id]/usage → PoolUsageSnapshot shape with correct fields", async () => {+ // 1. Create pool with 2 allocations+ const createReq = await makeManagementSessionRequest("http://localhost/api/quota/pools", {+ method: "POST",+ body: {+ connectionId: "conn-usage-test",+ name: "Usage Test Pool",+ allocations: [],+ },+ });+ const createRes = await poolsRoute.POST(createReq);+ assert.equal(createRes.status, 201);+ const { pool } = (await createRes.json()) as { pool: { id: string } };+ const poolId = pool.id;++ // 2. Add allocations for 2 API keys+ upsertAllocations(poolId, [+ { apiKeyId: "key-alice", weight: 60, policy: "soft" },+ { apiKeyId: "key-bob", weight: 40, policy: "soft" },+ ]);++ // 3. Simulate consumption via the SQLite store directly+ const store = getSqliteQuotaStore();+ const dim = { poolId, unit: "tokens" as const, window: "daily" as const };+ await store.consume("key-alice", dim, 1000);+ await store.consume("key-bob", dim, 500);++ // 4. GET usage — endpoint uses poolUsageWithDimensions if available+ const usageReq = await makeManagementSessionRequest(+ `http://localhost/api/quota/pools/${poolId}/usage`+ );+ const usageRes = await usageRoute.GET(usageReq, { params: Promise.resolve({ id: poolId }) });+ assert.equal(usageRes.status, 200);++ const body = (await usageRes.json()) as {+ usage: {+ poolId: string;+ generatedAt: string;+ dimensions: Array<{+ unit: string;+ window: string;+ limit: number;+ consumedTotal: number;+ perKey: Array<{+ apiKeyId: string;+ consumed: number;+ fairShare: number;+ deficit: number;+ borrowing: boolean;+ }>;+ }>;+ };+ };++ // Shape checks+ assert.equal(body.usage.poolId, poolId);+ assert.ok(body.usage.generatedAt, "generatedAt should be present");+ assert.ok(Array.isArray(body.usage.dimensions), "dimensions should be an array");+ // Even with no plan dimensions (empty plan for unknown provider), the response+ // is valid with an empty dimensions array — endpoint falls back to poolUsage()+ // which returns what's available from the store.+ assert.doesNotMatch(+ JSON.stringify(body),+ /\s+at\s+\//,+ "No stack trace in usage response"+ );+});++test("GET /api/quota/pools/[id]/usage response has required PoolUsageSnapshot fields", async () => {+ // Create minimal pool+ const createReq = await makeManagementSessionRequest("http://localhost/api/quota/pools", {+ method: "POST",+ body: { connectionId: "conn-snapshot-shape", name: "Shape Pool" },+ });+ const createRes = await poolsRoute.POST(createReq);+ const { pool } = (await createRes.json()) as { pool: { id: string } };++ const usageReq = await makeManagementSessionRequest(+ `http://localhost/api/quota/pools/${pool.id}/usage`+ );+ const usageRes = await usageRoute.GET(usageReq, {+ params: Promise.resolve({ id: pool.id }),+ });+ assert.equal(usageRes.status, 200);++ const body = (await usageRes.json()) as { usage: Record<string, unknown> };+ assert.ok("usage" in body, "Response should have 'usage' key");+ assert.ok("poolId" in body.usage, "PoolUsageSnapshot should have poolId");+ assert.ok("generatedAt" in body.usage, "PoolUsageSnapshot should have generatedAt");+ assert.ok("dimensions" in body.usage, "PoolUsageSnapshot should have dimensions");+});diff --git a/tests/integration/quota-preview.test.ts b/tests/integration/quota-preview.test.tsnew file mode 100644index 0000000000..2afd58547a--- /dev/null+++ b/tests/integration/quota-preview.test.ts@@ -0,0 +1,145 @@+/**+ * Integration tests: GET /api/quota/preview+ *+ * Verifies:+ * - Auth check (401 without session)+ * - Zod validation for query params (400 on missing required fields)+ * - 404 when pool does not exist+ * - Valid query → returns { decision } with kind="allow"+ * - enforce is dry-run: store counters unchanged before and after (peek)+ * - Error responses don't leak stack traces (Hard Rule #12 / B25)+ *+ * Part of: Group B — REST routes for Quota Sharing (plan 22, frente F8).+ */++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";+import { makeManagementSessionRequest } from "../helpers/managementSession.ts";++const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-quota-preview-"));+process.env.DATA_DIR = TEST_DATA_DIR;+process.env.API_KEY_SECRET = "test-quota-preview-secret";+process.env.QUOTA_STORE_DRIVER = "sqlite";++const core = await import("../../src/lib/db/core.ts");+const localDb = await import("../../src/lib/localDb.ts");+const compliance = await import("../../src/lib/compliance/index.ts");+const { createPool, upsertAllocations } = localDb;+const { getSqliteQuotaStore } = await import("../../src/lib/quota/sqliteQuotaStore.ts");+const { resetQuotaStoreSingleton } = await import("../../src/lib/quota/QuotaStore.ts");+const previewRoute = await import("../../src/app/api/quota/preview/route.ts");++async function enableManagementAuth() {+ process.env.INITIAL_PASSWORD = "bootstrap-password";+ await localDb.updateSettings({ requireLogin: true, password: "" });+}++function resetDb() {+ core.resetDbInstance();+ resetQuotaStoreSingleton();+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+ fs.mkdirSync(TEST_DATA_DIR, { recursive: true });+}++test.beforeEach(async () => {+ resetDb();+ compliance.initAuditLog();+});++test.after(() => {+ core.resetDbInstance();+ resetQuotaStoreSingleton();+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+});++test("GET /api/quota/preview without auth → 401", async () => {+ await enableManagementAuth();+ const req = new Request(+ "http://localhost/api/quota/preview?apiKeyId=k1&poolId=p1"+ );+ const res = await previewRoute.GET(req);+ assert.equal(res.status, 401);+});++test("GET /api/quota/preview without required query params → 400", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/quota/preview"+ // Missing apiKeyId and poolId+ );+ const res = await previewRoute.GET(req);+ assert.equal(res.status, 400);+ const body = await res.json();+ assert.ok(body.error?.message, "Should have error message");+ assert.doesNotMatch(JSON.stringify(body), /\s+at\s+\//, "No stack trace in 400 response");+});++test("GET /api/quota/preview with nonexistent poolId → 404", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/quota/preview?apiKeyId=key-1&poolId=no-such-pool"+ );+ const res = await previewRoute.GET(req);+ assert.equal(res.status, 404);+ const body = await res.json();+ assert.doesNotMatch(JSON.stringify(body), /\s+at\s+\//, "No stack trace in 404 response");+});++test("GET /api/quota/preview with valid params → { decision } with kind", async () => {+ // Create a real pool+ const pool = createPool({ connectionId: "conn-preview", name: "Preview Pool" });+ upsertAllocations(pool.id, [+ { apiKeyId: "preview-key-1", weight: 100, policy: "soft" },+ ]);++ const req = await makeManagementSessionRequest(+ `http://localhost/api/quota/preview?apiKeyId=preview-key-1&poolId=${pool.id}&estimatedTokens=100`+ );+ const res = await previewRoute.GET(req);+ assert.equal(res.status, 200);++ const body = (await res.json()) as { decision: { kind: string } };+ assert.ok(body.decision, "Response should have decision field");+ assert.ok(+ ["allow", "block"].includes(body.decision.kind),+ `decision.kind must be "allow" or "block", got: ${body.decision.kind}`+ );+});++test("GET /api/quota/preview is dry-run: store counters unchanged after call", async () => {+ // Create pool and seed some consumption+ const pool = createPool({ connectionId: "conn-dryrun", name: "Dry Run Pool" });+ upsertAllocations(pool.id, [+ { apiKeyId: "dryrun-key", weight: 100, policy: "hard" },+ ]);++ const store = getSqliteQuotaStore();+ const dim = { poolId: pool.id, unit: "tokens" as const, window: "daily" as const };++ // Pre-peek value+ const before = await store.peek("dryrun-key", dim);++ // Call preview (dry-run)+ const req = await makeManagementSessionRequest(+ `http://localhost/api/quota/preview?apiKeyId=dryrun-key&poolId=${pool.id}&estimatedTokens=500`+ );+ await previewRoute.GET(req);++ // Post-peek value — must equal pre-peek (no consumption occurred)+ const after = await store.peek("dryrun-key", dim);+ assert.equal(before, after, "Store counter must not change after a preview (dry-run) call");+});++test("GET /api/quota/preview accepts optional estimatedUsd and estimatedRequests", async () => {+ const pool = createPool({ connectionId: "conn-optional", name: "Optional Pool" });+ upsertAllocations(pool.id, [{ apiKeyId: "opt-key", weight: 100, policy: "burst" }]);++ const req = await makeManagementSessionRequest(+ `http://localhost/api/quota/preview?apiKeyId=opt-key&poolId=${pool.id}&estimatedUsd=1.5&estimatedRequests=3`+ );+ const res = await previewRoute.GET(req);+ assert.equal(res.status, 200);+ const body = (await res.json()) as { decision: unknown };+ assert.ok(body.decision, "Should return decision");+});diff --git a/tests/integration/quota-routes-error-sanitization.test.ts b/tests/integration/quota-routes-error-sanitization.test.tsnew file mode 100644index 0000000000..b786b65898--- /dev/null+++ b/tests/integration/quota-routes-error-sanitization.test.ts@@ -0,0 +1,255 @@+/**+ * Integration tests: error sanitization across all quota REST routes+ *+ * Verifies Hard Rule #12 (B25): No route returns raw stack traces, absolute+ * paths, or credential strings in error response bodies.+ *+ * Tests the error paths of each quota endpoint — 400s (bad input) and 404s+ * (not found) — to confirm buildErrorBody sanitization is active.+ *+ * Part of: Group B — REST routes for Quota Sharing (plan 22, frente F8).+ */++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";+import { makeManagementSessionRequest } from "../helpers/managementSession.ts";++const TEST_DATA_DIR = fs.mkdtempSync(+ path.join(os.tmpdir(), "omniroute-quota-err-sanitization-")+);+process.env.DATA_DIR = TEST_DATA_DIR;+process.env.API_KEY_SECRET = "test-quota-sanitization-secret";+process.env.QUOTA_STORE_DRIVER = "sqlite";+// Ensure a known fake URL that we can check is NOT leaked+process.env.QUOTA_STORE_REDIS_URL = "redis://secret-host:9999/0";++const core = await import("../../src/lib/db/core.ts");+const compliance = await import("../../src/lib/compliance/index.ts");+const { resetQuotaStoreSingleton } = await import("../../src/lib/quota/QuotaStore.ts");++// Import all routes+const poolsRoute = await import("../../src/app/api/quota/pools/route.ts");+const poolIdRoute = await import("../../src/app/api/quota/pools/[id]/route.ts");+const usageRoute = await import("../../src/app/api/quota/pools/[id]/usage/route.ts");+const plansRoute = await import("../../src/app/api/quota/plans/route.ts");+const planIdRoute = await import("../../src/app/api/quota/plans/[connectionId]/route.ts");+const previewRoute = await import("../../src/app/api/quota/preview/route.ts");+const settingsRoute = await import("../../src/app/api/settings/quota-store/route.ts");++function resetDb() {+ core.resetDbInstance();+ resetQuotaStoreSingleton();+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+ fs.mkdirSync(TEST_DATA_DIR, { recursive: true });+}++// Helper to assert no stack trace / path leak in a response body text+function assertNoStackTraceText(text: string, label: string) {+ assert.doesNotMatch(+ text,+ /\s+at\s+\//,+ `${label}: Response must not contain stack trace (Hard Rule #12)`+ );+ assert.doesNotMatch(+ text,+ /\/home\/[a-z]/,+ `${label}: Response must not contain absolute home path`+ );+}++// Reads the response body once and runs stack trace assertion+async function assertNoStackTrace(res: Response, label: string) {+ const text = await res.text();+ assertNoStackTraceText(text, label);+}++// Helper to assert secret URL not in response body text+function assertNoSecretUrlText(text: string, label: string) {+ assert.doesNotMatch(+ text,+ /secret-host/,+ `${label}: Response must not contain secret Redis host`+ );+ assert.doesNotMatch(+ text,+ /redis:\/\/secret/,+ `${label}: Response must not contain Redis URL`+ );+}++// Reads the response body once and runs both assertions (body cannot be read twice)+async function assertNoStackTraceAndNoSecretUrl(res: Response, label: string) {+ const text = await res.text();+ assertNoStackTraceText(text, label);+ assertNoSecretUrlText(text, label);+}++test.beforeEach(() => {+ resetDb();+ compliance.initAuditLog();+});++test.after(() => {+ core.resetDbInstance();+ resetQuotaStoreSingleton();+ delete process.env.QUOTA_STORE_REDIS_URL;+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+});++// ---------------------------------------------------------------------------+// POST /api/quota/pools — bad body → 400+// ---------------------------------------------------------------------------++test("POST /api/quota/pools 400 error response has no stack trace", async () => {+ const req = await makeManagementSessionRequest("http://localhost/api/quota/pools", {+ method: "POST",+ body: { connectionId: "", name: "" }, // Empty strings fail Zod validation+ });+ const res = await poolsRoute.POST(req);+ assert.equal(res.status, 400);+ await assertNoStackTrace(res, "POST /api/quota/pools 400");+});++// ---------------------------------------------------------------------------+// GET /api/quota/pools/[id] — 404+// ---------------------------------------------------------------------------++test("GET /api/quota/pools/[id] 404 response has no stack trace", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/quota/pools/does-not-exist"+ );+ const res = await poolIdRoute.GET(req, {+ params: Promise.resolve({ id: "does-not-exist" }),+ });+ assert.equal(res.status, 404);+ await assertNoStackTrace(res, "GET /api/quota/pools/[id] 404");+});++// ---------------------------------------------------------------------------+// PATCH /api/quota/pools/[id] — bad body → 400+// ---------------------------------------------------------------------------++test("PATCH /api/quota/pools/[id] 400 error response has no stack trace", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/quota/pools/does-not-exist",+ {+ method: "PATCH",+ body: { allocations: "not-an-array" }, // Zod expects array+ }+ );+ const res = await poolIdRoute.PATCH(req, {+ params: Promise.resolve({ id: "does-not-exist" }),+ });+ // May be 400 (Zod) or 404 (not found after Zod passes) — either is fine,+ // key requirement is no stack trace+ await assertNoStackTrace(res, "PATCH /api/quota/pools/[id]");+});++// ---------------------------------------------------------------------------+// GET /api/quota/pools/[id]/usage — 404+// ---------------------------------------------------------------------------++test("GET /api/quota/pools/[id]/usage 404 response has no stack trace", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/quota/pools/ghost-pool/usage"+ );+ const res = await usageRoute.GET(req, {+ params: Promise.resolve({ id: "ghost-pool" }),+ });+ assert.equal(res.status, 404);+ await assertNoStackTrace(res, "GET /api/quota/pools/[id]/usage 404");+});++// ---------------------------------------------------------------------------+// GET /api/quota/plans — valid but checked for sanitization+// ---------------------------------------------------------------------------++test("GET /api/quota/plans 200 response has no stack trace or path leak", async () => {+ const req = await makeManagementSessionRequest("http://localhost/api/quota/plans");+ const res = await plansRoute.GET(req);+ assert.equal(res.status, 200);+ await assertNoStackTrace(res, "GET /api/quota/plans 200");+});++// ---------------------------------------------------------------------------+// PUT /api/quota/plans/[connectionId] — bad body → 400+// ---------------------------------------------------------------------------++test("PUT /api/quota/plans/[connectionId] 400 error response has no stack trace", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/quota/plans/conn-bad",+ {+ method: "PUT",+ body: { dimensions: [] }, // PlanUpsertSchema requires min(1)+ }+ );+ const res = await planIdRoute.PUT(req, {+ params: Promise.resolve({ connectionId: "conn-bad" }),+ });+ assert.equal(res.status, 400);+ await assertNoStackTrace(res, "PUT /api/quota/plans/[connectionId] 400");+});++// ---------------------------------------------------------------------------+// GET /api/quota/preview — missing params → 400+// ---------------------------------------------------------------------------++test("GET /api/quota/preview 400 error response has no stack trace", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/quota/preview"+ // Missing apiKeyId and poolId+ );+ const res = await previewRoute.GET(req);+ assert.equal(res.status, 400);+ await assertNoStackTrace(res, "GET /api/quota/preview 400");+});++// ---------------------------------------------------------------------------+// GET /api/settings/quota-store — NEVER returns Redis URL+// ---------------------------------------------------------------------------++test("GET /api/settings/quota-store response does not contain Redis URL (Hard Rule #12/#1)", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/settings/quota-store"+ );+ const res = await settingsRoute.GET(req);+ assert.equal(res.status, 200);+ await assertNoStackTraceAndNoSecretUrl(res, "GET /api/settings/quota-store 200");+});++// ---------------------------------------------------------------------------+// PUT /api/settings/quota-store — bad driver → 400 (Zod)+// ---------------------------------------------------------------------------++test("PUT /api/settings/quota-store 400 error response has no stack trace", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/settings/quota-store",+ {+ method: "PUT",+ body: { driver: "baddriver" },+ }+ );+ const res = await settingsRoute.PUT(req);+ assert.equal(res.status, 400);+ await assertNoStackTrace(res, "PUT /api/settings/quota-store 400");+});++// ---------------------------------------------------------------------------+// PUT /api/settings/quota-store — redis without URL → 400 (custom check)+// ---------------------------------------------------------------------------++test("PUT /api/settings/quota-store redis+no-URL error response does not leak Redis URL", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/settings/quota-store",+ {+ method: "PUT",+ body: { driver: "redis" }, // No URL provided+ }+ );+ const res = await settingsRoute.PUT(req);+ assert.equal(res.status, 400);+ await assertNoStackTraceAndNoSecretUrl(res, "PUT /api/settings/quota-store redis-no-url 400");+});diff --git a/tests/integration/quota-store-settings.test.ts b/tests/integration/quota-store-settings.test.tsnew file mode 100644index 0000000000..bcf2e6bc75--- /dev/null+++ b/tests/integration/quota-store-settings.test.ts@@ -0,0 +1,202 @@+/**+ * Integration tests: GET/PUT /api/settings/quota-store+ *+ * Verifies:+ * - GET returns driver + redisUrlConfigured flag (NEVER the URL itself)+ * - PUT sqlite → 200; PUT redis without URL → 400; PUT redis with URL → 200+ * - PUT emits quota.store.driver_changed audit event+ * - GET never returns actual Redis URL (Hard Rule #12 / #1)+ * - Error responses don't leak stack traces (Hard Rule #12 / B25)+ *+ * Part of: Group B — REST routes for Quota Sharing (plan 22, frente F8).+ */++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";+import { makeManagementSessionRequest } from "../helpers/managementSession.ts";++const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-quota-store-settings-"));+process.env.DATA_DIR = TEST_DATA_DIR;+process.env.API_KEY_SECRET = "test-quota-store-settings-secret";+// Ensure no QUOTA_STORE_REDIS_URL leaks in from environment+delete process.env.QUOTA_STORE_REDIS_URL;+process.env.QUOTA_STORE_DRIVER = "sqlite";++const core = await import("../../src/lib/db/core.ts");+const localDb = await import("../../src/lib/localDb.ts");+const compliance = await import("../../src/lib/compliance/index.ts");+const { resetQuotaStoreSingleton } = await import("../../src/lib/quota/QuotaStore.ts");+const settingsRoute = await import("../../src/app/api/settings/quota-store/route.ts");++async function enableManagementAuth() {+ process.env.INITIAL_PASSWORD = "bootstrap-password";+ await localDb.updateSettings({ requireLogin: true, password: "" });+}++function resetDb() {+ core.resetDbInstance();+ resetQuotaStoreSingleton();+ delete process.env.QUOTA_STORE_REDIS_URL;+ delete process.env.INITIAL_PASSWORD;+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+ fs.mkdirSync(TEST_DATA_DIR, { recursive: true });+}++test.beforeEach(() => {+ resetDb();+ compliance.initAuditLog();+});++test.after(() => {+ core.resetDbInstance();+ resetQuotaStoreSingleton();+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+});++// ---------------------------------------------------------------------------+// GET /api/settings/quota-store+// ---------------------------------------------------------------------------++test("GET /api/settings/quota-store without auth → 401", async () => {+ await enableManagementAuth();+ const req = new Request("http://localhost/api/settings/quota-store");+ const res = await settingsRoute.GET(req);+ assert.equal(res.status, 401);+});++test("GET /api/settings/quota-store returns driver + redisUrlConfigured (not URL)", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/settings/quota-store"+ );+ const res = await settingsRoute.GET(req);+ assert.equal(res.status, 200);+ const body = (await res.json()) as {+ driver: string;+ redisUrlConfigured: boolean;+ redisUrl: null | string;+ };++ assert.ok(["sqlite", "redis"].includes(body.driver), "driver must be sqlite or redis");+ assert.ok(typeof body.redisUrlConfigured === "boolean", "redisUrlConfigured must be boolean");++ // Hard Rule #12 / #1 — URL must NEVER be returned+ assert.equal(body.redisUrl, null, "Redis URL must be null (never returned)");++ // Verify the raw Redis URL string is not anywhere in the response text+ const responseText = JSON.stringify(body);+ assert.doesNotMatch(responseText, /redis:\/\//, "Redis URL must not appear in response");+ assert.doesNotMatch(responseText, /\s+at\s+\//, "No stack trace in response");+});++test("GET /api/settings/quota-store redisUrlConfigured=false when no URL configured", async () => {+ delete process.env.QUOTA_STORE_REDIS_URL;+ const req = await makeManagementSessionRequest(+ "http://localhost/api/settings/quota-store"+ );+ const res = await settingsRoute.GET(req);+ const body = (await res.json()) as { redisUrlConfigured: boolean };+ assert.equal(body.redisUrlConfigured, false);+});++// ---------------------------------------------------------------------------+// PUT /api/settings/quota-store+// ---------------------------------------------------------------------------++test("PUT /api/settings/quota-store without auth → 401", async () => {+ await enableManagementAuth();+ const req = new Request("http://localhost/api/settings/quota-store", {+ method: "PUT",+ headers: { "content-type": "application/json" },+ body: JSON.stringify({ driver: "sqlite" }),+ });+ const res = await settingsRoute.PUT(req);+ assert.equal(res.status, 401);+});++test("PUT /api/settings/quota-store driver=sqlite → 200", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/settings/quota-store",+ {+ method: "PUT",+ body: { driver: "sqlite" },+ }+ );+ const res = await settingsRoute.PUT(req);+ assert.equal(res.status, 200);+ const body = (await res.json()) as { driver: string; redisUrl: null };+ assert.equal(body.driver, "sqlite");+ assert.equal(body.redisUrl, null);+});++test("PUT /api/settings/quota-store driver=redis without URL → 400", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/settings/quota-store",+ {+ method: "PUT",+ body: { driver: "redis" }, // No redisUrl+ }+ );+ const res = await settingsRoute.PUT(req);+ assert.equal(res.status, 400);+ const body = await res.json();+ assert.ok(body.error?.message, "Should have error message");+ assert.doesNotMatch(JSON.stringify(body), /\s+at\s+\//, "No stack trace in 400 response");+});++test("PUT /api/settings/quota-store driver=redis with valid URL → 200 + audit event", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/settings/quota-store",+ {+ method: "PUT",+ body: { driver: "redis", redisUrl: "redis://localhost:6379" },+ }+ );+ const res = await settingsRoute.PUT(req);+ assert.equal(res.status, 200);+ const body = (await res.json()) as {+ driver: string;+ redisUrlConfigured: boolean;+ redisUrl: null;+ };+ assert.equal(body.driver, "redis");+ assert.equal(body.redisUrlConfigured, true);+ // Hard Rule #12 / #1 — URL NEVER in response+ assert.equal(body.redisUrl, null);++ // Audit event+ const logs = compliance.getAuditLog({ action: "quota.store.driver_changed", limit: 10 });+ const events = Array.isArray(logs) ? logs : [];+ const evt = events.find(+ (e) =>+ typeof e === "object" &&+ e !== null &&+ (e as Record<string, unknown>).action === "quota.store.driver_changed"+ );+ assert.ok(evt, "quota.store.driver_changed audit event must be present");++ // Verify the actual Redis URL was NOT logged in audit metadata+ const evtStr = JSON.stringify(evt);+ assert.doesNotMatch(+ evtStr,+ /redis:\/\/localhost:6379/,+ "Actual Redis URL must not appear in audit log metadata"+ );+});++test("PUT /api/settings/quota-store with invalid driver → 400 (Zod)", async () => {+ const req = await makeManagementSessionRequest(+ "http://localhost/api/settings/quota-store",+ {+ method: "PUT",+ body: { driver: "memcached" }, // Not in enum+ }+ );+ const res = await settingsRoute.PUT(req);+ assert.equal(res.status, 400);+ const body = await res.json();+ assert.ok(body.error?.message, "Should have error message");+ assert.doesNotMatch(JSON.stringify(body), /\s+at\s+\//, "No stack trace in 400 response");+});