import { createContractHttpExecutor } from "../../src/adapters/http/http-execution-v3.ts"; import { createExecutionContext, type ExecutionContext, } from "../../src/platform/execution/execution-context.ts"; /** * Shared kit for traffic-budget integration tests (Phase 2) and the scale / * chaos scenarios (Phase 4). It drives the real V3 executor with an injected * transport so request counts are physical dispatch counts. */ export function scopeSnapshot() { return Object.freeze({ generation: 1, fingerprint: "traffic-scope", identities: Object.freeze({}) as never, signal: new AbortController().signal, isCurrent: () => true, }); } export type ManualClock = Readonly<{ now(): number; advance(ms: number): void; }>; export function manualClock(start = 0): ManualClock { let current = start; return Object.freeze({ now: () => current, advance(ms: number) { current += ms; }, }); } /** A clock that answers the listed readings in order, then keeps the last. */ export function fakeClock(readings: readonly number[]): () => number { let index = 0; return () => { const value = readings[Math.min(index, readings.length - 1)] ?? 0; index += 1; return value; }; } export function testExecutionContext( options: Readonly<{ interactionId?: string; deadlineMs?: number; maxPhysicalRequests?: number; maxRetries?: number; maxConcurrentRequests?: number; maxQueuedRequests?: number; clock?: () => number; signal?: AbortSignal; }> = {}, ): ExecutionContext { return createExecutionContext({ interactionId: options.interactionId ?? "interaction-test", deadlineMs: options.deadlineMs ?? 10_000, traffic: { maxPhysicalRequests: options.maxPhysicalRequests ?? 4, maxRetries: options.maxRetries ?? 2, maxConcurrentRequests: options.maxConcurrentRequests ?? 2, maxQueuedRequests: options.maxQueuedRequests ?? 4, }, ...(options.clock === undefined ? {} : { clock: options.clock }), ...(options.signal === undefined ? {} : { signal: options.signal }), }); } export type Transport = (input: RequestInfo | URL, init?: RequestInit) => Promise; export function testExecutor( transport: Transport, options: Readonly<{ maxRetryAttempts?: number; monotonicNow?: () => number; sleep?: (ms: number, signal: AbortSignal) => Promise; random?: () => number; credentialHeaders?: Readonly>; }> = {}, ) { const headers = options.credentialHeaders ?? {}; return createContractHttpExecutor({ baseUrl: "https://api.test", maxRetryAttempts: options.maxRetryAttempts ?? 2, attachCredentials: () => ({ kind: "READY" as const, headers }), fetcher: transport as typeof fetch, // Backoff is not what these tests measure; resolve it immediately unless a // scenario supplies its own sleep. sleep: options.sleep ?? (async () => {}), random: options.random ?? (() => 0.5), ...(options.monotonicNow === undefined ? {} : { monotonicNow: options.monotonicNow }), }); } export function networkFailure(): Promise { return Promise.reject(new TypeError("network")); } export function jsonRows(count: number): Response { return Response.json( Array.from({ length: count }, (_, index) => ({ id: `entity-${index}`, name: `Entity ${index}`, })), ); } /** * A server-side collection of `totalRows` rows behind a bounded page API: each * request returns at most `limit` rows starting at the numeric `cursor`. The * collection's cardinality is independent of how many rows one page carries. */ export function paginatedCollection(totalRows: number): Transport & { calls: number } { const transport = (async (input: RequestInfo | URL) => { transport.calls += 1; const url = new URL(String(input instanceof Request ? input.url : input)); const limit = Number(url.searchParams.get("limit") ?? "20"); const offset = Number(url.searchParams.get("cursor") ?? "0"); const count = Math.max(0, Math.min(limit, totalRows - offset)); return Response.json( Array.from({ length: count }, (_, index) => ({ id: `entity-${offset + index}`, name: `Entity ${offset + index}`, })), ); }) as unknown as Transport & { calls: number }; transport.calls = 0; return transport; }