Standardize jitter implementation with Temporal.Duration

kachick · Sep 11, 2024 · e9ae955 · e9ae955
1 parent 62c63ed
commit e9ae955
Show file tree

Hide file tree

Showing 3 changed files with 98 additions and 29 deletions.
diff --git a/__tests__/wait.test.ts b/__tests__/wait.test.ts
@@ -1,12 +1,6 @@
-import {
-  wait,
-  calcExponentialBackoffAndJitter,
-  MIN_JITTER_MILLISECONDS,
-  MAX_JITTER_MILLISECONDS,
-  getInterval,
-} from '../src/wait.ts';
+import { wait, calcExponentialBackoffAndJitter, MIN_JITTER, MAX_JITTER, getInterval } from '../src/wait.ts';
 import test from 'node:test';
-import assert from 'node:assert';
+import assert, { strictEqual } from 'node:assert';
 import { Temporal } from 'temporal-polyfill';
 
 test('wait 100 ms', async () => {
@@ -26,32 +20,99 @@ test('wait 100 ms', async () => {
 test('interval will be like a cheap exponential backoff', () => {
   const leastInterval = Temporal.Duration.from({ seconds: 100 });
 
-  assert(calcExponentialBackoffAndJitter(leastInterval, 1).total('milliseconds') >= (100000 + MIN_JITTER_MILLISECONDS));
-  assert(calcExponentialBackoffAndJitter(leastInterval, 1).total('milliseconds') < (100000 + MAX_JITTER_MILLISECONDS));
-  assert(calcExponentialBackoffAndJitter(leastInterval, 2).total('milliseconds') >= (200000 + MIN_JITTER_MILLISECONDS));
-  assert(calcExponentialBackoffAndJitter(leastInterval, 2).total('milliseconds') < (200000 + MAX_JITTER_MILLISECONDS));
-  assert(calcExponentialBackoffAndJitter(leastInterval, 3).total('milliseconds') >= (400000 + MIN_JITTER_MILLISECONDS));
-  assert(calcExponentialBackoffAndJitter(leastInterval, 3).total('milliseconds') < (400000 + MAX_JITTER_MILLISECONDS));
-  assert(calcExponentialBackoffAndJitter(leastInterval, 4).total('milliseconds') >= (800000 + MIN_JITTER_MILLISECONDS));
-  assert(calcExponentialBackoffAndJitter(leastInterval, 4).total('milliseconds') < (800000 + MAX_JITTER_MILLISECONDS));
   assert(
-    calcExponentialBackoffAndJitter(leastInterval, 5).total('milliseconds') >= (1600000 + MIN_JITTER_MILLISECONDS),
+    Temporal.Duration.compare(
+      calcExponentialBackoffAndJitter(leastInterval, 1),
+      MIN_JITTER.add({ milliseconds: 100000 }),
+    ) >= 0,
+  );
+  strictEqual(
+    Temporal.Duration.compare(
+      calcExponentialBackoffAndJitter(leastInterval, 1),
+      MAX_JITTER.add({ milliseconds: 100000 }),
+    ),
+    -1,
+  );
+
+  assert(
+    Temporal.Duration.compare(
+      calcExponentialBackoffAndJitter(leastInterval, 2),
+      MIN_JITTER.add({ milliseconds: 200000 }),
+    ) >= 0,
+  );
+  strictEqual(
+    Temporal.Duration.compare(
+      calcExponentialBackoffAndJitter(leastInterval, 2),
+      MAX_JITTER.add({ milliseconds: 200000 }),
+    ),
+    -1,
+  );
+
+  assert(
+    Temporal.Duration.compare(
+      calcExponentialBackoffAndJitter(leastInterval, 3),
+      MIN_JITTER.add({ milliseconds: 400000 }),
+    ) >= 0,
+  );
+  strictEqual(
+    Temporal.Duration.compare(
+      calcExponentialBackoffAndJitter(leastInterval, 3),
+      MAX_JITTER.add({ milliseconds: 400000 }),
+    ),
+    -1,
+  );
+
+  assert(
+    Temporal.Duration.compare(
+      calcExponentialBackoffAndJitter(leastInterval, 4),
+      MIN_JITTER.add({ milliseconds: 800000 }),
+    ) >= 0,
+  );
+  strictEqual(
+    Temporal.Duration.compare(
+      calcExponentialBackoffAndJitter(leastInterval, 4),
+      MAX_JITTER.add({ milliseconds: 800000 }),
+    ),
+    -1,
+  );
+
+  assert(
+    Temporal.Duration.compare(
+      calcExponentialBackoffAndJitter(leastInterval, 5),
+      MIN_JITTER.add({ milliseconds: 1600000 }),
+    ) >= 0,
+  );
+  strictEqual(
+    Temporal.Duration.compare(
+      calcExponentialBackoffAndJitter(leastInterval, 5),
+      MAX_JITTER.add({ milliseconds: 1600000 }),
+    ),
+    -1,
   );
-  assert(calcExponentialBackoffAndJitter(leastInterval, 5).total('milliseconds') < (1600000 + MAX_JITTER_MILLISECONDS));
 });
 
 test('getInterval returns different value with the given method', () => {
   const leastInterval = Temporal.Duration.from({ seconds: 100 });
 
   assert(
-    getInterval('exponential_backoff', leastInterval, 5).total('milliseconds') >= (1600000 + MIN_JITTER_MILLISECONDS),
+    Temporal.Duration.compare(
+      getInterval('exponential_backoff', leastInterval, 5),
+      MIN_JITTER.add({ milliseconds: 1600000 }),
+    ) >= 0,
   );
-  assert(
-    getInterval('exponential_backoff', leastInterval, 5).total('milliseconds') < (1600000 + MAX_JITTER_MILLISECONDS),
+  strictEqual(
+    Temporal.Duration.compare(
+      getInterval('exponential_backoff', leastInterval, 5),
+      MAX_JITTER.add({ milliseconds: 1600000 }),
+    ),
+    -1,
   );
 
-  assert.strictEqual(
-    Temporal.Duration.compare(getInterval('equal_intervals', leastInterval, 5), leastInterval),
+  strictEqual(
+    Temporal.Duration.compare(
+      getInterval('equal_intervals', leastInterval, 5),
+      leastInterval,
+    ),
     0,
   );
 });
diff --git a/dist/index.js b/dist/index.js
@@ -32570,10 +32570,14 @@ function getRandomInt(min, max) {
   const flooredMin = Math.ceil(min);
   return Math.floor(Math.random() * (Math.floor(max) - flooredMin) + flooredMin);
 }
-var MIN_JITTER_MILLISECONDS = 1e3;
-var MAX_JITTER_MILLISECONDS = 7e3;
+var MIN_JITTER = mr.Duration.from({
+  seconds: 1
+});
+var MAX_JITTER = mr.Duration.from({
+  seconds: 7
+});
 function calcExponentialBackoffAndJitter(leastInterval, attempts) {
-  const jitterMilliseconds = getRandomInt(MIN_JITTER_MILLISECONDS, MAX_JITTER_MILLISECONDS);
+  const jitterMilliseconds = getRandomInt(MIN_JITTER.total("milliseconds"), MAX_JITTER.total("milliseconds"));
   return mr.Duration.from({
     milliseconds: leastInterval.total("milliseconds") * 2 ** (attempts - 1) + jitterMilliseconds
   });

diff --git a/src/wait.ts b/src/wait.ts
@@ -15,14 +15,18 @@ function getRandomInt(min: number, max: number) {
   return Math.floor((Math.random() * (Math.floor(max) - flooredMin)) + flooredMin);
 }
 
-export const MIN_JITTER_MILLISECONDS = 1000;
-export const MAX_JITTER_MILLISECONDS = 7000;
+export const MIN_JITTER = Temporal.Duration.from({
+  seconds: 1,
+});
+export const MAX_JITTER = Temporal.Duration.from({
+  seconds: 7,
+});
 
 export function calcExponentialBackoffAndJitter(
   leastInterval: Temporal.Duration,
   attempts: number,
 ): Temporal.Duration {
-  const jitterMilliseconds = getRandomInt(MIN_JITTER_MILLISECONDS, MAX_JITTER_MILLISECONDS);
+  const jitterMilliseconds = getRandomInt(MIN_JITTER.total('milliseconds'), MAX_JITTER.total('milliseconds'));
   return Temporal.Duration.from({
     milliseconds: (leastInterval.total('milliseconds') * (2 ** (attempts - 1))) + jitterMilliseconds,
   });