Files
clean-architecture-frontend…/tests/scale/traffic/retry-after-jitter.test.ts
T

74 lines
2.5 KiB
TypeScript

import { describe, expect, it } from "vitest";
import { retryDelayFor } from "../../../src/adapters/http/http-retry-lifecycle.ts";
/** Deterministic per-client PRNG (mulberry32), seeded by client index. */
function seededRandom(seed: number): () => number {
let state = seed >>> 0;
return () => {
state = (state + 0x6d2b79f5) >>> 0;
let value = state;
value = Math.imul(value ^ (value >>> 15), value | 1);
value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
return ((value ^ (value >>> 14)) >>> 0) / 4_294_967_296;
};
}
function calculateRetryDelay(
options: Readonly<{ retryAfterMs: number; jitterSeed: number; attempt: number }>,
): number {
const delay = retryDelayFor(
options.retryAfterMs,
options.attempt - 1,
seededRandom(options.jitterSeed),
);
if (delay === null) throw new Error("Retry-After above the ceiling is not retried");
return delay;
}
describe("Retry-After jitter distribution", () => {
it("spreads retries around Retry-After instead of synchronizing all clients", () => {
const delays = Array.from({ length: 10_000 }, (_, seed) =>
calculateRetryDelay({
retryAfterMs: 3_000,
jitterSeed: seed,
attempt: 1,
}),
);
expect(new Set(delays).size).toBeGreaterThan(100);
expect(Math.max(...delays) - Math.min(...delays)).toBeGreaterThan(500);
});
it("never retries earlier than the server asked", () => {
for (let seed = 0; seed < 1_000; seed += 1) {
expect(
calculateRetryDelay({ retryAfterMs: 1_000, jitterSeed: seed, attempt: 1 }),
).toBeGreaterThanOrEqual(1_000);
}
});
it("keeps the jitter window bounded", () => {
const delays = Array.from({ length: 5_000 }, (_, seed) =>
calculateRetryDelay({ retryAfterMs: 5_000, jitterSeed: seed, attempt: 3 }),
);
expect(Math.max(...delays)).toBeLessThan(5_000 + 2_000);
});
it("spreads a cohort into many small buckets rather than one spike", () => {
const perBucket = new Map<number, number>();
for (let seed = 0; seed < 10_000; seed += 1) {
const bucket = Math.floor(
calculateRetryDelay({ retryAfterMs: 3_000, jitterSeed: seed, attempt: 1 }) / 50,
);
perBucket.set(bucket, (perBucket.get(bucket) ?? 0) + 1);
}
// No 50ms slice receives more than ~10% of the cohort.
expect(Math.max(...perBucket.values())).toBeLessThan(1_000);
});
it("does not retry when Retry-After exceeds the ceiling", () => {
expect(retryDelayFor(10_000, 0, () => 0.5)).toBeNull();
});
});