import { describe, expect, test } from "vitest"; import { createApiSessionStore } from "./session-store.js"; const START = new Date("2026-03-01T10:00:00.000Z"); function createDeterministicStore(ids: string[] = ["session-1", "session-2", "session-3"]) { let nowMs = START.getTime(); let idIndex = 0; return { store: createApiSessionStore({ now: () => new Date(nowMs), generateSessionId: () => ids[idIndex++] ?? `session-${idIndex}`, }), advance(ms: number) { nowMs += ms; }, }; } describe("createApiSessionStore", () => { test("creates active sessions with non-secret metadata and supports active lookup", () => { const { store } = createDeterministicStore(); const session = store.createSession("user-1"); expect(session).toEqual({ sessionId: "session-1", userId: "user-1", createdAt: START, revokedAt: undefined, revokeReason: undefined, }); expect(store.getActiveSession("session-1")).toEqual(session); expect(JSON.stringify(session)).not.toContain("jwt"); expect(JSON.stringify(session)).not.toContain("cookie"); expect(JSON.stringify(session)).not.toContain("token"); }); test("returns cloned records so callers cannot mutate stored state", () => { const { store } = createDeterministicStore(); const session = store.createSession("user-1"); session.createdAt.setUTCFullYear(2000); session.userId = "changed"; expect(store.getSession("session-1")).toMatchObject({ sessionId: "session-1", userId: "user-1", createdAt: START, }); }); test("revoke is idempotent and unknown revocation is a safe no-op", () => { const { store, advance } = createDeterministicStore(); store.createSession("user-1"); advance(1_000); const revoked = store.revokeSession("session-1", "logout"); advance(1_000); const revokedAgain = store.revokeSession("session-1", "test"); expect(store.revokeSession("missing", "logout")).toBeUndefined(); expect(revoked).toMatchObject({ sessionId: "session-1", revokedAt: new Date(START.getTime() + 1_000), revokeReason: "logout", }); expect(revokedAgain).toEqual(revoked); expect(store.getActiveSession("session-1")).toBeUndefined(); }); test("rotate revokes the old session and activates the replacement", () => { const { store, advance } = createDeterministicStore(); store.createSession("user-1"); advance(5_000); const result = store.rotateSession("session-1", "refresh"); expect(result).toEqual({ rotated: true, previous: { sessionId: "session-1", userId: "user-1", createdAt: START, revokedAt: new Date(START.getTime() + 5_000), revokeReason: "refresh", }, session: { sessionId: "session-2", userId: "user-1", createdAt: new Date(START.getTime() + 5_000), revokedAt: undefined, revokeReason: undefined, }, }); expect(store.getActiveSession("session-1")).toBeUndefined(); expect(result.rotated).toBe(true); if (!result.rotated) { throw new Error("Expected session rotation to succeed"); } expect(store.getActiveSession("session-2")).toEqual(result.session); }); test("unknown and revoked sessions cannot rotate", () => { const { store } = createDeterministicStore(); store.createSession("user-1"); store.revokeSession("session-1", "logout"); expect(store.rotateSession("missing")).toEqual({ rotated: false, reason: "unknown" }); expect(store.rotateSession("session-1")).toEqual({ rotated: false, reason: "revoked", previous: store.getSession("session-1"), }); }); test("happy path: createSession inserts on a single try without a retry loop", () => { const ids: string[] = []; const { store } = createDeterministicStore(["session-1"]); // Wrap generateSessionId via a fresh store-spy: easier to assert call count // through the public surface by tracking ids generated above. const session = store.createSession("user-1"); ids.push(session.sessionId); expect(ids).toEqual(["session-1"]); expect(store.getActiveSession("session-1")).toMatchObject({ userId: "user-1" }); }); test("uuid collision is treated as a systemic error and throws (no retry loop)", () => { // Force the id generator to return the same value twice; the legacy // implementation looped to a fresh id, masking the underlying entropy bug. const { store } = createDeterministicStore(["session-1", "session-1"]); store.createSession("user-1"); expect(() => store.createSession("user-2")).toThrow(/UUID collision/); // Original session must remain untouched. expect(store.getActiveSession("session-1")).toMatchObject({ userId: "user-1" }); }); test("reset clears all sessions and isolates store state", () => { const { store } = createDeterministicStore(); store.createSession("user-1"); store.createSession("user-2"); store.reset(); expect(store.getSession("session-1")).toBeUndefined(); expect(store.getActiveSession("session-2")).toBeUndefined(); expect(store.rotateSession("session-1")).toEqual({ rotated: false, reason: "unknown" }); }); });