| 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495 |
- import test from 'node:test';
- import assert from 'node:assert/strict';
- import { abortableDelay, createRequestPacer, parseRetryAfter } from '../src/request-pacing.js';
- test('history jitter stays within bounds and occurs before every request including the first', async () => {
- let now = 1_000_000;
- const waits = [], samples = [0, 0.25, 1];
- const pacer = createRequestPacer({ now: () => now, random: () => samples.shift(),
- sleep: async delay => { waits.push(delay); assert.equal(pacer.status().waiting, true); now += delay; } });
- for (let count = 0; count < 3; count++) assert.equal(await pacer.beforeRequest('https://teams.example'), true);
- assert.deepEqual(waits, [2000, 2750, 5000]);
- assert.equal(pacer.status().waiting, false); assert.equal(pacer.status().waitUntil, null);
- assert.equal(pacer.status().lastDelayMs, 5000);
- });
- test('cancelled jitter ends immediately and does not grant permission for another request', async () => {
- const controller = new AbortController();
- const pacer = createRequestPacer({ sleep: (delay, { signal }) => {
- const wait = abortableDelay(delay, { signal }); controller.abort(); return wait;
- } });
- await assert.rejects(pacer.beforeRequest('https://teams.example', { signal: controller.signal }), { name: 'AbortError' });
- assert.equal(pacer.status().waiting, false);
- await assert.rejects(pacer.beforeRequest('https://teams.example', { signal: controller.signal }), { name: 'AbortError' });
- });
- test('server Retry-After persists by origin and defers without sleeping across rounds and recreated pacers', async () => {
- let now = 1_000_000, waits = 0;
- const saved = new Map();
- const settings = { now: () => now, random: () => 0, sleep: async delay => { waits++; now += delay; },
- loadState: key => saved.get(key), saveState: (key, value) => saved.set(key, value) };
- const pacer = createRequestPacer(settings);
- await pacer.beforeRequest('https://teams.example');
- pacer.recordResponse('https://teams.example', { status: 429, retryAfterMs: 120_000 });
- const restarted = createRequestPacer(settings);
- assert.equal(await restarted.beforeRequest('https://teams.example'), false); assert.equal(waits, 1);
- assert.equal(restarted.status().coolingDownOrigins, 1);
- assert.equal(await restarted.beforeRequest('https://outlook.example'), true); assert.equal(waits, 2);
- now += 120_000;
- assert.equal(await restarted.beforeRequest('https://teams.example'), true); assert.equal(waits, 3);
- restarted.recordResponse('https://teams.example', { status: 200 });
- assert.equal(restarted.status().coolingDownOrigins, 0); assert.equal(saved.get('https://teams.example').failures, 0);
- });
- test('temporary failures use increasing fallback delays and do not shorten a longer server delay', () => {
- let now = 1_000_000;
- const pacer = createRequestPacer({ now: () => now });
- pacer.recordResponse('origin', { status: 503 });
- assert.equal(Date.parse(pacer.status().nextAllowedAt) - now, 30_000);
- now += 30_000;
- pacer.recordResponse('origin', { status: 503 });
- assert.equal(Date.parse(pacer.status().nextAllowedAt) - now, 60_000);
- now += 60_000;
- pacer.recordResponse('origin', { status: 429, retryAfterMs: 2 * 86400_000 });
- assert.equal(Date.parse(pacer.status().nextAllowedAt) - now, 2 * 86400_000);
- });
- test('Retry-After parsing accepts seconds and HTTP dates but exposes no raw header text', () => {
- const now = Date.parse('2026-09-08T00:00:00Z');
- assert.equal(parseRetryAfter('120', now), 120_000);
- assert.equal(parseRetryAfter('Tue, 08 Sep 2026 00:02:00 GMT', now), 120_000);
- assert.equal(parseRetryAfter('Tuesday, 08-Sep-26 00:02:00 GMT', now), 120_000);
- assert.equal(parseRetryAfter('Tue Sep 8 00:02:00 2026', now), 120_000);
- assert.equal(parseRetryAfter('Wednesday, 09-Sep-26 00:02:00 GMT', now), 86400_000 + 120_000);
- assert.equal(parseRetryAfter('Thursday, 10-Sep-26 00:02:00 GMT', now), 2 * 86400_000 + 120_000);
- assert.equal(parseRetryAfter('Saturday, 12-Sep-26 00:02:00 GMT', now), 4 * 86400_000 + 120_000);
- assert.equal(parseRetryAfter('0', now), 0);
- assert.equal(parseRetryAfter('Mon, 07 Sep 2026 00:02:00 GMT', now), 0);
- for (const input of ['private-token', '-1', '1.5', '2027', 'x'.repeat(129)]) {
- if (input === '2027') assert.equal(parseRetryAfter(input, now), 2_027_000);
- else assert.equal(parseRetryAfter(input, now), null);
- }
- });
- test('enormous valid Retry-After values retain a far-future durable cooldown instead of short retry', async () => {
- const now = Date.parse('2026-09-08T00:00:00Z'), saved = new Map();
- for (const value of ['99999999999999999999', '9'.repeat(200)]) {
- const delay = parseRetryAfter(value, now);
- assert.equal(delay, 8_640_000_000_000_000 - now);
- const settings = { now: () => now, loadState: key => saved.get(key), saveState: (key, state) => saved.set(key, state),
- sleep: async () => { throw new Error('Cooldown must not sleep.'); } };
- const pacer = createRequestPacer(settings);
- pacer.recordResponse('origin', { status: 429, retryAfterMs: delay });
- const restarted = createRequestPacer(settings);
- assert.equal(await restarted.beforeRequest('origin'), false);
- assert.equal(Date.parse(restarted.status().nextAllowedAt), 8_640_000_000_000_000);
- }
- });
- test('invalid delay configuration and invalid durable cooldowns fail closed', () => {
- for (const config of [{ minDelayMs: -1 }, { maxDelayMs: 1 }, { minDelayMs: 1.5 }, { maxDelayMs: 300001 }]) {
- assert.throws(() => createRequestPacer(config));
- }
- const pacer = createRequestPacer({ loadState: () => ({ version: 1, failures: 1, notBefore: 'private-secret' }) });
- assert.throws(() => pacer.register('origin'), /Invalid history request pacing state/);
- });
|