import { afterEach, describe, expect, it, vi } from "vitest"; import { createQueryClient } from "../../../src/adapters/query-cache/tanstack-query-cache.ts"; import { createTelemetryPipeline } from "../../../src/platform/telemetry/telemetry-pipeline.ts"; import type { InstalledHttpContract } from "../../../src/contracts/external-contract-runtime.ts"; import { TEST_CREATE_HTTP_CONTRACT } from "../../helpers/external-contract-fixture.ts"; import { jsonRows, networkFailure, testExecutionContext, testExecutor, type Transport, } from "../../helpers/traffic-test-kit.ts"; import { classifyCounterSeries } from "../../../scripts/scale/memory-slope.ts"; import { TEST_QUERY } from "../traffic/synthetic-traffic.ts"; import { recordScaleMetrics } from "../scale-artifact.ts"; const TEST_COMMAND = TEST_CREATE_HTTP_CONTRACT as InstalledHttpContract< unknown, unknown, unknown >; afterEach(() => { vi.useRealTimers(); }); /** * A long-lived scope signal that counts its listeners, standing in for the * session-wide server-state scope every execution subscribes to. */ function countingScope() { const controller = new AbortController(); let listeners = 0; const signal = controller.signal; const add = signal.addEventListener.bind(signal); const remove = signal.removeEventListener.bind(signal); Object.defineProperty(signal, "addEventListener", { value: (...args: Parameters) => { listeners += 1; add(...args); }, }); Object.defineProperty(signal, "removeEventListener", { value: (...args: Parameters) => { listeners -= 1; remove(...args); }, }); let generation = 1; return { scope: () => Object.freeze({ generation, fingerprint: `scope-${generation}`, identities: Object.freeze({}) as never, signal, isCurrent: () => true, }), listeners: () => listeners, nextGeneration() { generation += 1; }, generation: () => generation, }; } /** * Spec §33 / §44. Thousands of login/navigation/query/mutation/logout cycles. * Every long-lived resource must return to (or stabilize at) its post-warm-up * bound rather than grow with the number of cycles. */ describe("long-session logical leak checks", () => { it("returns timers, listeners, leases, buffers and cache entries to a stable bound", async () => { vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] }); const session = countingScope(); let cycle = 0; const transport: Transport = () => (cycle % 7 === 0 ? networkFailure() : Promise.resolve(jsonRows(2))); const executor = testExecutor(transport, { maxRetryAttempts: 1 }); const telemetry = createTelemetryPipeline({ transport: { send: () => {} }, schedule: () => {}, setTimer: () => 0, clearTimer: () => {}, }); const queryClient = createQueryClient(); const series = { timers: [] as number[], listeners: [] as number[], buffered: [] as number[], cache: [] as number[] }; const CYCLES = 3_000; for (cycle = 0; cycle < CYCLES; cycle += 1) { // login: a new session scope generation every 250 cycles if (cycle % 250 === 0) session.nextGeneration(); const execution = testExecutionContext({ maxPhysicalRequests: 3, maxRetries: 1, maxConcurrentRequests: 2, }); const context = { routeId: "TEST_ROUTE", scope: session.scope(), execution }; // navigation + query through the query cache (bounded key cardinality) const queryKey = ["session", session.generation(), cycle % 25]; const query = queryClient.fetchQuery({ queryKey, queryFn: () => executor.execute(TEST_QUERY, { limit: 1 }, context), }); // mutation const mutation = executor.execute(TEST_COMMAND, { name: `c${cycle}` }, { ...context, intent: Object.freeze({ intentId: `intent-${cycle}`, operationId: "TEST_CREATE_ENTITY", canonicalInputIdentity: `input-${cycle}`, idempotencyKey: `key-${cycle.toString().padStart(6, "0")}`, createdAtMonotonicMs: cycle, }), }); const [queryOutcome, mutationOutcome] = await Promise.all([query, mutation]); if (queryOutcome.kind !== "SUCCESS" || mutationOutcome.kind !== "SUCCESS") { await telemetry.emit({ kind: "session.operation.failed", severity: "warning", interactionId: execution.interaction.id, payload: { query: queryOutcome.kind, mutation: mutationOutcome.kind }, }); } // logout: the interaction ends execution.cancellation.cancel(); expect(execution.traffic.concurrency.active).toBe(0); if (cycle % 100 === 99) { await telemetry.flush(); series.timers.push(vi.getTimerCount()); series.listeners.push(session.listeners()); series.buffered.push(telemetry.stats().buffered); series.cache.push(queryClient.getQueryCache().getAll().length); } if (cycle % 250 === 249) { // Scope generation changed: the previous generation's entries are garbage. queryClient.removeQueries({ queryKey: ["session", session.generation()] }); } } await recordScaleMetrics("long-session", { cycles: CYCLES, ...series }); expect(vi.getTimerCount()).toBe(0); expect(session.listeners()).toBe(0); expect(classifyCounterSeries(series.timers, { warmupSamples: 3 })).toBe("stable"); expect(classifyCounterSeries(series.listeners, { warmupSamples: 3 })).toBe("stable"); expect(classifyCounterSeries(series.buffered, { warmupSamples: 3 })).toBe("stable"); expect(Math.max(...series.cache)).toBeLessThanOrEqual(25); expect(Math.max(...series.buffered)).toBeLessThanOrEqual(200); queryClient.clear(); telemetry.dispose(); }, 120_000); });