mirror of
https://github.com/diegosouzapw/OmniRoute.git
synced 2026-08-26 00:52:18 +03:00
feat(dashboard): surface exclusive managed leases in Sessions view (#11389)
Merged into release/v3.8.51 via batch validation: exclusive-session-observability unit+UI suites green on the combined tree, static gates green. Nice additive observability layer over the #10362 lease backend — thanks @KaspaPulse!
This commit is contained in:
KaspaPulse
332
tests/unit/exclusive-session-observability.test.ts
Normal file
332
tests/unit/exclusive-session-observability.test.ts
Normal file
@@ -0,0 +1,332 @@
|
||||
import assert from "node:assert/strict";
|
||||
import fs from "node:fs";
|
||||
import os from "node:os";
|
||||
import path from "node:path";
|
||||
import test from "node:test";
|
||||
|
||||
import {
|
||||
buildExclusiveDashboardSessions,
|
||||
mergeDashboardSessions,
|
||||
} from "../../src/lib/sessionObservability.ts";
|
||||
|
||||
const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-session-observability-"));
|
||||
process.env.DATA_DIR = TEST_DATA_DIR;
|
||||
process.env.DISABLE_SQLITE_AUTO_BACKUP = "true";
|
||||
process.env.API_KEY_SECRET = "ab".repeat(32);
|
||||
|
||||
const core = await import("../../src/lib/db/core.ts");
|
||||
const apiKeys = await import("../../src/lib/db/apiKeys.ts");
|
||||
const leases = await import("../../src/lib/db/exclusiveConnectionLeases.ts");
|
||||
const providers = await import("../../src/lib/db/providers.ts");
|
||||
const sessionManager = await import("../../open-sse/services/sessionManager.ts");
|
||||
const usageHistory = await import("../../src/lib/usage/usageHistory.ts");
|
||||
const sessionsRoute = await import("../../src/app/api/sessions/route.ts");
|
||||
|
||||
const OWNER_A = "vlo_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
|
||||
const OWNER_B = "vlo_BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB";
|
||||
const BASE_TIME = Date.parse("2026-08-24T12:00:00.000Z");
|
||||
|
||||
function at(offsetMs: number): string {
|
||||
return new Date(BASE_TIME + offsetMs).toISOString();
|
||||
}
|
||||
|
||||
function projectOfficialOccupancy(connectionIds: string[], now: string) {
|
||||
const occupancy = leases.getExclusiveLeaseOccupancy(connectionIds, now);
|
||||
return buildExclusiveDashboardSessions(new Set(occupancy.keys()), {}, []);
|
||||
}
|
||||
|
||||
test.afterEach(() => {
|
||||
sessionManager.clearSessions();
|
||||
usageHistory.clearPendingRequests();
|
||||
});
|
||||
|
||||
test.after(() => {
|
||||
core.resetDbInstance();
|
||||
fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
test("projects idle and active leases, distinct connections, legacy rows, and de-duplication", () => {
|
||||
const leaseRows = buildExclusiveDashboardSessions(
|
||||
new Set(["conn-idle", "conn-active"]),
|
||||
{ "conn-active": { "gpt-5.6-sol (codex)": 2 }, "conn-idle": { ignored: 0 } },
|
||||
[
|
||||
{
|
||||
sessionId: "legacy-duplicate-a",
|
||||
ageMs: 10_000,
|
||||
requestCount: 2,
|
||||
connectionId: "conn-active",
|
||||
},
|
||||
{
|
||||
sessionId: "legacy-duplicate-b",
|
||||
ageMs: 5_000,
|
||||
requestCount: 3,
|
||||
connectionId: "conn-active",
|
||||
},
|
||||
],
|
||||
new Map([
|
||||
["conn-active", "Managed Active"],
|
||||
["conn-idle", "Managed Idle"],
|
||||
])
|
||||
);
|
||||
|
||||
assert.equal(leaseRows.length, 2);
|
||||
assert.deepEqual(
|
||||
leaseRows.map((row) => [row.connectionId, row.active, row.requestCount]),
|
||||
[
|
||||
["conn-active", true, 5],
|
||||
["conn-idle", false, 0],
|
||||
]
|
||||
);
|
||||
assert.equal(leaseRows[0].connectionName, "Managed Active");
|
||||
|
||||
const displayed = mergeDashboardSessions(leaseRows, [
|
||||
{
|
||||
sessionId: "legacy-duplicate-a",
|
||||
ageMs: 10_000,
|
||||
requestCount: 2,
|
||||
connectionId: "conn-active",
|
||||
},
|
||||
{
|
||||
sessionId: "legacy-unmanaged",
|
||||
ageMs: 2_000,
|
||||
requestCount: 1,
|
||||
connectionId: "conn-unmanaged",
|
||||
},
|
||||
{
|
||||
sessionId: "legacy-unbound",
|
||||
ageMs: 1_000,
|
||||
requestCount: 1,
|
||||
connectionId: null,
|
||||
},
|
||||
]);
|
||||
|
||||
assert.deepEqual(
|
||||
displayed.map((row) => row.sessionId),
|
||||
["lease:conn-active", "lease:conn-idle", "legacy-unmanaged", "legacy-unbound"]
|
||||
);
|
||||
});
|
||||
|
||||
test("lease projection is a minimum privacy-safe observability payload", () => {
|
||||
const secretOwnerHash = "c".repeat(64);
|
||||
const rows = buildExclusiveDashboardSessions(
|
||||
new Set(["conn-private"]),
|
||||
{},
|
||||
[],
|
||||
new Map([["conn-private", "Private account"]])
|
||||
);
|
||||
const payload = JSON.stringify(rows);
|
||||
|
||||
assert.deepEqual(Object.keys(rows[0]).sort(), [
|
||||
"active",
|
||||
"ageMs",
|
||||
"connectionId",
|
||||
"connectionName",
|
||||
"leaseBacked",
|
||||
"requestCount",
|
||||
"sessionId",
|
||||
]);
|
||||
for (const forbidden of [
|
||||
secretOwnerHash,
|
||||
"leaseOwnerHash",
|
||||
"lease_owner_hash",
|
||||
"generation",
|
||||
"apiKeyId",
|
||||
"leaseOwnerId",
|
||||
"expiresAt",
|
||||
"IDLE",
|
||||
]) {
|
||||
assert.equal(payload.includes(forbidden), false, `payload must not contain ${forbidden}`);
|
||||
}
|
||||
});
|
||||
|
||||
test("official SQLite lease lifecycle remains visible through idle renew, release, and expiry", async () => {
|
||||
const connectionA = "11111111-1111-4111-8111-111111111111";
|
||||
const connectionB = "22222222-2222-4222-8222-222222222222";
|
||||
const managedKey = await apiKeys.createApiKey(
|
||||
"Lifecycle managed key",
|
||||
"0123456789abcdef",
|
||||
["lease:exclusive"],
|
||||
{ allowedConnections: [connectionA, connectionB] }
|
||||
);
|
||||
const managed = await apiKeys.getExclusiveLeaseConnectionIds();
|
||||
assert.equal(managed.has(connectionA), true);
|
||||
assert.equal(managed.has(connectionB), true);
|
||||
|
||||
const acquired = leases.acquireExclusiveConnectionLease({
|
||||
leaseOwnerId: OWNER_A,
|
||||
apiKeyId: managedKey.id,
|
||||
provider: "codex",
|
||||
connectionId: connectionA,
|
||||
now: at(0),
|
||||
ttlMs: 120_000,
|
||||
});
|
||||
assert.equal(acquired.kind, "ACQUIRED");
|
||||
if (acquired.kind !== "ACQUIRED") return;
|
||||
assert.equal(projectOfficialOccupancy([connectionA], at(30_000)).length, 1);
|
||||
assert.equal(projectOfficialOccupancy([connectionA], at(30_000))[0].active, false);
|
||||
|
||||
const renewed = leases.renewExclusiveConnectionLease({
|
||||
leaseOwnerId: OWNER_A,
|
||||
generation: acquired.lease.generation,
|
||||
apiKeyId: managedKey.id,
|
||||
now: at(60_000),
|
||||
ttlMs: 120_000,
|
||||
});
|
||||
assert.equal(renewed.kind, "RENEWED");
|
||||
if (renewed.kind !== "RENEWED") return;
|
||||
assert.equal(renewed.lease.generation, acquired.lease.generation);
|
||||
assert.equal(projectOfficialOccupancy([connectionA], at(150_000)).length, 1);
|
||||
assert.equal(
|
||||
leases.assertExclusiveConnectionLeaseFence({
|
||||
leaseOwnerId: OWNER_A,
|
||||
generation: acquired.lease.generation,
|
||||
apiKeyId: managedKey.id,
|
||||
connectionId: connectionA,
|
||||
now: at(150_000),
|
||||
}).kind,
|
||||
"VALID"
|
||||
);
|
||||
assert.equal(
|
||||
leases.releaseExclusiveConnectionLease({
|
||||
leaseOwnerId: OWNER_A,
|
||||
generation: acquired.lease.generation + 1,
|
||||
apiKeyId: managedKey.id,
|
||||
now: at(151_000),
|
||||
}).kind,
|
||||
"STALE"
|
||||
);
|
||||
assert.equal(projectOfficialOccupancy([connectionA], at(152_000)).length, 1);
|
||||
|
||||
assert.equal(
|
||||
leases.releaseExclusiveConnectionLease({
|
||||
leaseOwnerId: OWNER_A,
|
||||
generation: acquired.lease.generation,
|
||||
apiKeyId: managedKey.id,
|
||||
now: at(153_000),
|
||||
}).kind,
|
||||
"RELEASED"
|
||||
);
|
||||
assert.equal(projectOfficialOccupancy([connectionA], at(154_000)).length, 0);
|
||||
|
||||
const expiring = leases.acquireExclusiveConnectionLease({
|
||||
leaseOwnerId: OWNER_B,
|
||||
apiKeyId: managedKey.id,
|
||||
provider: "codex",
|
||||
connectionId: connectionB,
|
||||
now: at(200_000),
|
||||
ttlMs: 1_000,
|
||||
});
|
||||
assert.equal(expiring.kind, "ACQUIRED");
|
||||
if (expiring.kind !== "ACQUIRED") return;
|
||||
assert.equal(projectOfficialOccupancy([connectionB], at(200_500)).length, 1);
|
||||
assert.equal(leases.reconcileExpiredExclusiveConnectionLeases(at(202_000)), 1);
|
||||
assert.equal(projectOfficialOccupancy([connectionB], at(202_000)).length, 0);
|
||||
|
||||
const reacquired = leases.acquireExclusiveConnectionLease({
|
||||
leaseOwnerId: OWNER_B,
|
||||
apiKeyId: managedKey.id,
|
||||
provider: "codex",
|
||||
connectionId: connectionB,
|
||||
now: at(203_000),
|
||||
});
|
||||
assert.equal(reacquired.kind, "ACQUIRED");
|
||||
if (reacquired.kind !== "ACQUIRED") return;
|
||||
assert.equal(reacquired.lease.generation, expiring.lease.generation + 1);
|
||||
assert.equal(
|
||||
leases.assertExclusiveConnectionLeaseFence({
|
||||
leaseOwnerId: OWNER_B,
|
||||
generation: expiring.lease.generation,
|
||||
apiKeyId: managedKey.id,
|
||||
connectionId: connectionB,
|
||||
now: at(204_000),
|
||||
}).kind,
|
||||
"STALE"
|
||||
);
|
||||
assert.equal(
|
||||
leases.releaseExclusiveConnectionLease({
|
||||
leaseOwnerId: OWNER_B,
|
||||
generation: reacquired.lease.generation,
|
||||
apiKeyId: managedKey.id,
|
||||
now: at(205_000),
|
||||
}).kind,
|
||||
"RELEASED"
|
||||
);
|
||||
});
|
||||
|
||||
test("sessions API keeps legacy fields additive and decorates only in-flight leased work", async () => {
|
||||
const connection = await providers.createProviderConnection({
|
||||
provider: "codex",
|
||||
authType: "oauth",
|
||||
name: "Friendly Lease Account",
|
||||
accessToken: "synthetic-local-token",
|
||||
});
|
||||
const managedKey = await apiKeys.createApiKey(
|
||||
"Route managed key",
|
||||
"fedcba9876543210",
|
||||
["lease:exclusive"],
|
||||
{ allowedConnections: [connection.id] }
|
||||
);
|
||||
const acquired = leases.acquireExclusiveConnectionLease({
|
||||
leaseOwnerId: "vlo_CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
|
||||
apiKeyId: managedKey.id,
|
||||
provider: "codex",
|
||||
connectionId: connection.id,
|
||||
});
|
||||
assert.equal(acquired.kind, "ACQUIRED");
|
||||
if (acquired.kind !== "ACQUIRED") return;
|
||||
|
||||
sessionManager.touchSession("legacy-unmanaged", "legacy-connection");
|
||||
const idleResponse = await sessionsRoute.GET();
|
||||
const idleBody = (await idleResponse.json()) as Record<string, unknown>;
|
||||
assert.equal(idleResponse.status, 200);
|
||||
assert.equal(idleBody.count, 1);
|
||||
assert.equal(Array.isArray(idleBody.sessions), true);
|
||||
assert.equal(
|
||||
(idleBody.sessions as Array<{ sessionId: string }>)[0].sessionId,
|
||||
"legacy-unmanaged"
|
||||
);
|
||||
assert.deepEqual(idleBody.byApiKey, {});
|
||||
const idleLease = (idleBody.exclusiveSessions as Array<Record<string, unknown>>)[0];
|
||||
assert.equal(idleLease.connectionId, connection.id);
|
||||
assert.equal(idleLease.connectionName, "Friendly Lease Account");
|
||||
assert.equal(idleLease.active, false);
|
||||
for (const forbidden of ["leaseOwnerHash", "lease_owner_hash", "generation", "apiKeyId"]) {
|
||||
assert.equal(JSON.stringify(idleBody).includes(forbidden), false);
|
||||
}
|
||||
|
||||
usageHistory.trackPendingRequest("gpt-5.6-sol", "codex", connection.id, true);
|
||||
const activeBody = (await (await sessionsRoute.GET()).json()) as {
|
||||
exclusiveSessions: Array<{ active: boolean }>;
|
||||
};
|
||||
assert.equal(activeBody.exclusiveSessions[0].active, true);
|
||||
usageHistory.trackPendingRequest("gpt-5.6-sol", "codex", connection.id, false);
|
||||
|
||||
assert.equal(
|
||||
leases.releaseExclusiveConnectionLease({
|
||||
leaseOwnerId: "vlo_CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
|
||||
generation: acquired.lease.generation,
|
||||
apiKeyId: managedKey.id,
|
||||
}).kind,
|
||||
"RELEASED"
|
||||
);
|
||||
const releasedBody = (await (await sessionsRoute.GET()).json()) as {
|
||||
count: number;
|
||||
sessions: Array<{ sessionId: string }>;
|
||||
exclusiveSessions: unknown[];
|
||||
};
|
||||
assert.equal(releasedBody.count, 1);
|
||||
assert.equal(releasedBody.sessions[0].sessionId, "legacy-unmanaged");
|
||||
assert.deepEqual(releasedBody.exclusiveSessions, []);
|
||||
});
|
||||
|
||||
test("sessions route keeps raw lease SQL out of the API and sanitizes failures", () => {
|
||||
const route = fs.readFileSync(
|
||||
new URL("../../src/app/api/sessions/route.ts", import.meta.url),
|
||||
"utf8"
|
||||
);
|
||||
assert.match(route, /getExclusiveLeaseConnectionIds/);
|
||||
assert.match(route, /getExclusiveLeaseOccupancy/);
|
||||
assert.match(route, /getPendingRequests/);
|
||||
assert.match(route, /sanitizeErrorMessage\(error\)/);
|
||||
assert.doesNotMatch(route, /SELECT\s|exclusive_connection_leases/i);
|
||||
});
|
||||
139
tests/unit/ui/exclusive-session-observability-ui.test.tsx
Normal file
139
tests/unit/ui/exclusive-session-observability-ui.test.tsx
Normal file
@@ -0,0 +1,139 @@
|
||||
// @vitest-environment jsdom
|
||||
|
||||
import React, { act } from "react";
|
||||
import { createRoot } from "react-dom/client";
|
||||
import { afterEach, beforeEach, expect, it, vi } from "vitest";
|
||||
|
||||
vi.mock("next-intl", () => ({
|
||||
useTranslations: (namespace: string) => (key: string) => {
|
||||
if (namespace === "common" && key === "active") return "Localized active";
|
||||
if (namespace === "usage" && key === "noSessions") return "Localized empty state";
|
||||
return key;
|
||||
},
|
||||
}));
|
||||
|
||||
vi.mock("@/shared/components", () => ({
|
||||
Card: ({ children }: { children: React.ReactNode }) => <div data-testid="card">{children}</div>,
|
||||
}));
|
||||
|
||||
const { default: SessionsTab } =
|
||||
await import("../../../src/app/(dashboard)/dashboard/usage/components/SessionsTab");
|
||||
|
||||
let container: HTMLDivElement;
|
||||
let root: ReturnType<typeof createRoot>;
|
||||
|
||||
beforeEach(() => {
|
||||
(
|
||||
globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }
|
||||
).IS_REACT_ACT_ENVIRONMENT = true;
|
||||
container = document.createElement("div");
|
||||
document.body.appendChild(container);
|
||||
root = createRoot(container);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
act(() => root.unmount());
|
||||
container.remove();
|
||||
vi.unstubAllGlobals();
|
||||
vi.clearAllMocks();
|
||||
});
|
||||
|
||||
async function renderPayload(payload: Record<string, unknown>): Promise<void> {
|
||||
vi.stubGlobal(
|
||||
"fetch",
|
||||
vi.fn(async () => ({
|
||||
ok: true,
|
||||
json: async () => payload,
|
||||
}))
|
||||
);
|
||||
|
||||
await act(async () => {
|
||||
root.render(<SessionsTab />);
|
||||
await Promise.resolve();
|
||||
await Promise.resolve();
|
||||
});
|
||||
}
|
||||
|
||||
it("keeps idle leases visible, de-duplicates legacy rows, and localizes only active work", async () => {
|
||||
await renderPayload({
|
||||
count: 2,
|
||||
sessions: [
|
||||
{
|
||||
sessionId: "legacy-active",
|
||||
ageMs: 1_000,
|
||||
requestCount: 4,
|
||||
connectionId: "conn-active",
|
||||
},
|
||||
{
|
||||
sessionId: "legacy-unmanaged",
|
||||
ageMs: 2_000,
|
||||
requestCount: 1,
|
||||
connectionId: "conn-unmanaged",
|
||||
},
|
||||
],
|
||||
exclusiveSessions: [
|
||||
{
|
||||
sessionId: "lease:conn-active",
|
||||
ageMs: null,
|
||||
requestCount: 4,
|
||||
connectionId: "conn-active",
|
||||
connectionName: "Friendly active account",
|
||||
leaseBacked: true,
|
||||
active: true,
|
||||
},
|
||||
{
|
||||
sessionId: "lease:conn-idle",
|
||||
ageMs: null,
|
||||
requestCount: 0,
|
||||
connectionId: "conn-idle",
|
||||
connectionName: "Friendly idle account",
|
||||
leaseBacked: true,
|
||||
active: false,
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
expect(container.querySelector("[title='lease:conn-active']")).not.toBeNull();
|
||||
expect(container.querySelector("[title='lease:conn-idle']")).not.toBeNull();
|
||||
expect(container.querySelector("[title='legacy-unmanaged']")).not.toBeNull();
|
||||
expect(container.querySelector("[title='legacy-active']")).toBeNull();
|
||||
expect(container.textContent).toContain("Friendly active account");
|
||||
expect(container.textContent).toContain("Friendly idle account");
|
||||
|
||||
const activeLabels = Array.from(container.querySelectorAll("span")).filter(
|
||||
(node) => node.textContent === "Localized active"
|
||||
);
|
||||
expect(activeLabels).toHaveLength(1);
|
||||
const idleRow = container.querySelector("[title='lease:conn-idle']")?.closest("tr");
|
||||
expect(idleRow?.textContent).not.toContain("Localized active");
|
||||
expect(container.textContent).not.toContain("IDLE");
|
||||
|
||||
expect(container.querySelector("[data-testid='session-count']")?.textContent).toBe("3");
|
||||
});
|
||||
|
||||
it("preserves a legacy-only response when additive lease fields are absent", async () => {
|
||||
await renderPayload({
|
||||
count: 1,
|
||||
sessions: [
|
||||
{
|
||||
sessionId: "legacy-only",
|
||||
ageMs: 1_000,
|
||||
requestCount: 1,
|
||||
connectionId: null,
|
||||
},
|
||||
],
|
||||
byApiKey: {},
|
||||
});
|
||||
|
||||
expect(container.querySelector("[title='legacy-only']")).not.toBeNull();
|
||||
expect(container.textContent).not.toContain("Localized empty state");
|
||||
expect(container.querySelector("[data-testid='session-count']")?.textContent).toBe("1");
|
||||
});
|
||||
|
||||
it("keeps the localized empty state and zero count", async () => {
|
||||
await renderPayload({ count: 0, sessions: [], byApiKey: {} });
|
||||
|
||||
expect(container.textContent).toContain("Localized empty state");
|
||||
expect(container.querySelector("tbody")).toBeNull();
|
||||
expect(container.querySelector("[data-testid='session-count']")?.textContent).toBe("0");
|
||||
});
|
||||
Reference in New Issue
Block a user