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/); });