request-pacing.test.js 5.6 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495
  1. import test from 'node:test';
  2. import assert from 'node:assert/strict';
  3. import { abortableDelay, createRequestPacer, parseRetryAfter } from '../src/request-pacing.js';
  4. test('history jitter stays within bounds and occurs before every request including the first', async () => {
  5. let now = 1_000_000;
  6. const waits = [], samples = [0, 0.25, 1];
  7. const pacer = createRequestPacer({ now: () => now, random: () => samples.shift(),
  8. sleep: async delay => { waits.push(delay); assert.equal(pacer.status().waiting, true); now += delay; } });
  9. for (let count = 0; count < 3; count++) assert.equal(await pacer.beforeRequest('https://teams.example'), true);
  10. assert.deepEqual(waits, [2000, 2750, 5000]);
  11. assert.equal(pacer.status().waiting, false); assert.equal(pacer.status().waitUntil, null);
  12. assert.equal(pacer.status().lastDelayMs, 5000);
  13. });
  14. test('cancelled jitter ends immediately and does not grant permission for another request', async () => {
  15. const controller = new AbortController();
  16. const pacer = createRequestPacer({ sleep: (delay, { signal }) => {
  17. const wait = abortableDelay(delay, { signal }); controller.abort(); return wait;
  18. } });
  19. await assert.rejects(pacer.beforeRequest('https://teams.example', { signal: controller.signal }), { name: 'AbortError' });
  20. assert.equal(pacer.status().waiting, false);
  21. await assert.rejects(pacer.beforeRequest('https://teams.example', { signal: controller.signal }), { name: 'AbortError' });
  22. });
  23. test('server Retry-After persists by origin and defers without sleeping across rounds and recreated pacers', async () => {
  24. let now = 1_000_000, waits = 0;
  25. const saved = new Map();
  26. const settings = { now: () => now, random: () => 0, sleep: async delay => { waits++; now += delay; },
  27. loadState: key => saved.get(key), saveState: (key, value) => saved.set(key, value) };
  28. const pacer = createRequestPacer(settings);
  29. await pacer.beforeRequest('https://teams.example');
  30. pacer.recordResponse('https://teams.example', { status: 429, retryAfterMs: 120_000 });
  31. const restarted = createRequestPacer(settings);
  32. assert.equal(await restarted.beforeRequest('https://teams.example'), false); assert.equal(waits, 1);
  33. assert.equal(restarted.status().coolingDownOrigins, 1);
  34. assert.equal(await restarted.beforeRequest('https://outlook.example'), true); assert.equal(waits, 2);
  35. now += 120_000;
  36. assert.equal(await restarted.beforeRequest('https://teams.example'), true); assert.equal(waits, 3);
  37. restarted.recordResponse('https://teams.example', { status: 200 });
  38. assert.equal(restarted.status().coolingDownOrigins, 0); assert.equal(saved.get('https://teams.example').failures, 0);
  39. });
  40. test('temporary failures use increasing fallback delays and do not shorten a longer server delay', () => {
  41. let now = 1_000_000;
  42. const pacer = createRequestPacer({ now: () => now });
  43. pacer.recordResponse('origin', { status: 503 });
  44. assert.equal(Date.parse(pacer.status().nextAllowedAt) - now, 30_000);
  45. now += 30_000;
  46. pacer.recordResponse('origin', { status: 503 });
  47. assert.equal(Date.parse(pacer.status().nextAllowedAt) - now, 60_000);
  48. now += 60_000;
  49. pacer.recordResponse('origin', { status: 429, retryAfterMs: 2 * 86400_000 });
  50. assert.equal(Date.parse(pacer.status().nextAllowedAt) - now, 2 * 86400_000);
  51. });
  52. test('Retry-After parsing accepts seconds and HTTP dates but exposes no raw header text', () => {
  53. const now = Date.parse('2026-09-08T00:00:00Z');
  54. assert.equal(parseRetryAfter('120', now), 120_000);
  55. assert.equal(parseRetryAfter('Tue, 08 Sep 2026 00:02:00 GMT', now), 120_000);
  56. assert.equal(parseRetryAfter('Tuesday, 08-Sep-26 00:02:00 GMT', now), 120_000);
  57. assert.equal(parseRetryAfter('Tue Sep 8 00:02:00 2026', now), 120_000);
  58. assert.equal(parseRetryAfter('Wednesday, 09-Sep-26 00:02:00 GMT', now), 86400_000 + 120_000);
  59. assert.equal(parseRetryAfter('Thursday, 10-Sep-26 00:02:00 GMT', now), 2 * 86400_000 + 120_000);
  60. assert.equal(parseRetryAfter('Saturday, 12-Sep-26 00:02:00 GMT', now), 4 * 86400_000 + 120_000);
  61. assert.equal(parseRetryAfter('0', now), 0);
  62. assert.equal(parseRetryAfter('Mon, 07 Sep 2026 00:02:00 GMT', now), 0);
  63. for (const input of ['private-token', '-1', '1.5', '2027', 'x'.repeat(129)]) {
  64. if (input === '2027') assert.equal(parseRetryAfter(input, now), 2_027_000);
  65. else assert.equal(parseRetryAfter(input, now), null);
  66. }
  67. });
  68. test('enormous valid Retry-After values retain a far-future durable cooldown instead of short retry', async () => {
  69. const now = Date.parse('2026-09-08T00:00:00Z'), saved = new Map();
  70. for (const value of ['99999999999999999999', '9'.repeat(200)]) {
  71. const delay = parseRetryAfter(value, now);
  72. assert.equal(delay, 8_640_000_000_000_000 - now);
  73. const settings = { now: () => now, loadState: key => saved.get(key), saveState: (key, state) => saved.set(key, state),
  74. sleep: async () => { throw new Error('Cooldown must not sleep.'); } };
  75. const pacer = createRequestPacer(settings);
  76. pacer.recordResponse('origin', { status: 429, retryAfterMs: delay });
  77. const restarted = createRequestPacer(settings);
  78. assert.equal(await restarted.beforeRequest('origin'), false);
  79. assert.equal(Date.parse(restarted.status().nextAllowedAt), 8_640_000_000_000_000);
  80. }
  81. });
  82. test('invalid delay configuration and invalid durable cooldowns fail closed', () => {
  83. for (const config of [{ minDelayMs: -1 }, { maxDelayMs: 1 }, { minDelayMs: 1.5 }, { maxDelayMs: 300001 }]) {
  84. assert.throws(() => createRequestPacer(config));
  85. }
  86. const pacer = createRequestPacer({ loadState: () => ({ version: 1, failures: 1, notBefore: 'private-secret' }) });
  87. assert.throws(() => pacer.register('origin'), /Invalid history request pacing state/);
  88. });