137 lines
4.3 KiB
TypeScript
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;
|
|
}
|