Files
clean-architecture-frontend…/tests/helpers/traffic-test-kit.ts
T

137 lines
4.3 KiB
TypeScript

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<Response>;
export function testExecutor(
transport: Transport,
options: Readonly<{
maxRetryAttempts?: number;
monotonicNow?: () => number;
sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
random?: () => number;
credentialHeaders?: Readonly<Record<string, string>>;
}> = {},
) {
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<Response> {
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;
}