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(db): unit tests for F2 modules

diegosouzapw80fa37f30f73
diff --git a/tests/unit/db-agent-bridge-bypass.test.ts b/tests/unit/db-agent-bridge-bypass.test.ts
new file mode 100644
index 0000000000..a45e8f8831
--- /dev/null
+++ b/tests/unit/db-agent-bridge-bypass.test.ts
@@ -0,0 +1,133 @@
+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-db-agent-bridge-bypass-")
+);
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const mod = await import("../../src/lib/db/agentBridgeBypass.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 (error: any) {
+ if ((error?.code === "EBUSY" || error?.code === "EPERM") && attempt < 9) {
+ await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
+ } else {
+ throw error;
+ }
+ }
+ }
+
+ 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 });
+});
+
+const DEFAULT_PATTERNS = [
+ "*.googleapis.com",
+ "*.gstatic.com",
+ "accounts.google.com",
+ "login.microsoftonline.com",
+];
+
+test("getAllBypassPatterns returns empty array when table is empty", () => {
+ const rows = mod.getAllBypassPatterns();
+ assert.deepEqual(rows, []);
+});
+
+test("seedDefaultBypassPatterns inserts default patterns with source=default", () => {
+ mod.seedDefaultBypassPatterns(DEFAULT_PATTERNS);
+
+ const rows = mod.getAllBypassPatterns();
+ assert.equal(rows.length, DEFAULT_PATTERNS.length);
+
+ for (const row of rows) {
+ assert.equal(row.source, "default");
+ assert.ok(DEFAULT_PATTERNS.includes(row.pattern));
+ }
+});
+
+test("seedDefaultBypassPatterns is idempotent — calling twice does not duplicate", () => {
+ mod.seedDefaultBypassPatterns(DEFAULT_PATTERNS);
+ mod.seedDefaultBypassPatterns(DEFAULT_PATTERNS);
+
+ const rows = mod.getAllBypassPatterns();
+ assert.equal(rows.length, DEFAULT_PATTERNS.length);
+});
+
+test("getUserBypassPatterns returns only user patterns", () => {
+ mod.seedDefaultBypassPatterns(DEFAULT_PATTERNS);
+ mod.replaceUserBypassPatterns(["*.internal.example.com", "localhost"]);
+
+ const userPatterns = mod.getUserBypassPatterns();
+ assert.equal(userPatterns.length, 2);
+ assert.ok(userPatterns.includes("*.internal.example.com"));
+ assert.ok(userPatterns.includes("localhost"));
+
+ // Defaults should not appear in user patterns
+ for (const p of DEFAULT_PATTERNS) {
+ assert.ok(!userPatterns.includes(p));
+ }
+});
+
+test("replaceUserBypassPatterns replaces only user entries — defaults untouched", () => {
+ mod.seedDefaultBypassPatterns(DEFAULT_PATTERNS);
+ mod.replaceUserBypassPatterns(["custom.host.1"]);
+ mod.replaceUserBypassPatterns(["custom.host.2", "custom.host.3"]);
+
+ const allRows = mod.getAllBypassPatterns();
+ const defaultRows = allRows.filter((r) => r.source === "default");
+ const userRows = allRows.filter((r) => r.source === "user");
+
+ assert.equal(defaultRows.length, DEFAULT_PATTERNS.length);
+ assert.equal(userRows.length, 2);
+
+ const userPatterns = userRows.map((r) => r.pattern);
+ assert.ok(!userPatterns.includes("custom.host.1"), "old user pattern must be replaced");
+ assert.ok(userPatterns.includes("custom.host.2"));
+ assert.ok(userPatterns.includes("custom.host.3"));
+});
+
+test("replaceUserBypassPatterns with empty array clears all user patterns", () => {
+ mod.seedDefaultBypassPatterns(DEFAULT_PATTERNS);
+ mod.replaceUserBypassPatterns(["temp.host"]);
+ mod.replaceUserBypassPatterns([]);
+
+ const userPatterns = mod.getUserBypassPatterns();
+ assert.equal(userPatterns.length, 0);
+
+ // Defaults remain
+ const allRows = mod.getAllBypassPatterns();
+ assert.equal(allRows.length, DEFAULT_PATTERNS.length);
+});
+
+test("getAllBypassPatterns returns both default and user patterns", () => {
+ mod.seedDefaultBypassPatterns(["*.example.com"]);
+ mod.replaceUserBypassPatterns(["custom.host"]);
+
+ const allRows = mod.getAllBypassPatterns();
+ assert.equal(allRows.length, 2);
+
+ const sources = new Set(allRows.map((r) => r.source));
+ assert.ok(sources.has("default"));
+ assert.ok(sources.has("user"));
+});
diff --git a/tests/unit/db-agent-bridge-mappings.test.ts b/tests/unit/db-agent-bridge-mappings.test.ts
new file mode 100644
index 0000000000..5c03d24fa4
--- /dev/null
+++ b/tests/unit/db-agent-bridge-mappings.test.ts
@@ -0,0 +1,126 @@
+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-db-agent-bridge-mappings-")
+);
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const mod = await import("../../src/lib/db/agentBridgeMappings.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 (error: any) {
+ if ((error?.code === "EBUSY" || error?.code === "EPERM") && attempt < 9) {
+ await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
+ } else {
+ throw error;
+ }
+ }
+ }
+
+ 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 });
+});
+
+test("getMappingsForAgent returns empty array when no mappings exist", () => {
+ const rows = mod.getMappingsForAgent("antigravity");
+ assert.deepEqual(rows, []);
+});
+
+test("setMappings inserts and retrieves mappings for an agent", () => {
+ mod.setMappings("copilot", [
+ { source: "gpt-4", target: "openai/gpt-4.1" },
+ { source: "gpt-3.5-turbo", target: "openai/gpt-4o-mini" },
+ ]);
+
+ const rows = mod.getMappingsForAgent("copilot");
+ assert.equal(rows.length, 2);
+
+ const sources = rows.map((r) => r.source_model);
+ assert.ok(sources.includes("gpt-4"));
+ assert.ok(sources.includes("gpt-3.5-turbo"));
+
+ const gpt4Row = rows.find((r) => r.source_model === "gpt-4");
+ assert.equal(gpt4Row?.target_model, "openai/gpt-4.1");
+ assert.equal(gpt4Row?.agent_id, "copilot");
+});
+
+test("setMappings is transactional — replaces all mappings idempotently", () => {
+ // First set
+ mod.setMappings("cursor", [
+ { source: "claude-3-5-sonnet", target: "anthropic/claude-sonnet-4-5" },
+ ]);
+
+ // Second set — should replace (not accumulate)
+ mod.setMappings("cursor", [
+ { source: "claude-3-opus", target: "anthropic/claude-opus-4" },
+ { source: "gpt-4o", target: "openai/gpt-4.1" },
+ ]);
+
+ const rows = mod.getMappingsForAgent("cursor");
+ assert.equal(rows.length, 2);
+
+ const sources = rows.map((r) => r.source_model);
+ assert.ok(!sources.includes("claude-3-5-sonnet"), "old mapping should be replaced");
+ assert.ok(sources.includes("claude-3-opus"));
+ assert.ok(sources.includes("gpt-4o"));
+});
+
+test("setMappings with empty array clears all mappings for agent", () => {
+ mod.setMappings("zed", [{ source: "gpt-4", target: "openai/gpt-4.1" }]);
+ mod.setMappings("zed", []);
+
+ const rows = mod.getMappingsForAgent("zed");
+ assert.equal(rows.length, 0);
+});
+
+test("setMappings does not affect mappings for other agents", () => {
+ mod.setMappings("kiro", [{ source: "gpt-4", target: "openai/gpt-4.1" }]);
+ mod.setMappings("codex", [{ source: "o3", target: "openai/o3" }]);
+ mod.setMappings("kiro", [{ source: "gpt-4o", target: "openai/gpt-4o" }]);
+
+ const codexRows = mod.getMappingsForAgent("codex");
+ assert.equal(codexRows.length, 1);
+ assert.equal(codexRows[0].source_model, "o3");
+});
+
+test("deleteMapping removes a specific source mapping", () => {
+ mod.setMappings("antigravity", [
+ { source: "gpt-4", target: "openai/gpt-4.1" },
+ { source: "gpt-3.5-turbo", target: "openai/gpt-4o-mini" },
+ ]);
+
+ mod.deleteMapping("antigravity", "gpt-4");
+
+ const rows = mod.getMappingsForAgent("antigravity");
+ assert.equal(rows.length, 1);
+ assert.equal(rows[0].source_model, "gpt-3.5-turbo");
+});
+
+test("deleteMapping is a no-op when mapping does not exist", () => {
+ mod.setMappings("claude-code", [{ source: "claude-3", target: "anthropic/claude-opus-4" }]);
+ mod.deleteMapping("claude-code", "nonexistent-model");
+
+ const rows = mod.getMappingsForAgent("claude-code");
+ assert.equal(rows.length, 1);
+});
diff --git a/tests/unit/db-agent-bridge-state.test.ts b/tests/unit/db-agent-bridge-state.test.ts
new file mode 100644
index 0000000000..919c17646b
--- /dev/null
+++ b/tests/unit/db-agent-bridge-state.test.ts
@@ -0,0 +1,113 @@
+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-db-agent-bridge-state-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const mod = await import("../../src/lib/db/agentBridgeState.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 (error: any) {
+ if ((error?.code === "EBUSY" || error?.code === "EPERM") && attempt < 9) {
+ await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
+ } else {
+ throw error;
+ }
+ }
+ }
+
+ 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 });
+});
+
+test("migration is idempotent — running getDbInstance twice does not throw", () => {
+ // First init
+ const db1 = core.getDbInstance();
+ assert.ok(db1);
+ core.resetDbInstance();
+
+ // Second init — migrations should skip already-applied files
+ const db2 = core.getDbInstance();
+ assert.ok(db2);
+});
+
+test("getAgentBridgeState returns null for unknown agent", () => {
+ const result = mod.getAgentBridgeState("unknown-agent");
+ assert.equal(result, null);
+});
+
+test("upsertAgentBridgeState creates a new row with defaults", () => {
+ mod.upsertAgentBridgeState({ agent_id: "copilot" });
+ const row = mod.getAgentBridgeState("copilot");
+
+ assert.ok(row);
+ assert.equal(row.agent_id, "copilot");
+ assert.equal(row.dns_enabled, false);
+ assert.equal(row.cert_trusted, false);
+ assert.equal(row.setup_completed, false);
+ assert.equal(row.last_started_at, null);
+ assert.equal(row.last_error, null);
+});
+
+test("upsertAgentBridgeState updates an existing row", () => {
+ mod.upsertAgentBridgeState({ agent_id: "cursor" });
+ mod.upsertAgentBridgeState({ agent_id: "cursor", dns_enabled: true, cert_trusted: true });
+
+ const row = mod.getAgentBridgeState("cursor");
+ assert.ok(row);
+ assert.equal(row.dns_enabled, true);
+ assert.equal(row.cert_trusted, true);
+ assert.equal(row.setup_completed, false);
+});
+
+test("setLastStarted persists timestamp and auto-creates row if missing", () => {
+ const ts = new Date().toISOString();
+ mod.setLastStarted("kiro", ts);
+
+ const row = mod.getAgentBridgeState("kiro");
+ assert.ok(row);
+ assert.equal(row.last_started_at, ts);
+});
+
+test("setLastError persists error string and clears it with null", () => {
+ mod.upsertAgentBridgeState({ agent_id: "codex" });
+ mod.setLastError("codex", "upstream timeout");
+
+ let row = mod.getAgentBridgeState("codex");
+ assert.equal(row?.last_error, "upstream timeout");
+
+ mod.setLastError("codex", null);
+ row = mod.getAgentBridgeState("codex");
+ assert.equal(row?.last_error, null);
+});
+
+test("getAllAgentBridgeStates returns all rows", () => {
+ mod.upsertAgentBridgeState({ agent_id: "antigravity" });
+ mod.upsertAgentBridgeState({ agent_id: "zed" });
+
+ const rows = mod.getAllAgentBridgeStates();
+ assert.ok(rows.length >= 2);
+ const ids = rows.map((r) => r.agent_id);
+ assert.ok(ids.includes("antigravity"));
+ assert.ok(ids.includes("zed"));
+});
diff --git a/tests/unit/db-inspector-custom-hosts.test.ts b/tests/unit/db-inspector-custom-hosts.test.ts
new file mode 100644
index 0000000000..39ad298ae8
--- /dev/null
+++ b/tests/unit/db-inspector-custom-hosts.test.ts
@@ -0,0 +1,141 @@
+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-db-inspector-custom-hosts-")
+);
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const mod = await import("../../src/lib/db/inspectorCustomHosts.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 (error: any) {
+ if ((error?.code === "EBUSY" || error?.code === "EPERM") && attempt < 9) {
+ await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
+ } else {
+ throw error;
+ }
+ }
+ }
+
+ 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 });
+});
+
+test("listCustomHosts returns empty array initially", () => {
+ const rows = mod.listCustomHosts();
+ assert.deepEqual(rows, []);
+});
+
+test("addCustomHost inserts a host with defaults", () => {
+ mod.addCustomHost("api.openai.com");
+
+ const rows = mod.listCustomHosts();
+ assert.equal(rows.length, 1);
+ assert.equal(rows[0].host, "api.openai.com");
+ assert.equal(rows[0].enabled, true);
+ assert.equal(rows[0].kind, "custom");
+ assert.equal(rows[0].label, null);
+ assert.equal(rows[0].last_seen_at, null);
+ assert.ok(rows[0].added_at);
+});
+
+test("addCustomHost respects kind and label parameters", () => {
+ mod.addCustomHost("api.anthropic.com", "llm", "Anthropic API");
+
+ const rows = mod.listCustomHosts();
+ const row = rows.find((r) => r.host === "api.anthropic.com");
+ assert.ok(row);
+ assert.equal(row.kind, "llm");
+ assert.equal(row.label, "Anthropic API");
+});
+
+test("addCustomHost is idempotent — duplicate inserts are ignored", () => {
+ mod.addCustomHost("api.openai.com");
+ mod.addCustomHost("api.openai.com");
+
+ const rows = mod.listCustomHosts();
+ assert.equal(rows.length, 1);
+});
+
+test("toggleCustomHost disables an enabled host", () => {
+ mod.addCustomHost("api.openai.com");
+ mod.toggleCustomHost("api.openai.com", false);
+
+ const rows = mod.listCustomHosts();
+ assert.equal(rows[0].enabled, false);
+});
+
+test("toggleCustomHost re-enables a disabled host", () => {
+ mod.addCustomHost("api.openai.com");
+ mod.toggleCustomHost("api.openai.com", false);
+ mod.toggleCustomHost("api.openai.com", true);
+
+ const rows = mod.listCustomHosts();
+ assert.equal(rows[0].enabled, true);
+});
+
+test("listCustomHosts with enabledOnly=true excludes disabled hosts", () => {
+ mod.addCustomHost("api.openai.com");
+ mod.addCustomHost("api.anthropic.com");
+ mod.toggleCustomHost("api.anthropic.com", false);
+
+ const all = mod.listCustomHosts();
+ const enabledOnly = mod.listCustomHosts({ enabledOnly: true });
+
+ assert.equal(all.length, 2);
+ assert.equal(enabledOnly.length, 1);
+ assert.equal(enabledOnly[0].host, "api.openai.com");
+});
+
+test("removeCustomHost deletes the host", () => {
+ mod.addCustomHost("api.openai.com");
+ mod.addCustomHost("api.anthropic.com");
+
+ mod.removeCustomHost("api.openai.com");
+
+ const rows = mod.listCustomHosts();
+ assert.equal(rows.length, 1);
+ assert.equal(rows[0].host, "api.anthropic.com");
+});
+
+test("removeCustomHost is a no-op for non-existent hosts", () => {
+ mod.addCustomHost("api.openai.com");
+ mod.removeCustomHost("nonexistent.host");
+
+ const rows = mod.listCustomHosts();
+ assert.equal(rows.length, 1);
+});
+
+test("touchLastSeen updates last_seen_at timestamp", () => {
+ mod.addCustomHost("api.openai.com");
+
+ const before = mod.listCustomHosts()[0];
+ assert.equal(before.last_seen_at, null);
+
+ mod.touchLastSeen("api.openai.com");
+
+ const after = mod.listCustomHosts()[0];
+ assert.ok(after.last_seen_at !== null);
+ assert.ok(Date.parse(after.last_seen_at as string) > 0);
+});
diff --git a/tests/unit/db-inspector-sessions.test.ts b/tests/unit/db-inspector-sessions.test.ts
new file mode 100644
index 0000000000..5131a35433
--- /dev/null
+++ b/tests/unit/db-inspector-sessions.test.ts
@@ -0,0 +1,149 @@
+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-db-inspector-sessions-")
+);
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const mod = await import("../../src/lib/db/inspectorSessions.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 (error: any) {
+ if ((error?.code === "EBUSY" || error?.code === "EPERM") && attempt < 9) {
+ await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
+ } else {
+ throw error;
+ }
+ }
+ }
+
+ 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 });
+});
+
+test("createSession returns a uuid and started_at timestamp", () => {
+ const { id, started_at } = mod.createSession();
+
+ assert.match(id, /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+ assert.ok(Date.parse(started_at) > 0);
+});
+
+test("createSession persists name and profile", () => {
+ const { id } = mod.createSession({ name: "My Session", profile: "llm" });
+
+ const row = mod.getSession(id);
+ assert.ok(row);
+ assert.equal(row.name, "My Session");
+ assert.equal(row.profile, "llm");
+ assert.equal(row.ended_at, null);
+ assert.equal(row.request_count, 0);
+});
+
+test("listSessions returns all created sessions", () => {
+ const { id: id1 } = mod.createSession({ name: "First" });
+ const { id: id2 } = mod.createSession({ name: "Second" });
+
+ const sessions = mod.listSessions();
+ assert.ok(sessions.length >= 2);
+
+ const ids = sessions.map((s) => s.id);
+ assert.ok(ids.includes(id1), "First session should be in the list");
+ assert.ok(ids.includes(id2), "Second session should be in the list");
+});
+
+test("appendSessionRequest increments seq atomically and updates request_count", () => {
+ const { id } = mod.createSession();
+
+ mod.appendSessionRequest(id, JSON.stringify({ a: 1 }));
+ mod.appendSessionRequest(id, JSON.stringify({ a: 2 }));
+ mod.appendSessionRequest(id, JSON.stringify({ a: 3 }));
+
+ const session = mod.getSession(id);
+ assert.equal(session?.request_count, 3);
+
+ const requests = mod.getSessionRequests(id);
+ assert.equal(requests.length, 3);
+ assert.equal(requests[0].seq, 1);
+ assert.equal(requests[1].seq, 2);
+ assert.equal(requests[2].seq, 3);
+});
+
+test("getSessionRequests returns payloads in seq order", () => {
+ const { id } = mod.createSession();
+
+ mod.appendSessionRequest(id, "payload-A");
+ mod.appendSessionRequest(id, "payload-B");
+ mod.appendSessionRequest(id, "payload-C");
+
+ const requests = mod.getSessionRequests(id);
+ assert.equal(requests[0].payload, "payload-A");
+ assert.equal(requests[1].payload, "payload-B");
+ assert.equal(requests[2].payload, "payload-C");
+});
+
+test("stopSession sets ended_at timestamp", () => {
+ const { id } = mod.createSession();
+
+ const before = mod.getSession(id);
+ assert.equal(before?.ended_at, null);
+
+ mod.stopSession(id);
+
+ const after = mod.getSession(id);
+ assert.ok(after?.ended_at !== null);
+ assert.ok(Date.parse(after?.ended_at as string) > 0);
+});
+
+test("renameSession updates the name", () => {
+ const { id } = mod.createSession({ name: "Old Name" });
+ mod.renameSession(id, "New Name");
+
+ const row = mod.getSession(id);
+ assert.equal(row?.name, "New Name");
+});
+
+test("deleteSession removes session and cascade-deletes requests", () => {
+ const { id } = mod.createSession();
+ mod.appendSessionRequest(id, "payload-1");
+ mod.appendSessionRequest(id, "payload-2");
+
+ mod.deleteSession(id);
+
+ const session = mod.getSession(id);
+ assert.equal(session, null);
+
+ const requests = mod.getSessionRequests(id);
+ assert.equal(requests.length, 0);
+});
+
+test("getSession returns null for non-existent id", () => {
+ const row = mod.getSession("00000000-0000-4000-8000-000000000000");
+ assert.equal(row, null);
+});
+
+test("getSessionRequests returns empty array for session with no requests", () => {
+ const { id } = mod.createSession();
+ const requests = mod.getSessionRequests(id);
+ assert.deepEqual(requests, []);
+});