595 lines
24 KiB
TypeScript
595 lines
24 KiB
TypeScript
import { expect, test, vi } from 'vitest';
|
|
import { ExponentialBackoff } from '../../src/utils/exponential-backoff.js';
|
|
|
|
/**
|
|
* A valid options object that satisfies {@link ExponentialBackoff.validateOptions}.
|
|
*/
|
|
const validExponentialBackoffOptions = {
|
|
maxDelay: 10_000,
|
|
maxAttempts: 10,
|
|
baseDelay: 1_000,
|
|
growthRate: 2,
|
|
jitter: 0.1,
|
|
};
|
|
|
|
/**
|
|
* Tests that the static {@link ExponentialBackoff.run} helper creates a throwaway instance
|
|
* with library defaults (including the default 1000ms base delay) when no options are passed.
|
|
*/
|
|
const testExponentialBackoffRunUsesDefaultOptions = async (): Promise<void> => {
|
|
// Fake timers let us advance time without waiting real seconds between retries.
|
|
vi.useFakeTimers();
|
|
// Pin Math.random to 0 so jitter does not reduce the default delay.
|
|
vi.spyOn(Math, 'random').mockReturnValue(0);
|
|
|
|
try {
|
|
// The wrapped function fails on its first invocation and succeeds on the second.
|
|
// That forces ExponentialBackoff.run down the retry path using default options.
|
|
const rejectThenResolveFn = vi.fn().mockRejectedValueOnce(new Error('retry me'))
|
|
.mockResolvedValueOnce('static-result');
|
|
|
|
// Call the static helper with no onError and no options — defaults apply entirely.
|
|
const promise = ExponentialBackoff.run(rejectThenResolveFn);
|
|
|
|
// Yield one microtask so the first (immediate) attempt completes and schedules the retry timer.
|
|
await Promise.resolve();
|
|
expect(rejectThenResolveFn).toHaveBeenCalledTimes(1);
|
|
|
|
// Default baseDelay is 1000ms; advancing less would not trigger the retry yet.
|
|
await vi.advanceTimersByTimeAsync(1_000);
|
|
|
|
// The retry should have succeeded and returned the resolved value from the mock.
|
|
await expect(promise).resolves.toBe('static-result');
|
|
expect(rejectThenResolveFn).toHaveBeenCalledTimes(2);
|
|
} finally {
|
|
vi.useRealTimers();
|
|
vi.restoreAllMocks();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Tests that {@link ExponentialBackoff.run} accepts a partial options object and merges it
|
|
* with defaults, still retrying when only some fields are overridden.
|
|
*/
|
|
const testExponentialBackoffRunWithPartialOptions = async (): Promise<void> => {
|
|
// Same fail-then-succeed pattern; we only care that partial options still enable a retry.
|
|
const rejectThenResolveFn = vi.fn().mockRejectedValueOnce(new Error('retry me'))
|
|
.mockResolvedValueOnce('done');
|
|
|
|
// baseDelay/jitter of 0 skip real waiting; maxAttempts: 3 gives headroom for one retry.
|
|
// onError is explicitly undefined to verify the default no-op handler is used.
|
|
const result = await ExponentialBackoff.run(rejectThenResolveFn, undefined, {
|
|
baseDelay: 0,
|
|
jitter: 0,
|
|
maxAttempts: 3,
|
|
});
|
|
|
|
expect(result).toBe('done');
|
|
expect(rejectThenResolveFn).toHaveBeenCalledTimes(2);
|
|
};
|
|
|
|
/**
|
|
* Tests that calling {@link ExponentialBackoff.run} on a constructed instance applies
|
|
* the instance's stored options when no per-run options are supplied.
|
|
*/
|
|
const testExponentialBackoffInstanceRunUsesDefaultOnError = async (): Promise<void> => {
|
|
const rejectThenResolveFn = vi.fn().mockRejectedValueOnce(new Error('retry me'))
|
|
.mockResolvedValueOnce('instance-result');
|
|
|
|
// Options live on the instance; run(fn) should read them instead of static defaults.
|
|
const backoff = new ExponentialBackoff({ baseDelay: 0, jitter: 0, maxAttempts: 3 });
|
|
|
|
const result = await backoff.run(rejectThenResolveFn);
|
|
|
|
expect(result).toBe('instance-result');
|
|
expect(rejectThenResolveFn).toHaveBeenCalledTimes(2);
|
|
};
|
|
|
|
/**
|
|
* Tests the happy path: the wrapped function succeeds immediately and no retry machinery runs.
|
|
*/
|
|
const testExponentialBackoffSucceedsOnFirstAttempt = async (): Promise<void> => {
|
|
// Always resolves — never enters the catch/retry branch.
|
|
const resolveFn = vi.fn(async () => 'success');
|
|
const onError = vi.fn();
|
|
|
|
const result = await ExponentialBackoff.run(resolveFn, onError, {
|
|
baseDelay: 0,
|
|
jitter: 0,
|
|
});
|
|
|
|
expect(result).toBe('success');
|
|
expect(resolveFn).toHaveBeenCalledOnce();
|
|
expect(onError).not.toHaveBeenCalled();
|
|
};
|
|
|
|
/**
|
|
* Tests that retries continue across multiple failures until the function eventually resolves.
|
|
*/
|
|
const testExponentialBackoffRetriesUntilSuccess = async (): Promise<void> => {
|
|
// Three invocations: two rejections then a success on the third call.
|
|
const tripleRejectFn = vi
|
|
.fn()
|
|
.mockRejectedValueOnce(new Error('attempt 1'))
|
|
.mockRejectedValueOnce(new Error('attempt 2'))
|
|
.mockResolvedValueOnce('success');
|
|
|
|
// maxAttempts: 5 is high enough that we stop because fn succeeded, not because we hit the cap.
|
|
const result = await ExponentialBackoff.run(tripleRejectFn, () => {}, {
|
|
baseDelay: 0,
|
|
jitter: 0,
|
|
maxAttempts: 5,
|
|
});
|
|
|
|
expect(result).toBe('success');
|
|
expect(tripleRejectFn).toHaveBeenCalledTimes(3);
|
|
};
|
|
|
|
/**
|
|
* Tests that the onError callback is invoked once for every failed attempt, including the last one
|
|
* before an ExponentialBackoffMaxRetriesHitError is thrown to the caller.
|
|
*/
|
|
const testExponentialBackoffCallsOnErrorForEachFailure = async (): Promise<void> => {
|
|
const error = new Error('temporary failure');
|
|
|
|
// Always rejects with the same error — we will exhaust all attempts.
|
|
const rejectFn = vi.fn().mockRejectedValue(error);
|
|
const onError = vi.fn();
|
|
|
|
// maxAttempts: 3 means three tries total, all of which will fail.
|
|
await expect(ExponentialBackoff.run(rejectFn, onError, {
|
|
baseDelay: 0,
|
|
jitter: 0,
|
|
maxAttempts: 3,
|
|
})).rejects.toThrow(AggregateError);
|
|
|
|
expect(onError).toHaveBeenCalledTimes(3);
|
|
expect(onError).toHaveBeenCalledWith(error, expect.objectContaining({}));
|
|
};
|
|
|
|
/**
|
|
* Tests that when all attempts are exhausted the caller receives an ExponentialBackoffMaxRetriesHitError
|
|
* with every task error preserved in order on the cause.
|
|
*/
|
|
const testExponentialBackoffThrowsMaxRetriesHitErrorWhenExhausted = async (): Promise<void> => {
|
|
const firstError = new Error('first');
|
|
const lastError = new Error('last');
|
|
|
|
// Two distinct errors so we can prove both are collected, not just the last one.
|
|
const doubleRejectFn = vi.fn().mockRejectedValueOnce(firstError)
|
|
.mockRejectedValueOnce(lastError);
|
|
|
|
try {
|
|
await ExponentialBackoff.run(doubleRejectFn, () => {}, {
|
|
baseDelay: 0,
|
|
jitter: 0,
|
|
maxAttempts: 2,
|
|
});
|
|
expect.fail('Expected AggregateError to be thrown');
|
|
} catch (error) {
|
|
expect(error).toBeInstanceOf(AggregateError);
|
|
expect((error as AggregateError).errors).toEqual([ firstError, lastError ]);
|
|
}
|
|
|
|
expect(doubleRejectFn).toHaveBeenCalledTimes(2);
|
|
};
|
|
|
|
/**
|
|
* Tests that rejections which are not Error instances are coerced to Error before onError runs,
|
|
* so callers always observe a consistent error type in the callback.
|
|
*/
|
|
const testExponentialBackoffWrapsNonErrorThrows = async (): Promise<void> => {
|
|
// Reject with a plain string — not an Error subclass.
|
|
const rejectedFn = vi.fn().mockRejectedValue('not-an-error');
|
|
const onError = vi.fn();
|
|
|
|
// Single attempt — we fail fast and inspect what onError received.
|
|
try {
|
|
await ExponentialBackoff.run(rejectedFn, onError, {
|
|
baseDelay: 0,
|
|
jitter: 0,
|
|
maxAttempts: 1,
|
|
});
|
|
expect.fail('Expected AggregateError to be thrown');
|
|
} catch (error) {
|
|
expect(error).toBeInstanceOf(AggregateError);
|
|
const [ wrappedError ] = (error as AggregateError).errors as Error[];
|
|
expect(wrappedError).toBeInstanceOf(Error);
|
|
expect(wrappedError?.message).toBe('not-an-error');
|
|
}
|
|
|
|
expect(onError).toHaveBeenCalledOnce();
|
|
expect(onError.mock.calls?.[0]?.[0]).toBeInstanceOf(Error);
|
|
expect(onError.mock.calls?.[0]?.[0]?.message).toBe('not-an-error');
|
|
};
|
|
|
|
/**
|
|
* Tests that when the task function succeeds and the abort signal is aborted, the result is returned
|
|
* and the onError callback is not called.
|
|
*/
|
|
const testExponentialBackoffRunSuccessAndAbortSignal = async (): Promise<void> => {
|
|
// Define the function which aborts the exponential backoff and succeeds
|
|
const abortAndSucceedFn = vi.fn(({ abort }) => {
|
|
abort(new Error('retry me'));
|
|
|
|
return Promise.resolve('success');
|
|
});
|
|
const onErrorFn = vi.fn();
|
|
|
|
// Run the exponential backoff with the function and the onError callback
|
|
const result = await ExponentialBackoff.run(abortAndSucceedFn, onErrorFn, {
|
|
baseDelay: 0,
|
|
jitter: 0,
|
|
});
|
|
|
|
// Expect the result to be the success message
|
|
expect(result).toBe('success');
|
|
expect(abortAndSucceedFn).toHaveBeenCalledOnce();
|
|
|
|
// Expect the onError callback to not have been called
|
|
expect(onErrorFn).not.toHaveBeenCalled();
|
|
};
|
|
|
|
/**
|
|
* Tests that when the abort signal is aborted with an error, an AggregateError is thrown
|
|
* with the error as the message.
|
|
*/
|
|
const testExponentialBackoffRunWithAbortSignal = async (): Promise<void> => {
|
|
// Define the function which aborts the exponential backoff and throws an error
|
|
const abortAndThrowFn = vi.fn(({ abort }) => {
|
|
abort(new Error('exponential backoff aborted message'));
|
|
throw new Error('error message');
|
|
});
|
|
const onErrorFn = vi.fn();
|
|
|
|
// Define the expected error
|
|
const expectedError = new Error('Exponential backoff aborted', { cause: new Error('exponential backoff aborted message') });
|
|
|
|
// Run the exponential backoff with the function and the onError callback and expect the error to be thrown
|
|
await expect(ExponentialBackoff.run(abortAndThrowFn, onErrorFn, {
|
|
baseDelay: 0,
|
|
jitter: 0,
|
|
})).rejects.toThrow(expectedError);
|
|
|
|
// Expect the onError callback to have been called once with the error
|
|
expect(onErrorFn).toHaveBeenCalledOnce();
|
|
expect(onErrorFn.mock.calls?.[0]?.[0]).toBeInstanceOf(Error);
|
|
expect(onErrorFn.mock.calls?.[0]?.[0]?.message).toBe('error message');
|
|
|
|
// Expect the function to have been called once and not to have resolved
|
|
expect(abortAndThrowFn).toHaveBeenCalledOnce();
|
|
expect(abortAndThrowFn).not.toHaveResolved();
|
|
};
|
|
|
|
/**
|
|
* Tests that when the abort signal is aborted with a string, an AggregateError is thrown
|
|
* with the string as the message.
|
|
*/
|
|
const testExponentialBackoffRunAbortedStringCreatesError = async (): Promise<void> => {
|
|
// Define the function which aborts the exponential backoff and throws an error
|
|
const abortAndThrowStringFn = vi.fn(({ abort }) => {
|
|
abort('exponential backoff aborted message');
|
|
|
|
// eslint-disable-next-line
|
|
throw 'error message';
|
|
});
|
|
const onErrorFn = vi.fn();
|
|
|
|
// Define the expected error, Note that we "abort" with just a string, not an error. They are treated equivalently.
|
|
const expectedError = new Error('Exponential backoff aborted', { cause: new Error('exponential backoff aborted message') });
|
|
|
|
// Run the exponential backoff with the function and the onError callback and expect the error to be thrown
|
|
await expect(ExponentialBackoff.run(abortAndThrowStringFn, onErrorFn, {
|
|
baseDelay: 0,
|
|
jitter: 0,
|
|
})).rejects.toThrow(expectedError);
|
|
|
|
// Expect the onError callback to have been called once with the error
|
|
expect(onErrorFn).toHaveBeenCalledOnce();
|
|
expect(onErrorFn.mock.calls?.[0]?.[0]).toBeInstanceOf(Error);
|
|
expect(onErrorFn.mock.calls?.[0]?.[0]?.message).toBe('error message');
|
|
|
|
// Expect the function to have been called once and not to have resolved
|
|
expect(abortAndThrowStringFn).toHaveBeenCalledOnce();
|
|
expect(abortAndThrowStringFn).not.toHaveResolved();
|
|
};
|
|
|
|
/**
|
|
* Tests the {@link ExponentialBackoff.from} factory and subsequent instance {@link ExponentialBackoff.run}
|
|
* as an alternative to the static helper.
|
|
*/
|
|
const testExponentialBackoffFromAndInstanceRun = async (): Promise<void> => {
|
|
const successfullyResolve = vi.fn(async () => 42);
|
|
|
|
// from() is a convenience constructor; run() on the result should behave like the static path.
|
|
const backoff = ExponentialBackoff.from({
|
|
baseDelay: 0,
|
|
jitter: 0,
|
|
});
|
|
|
|
const result = await backoff.run(successfullyResolve);
|
|
|
|
expect(result).toBe(42);
|
|
expect(successfullyResolve).toHaveBeenCalledOnce();
|
|
};
|
|
|
|
/**
|
|
* Tests that maxAttempts: 0 disables the attempt cap so retries continue until the function succeeds.
|
|
*/
|
|
const testExponentialBackoffRetriesIndefinitelyWhenMaxAttemptsIsZero = async (): Promise<void> => {
|
|
// Four invocations: three failures then success — would exceed a cap of 3 if one existed.
|
|
const tripleRejectThenResolveFn = vi
|
|
.fn()
|
|
.mockRejectedValueOnce(new Error('attempt 1'))
|
|
.mockRejectedValueOnce(new Error('attempt 2'))
|
|
.mockRejectedValueOnce(new Error('attempt 3'))
|
|
.mockResolvedValueOnce('eventually');
|
|
|
|
const result = await ExponentialBackoff.run(tripleRejectThenResolveFn, () => {}, {
|
|
baseDelay: 0,
|
|
jitter: 0,
|
|
maxAttempts: 0,
|
|
});
|
|
|
|
expect(result).toBe('eventually');
|
|
expect(tripleRejectThenResolveFn).toHaveBeenCalledTimes(4);
|
|
};
|
|
|
|
/**
|
|
* Tests the delay formula: each retry waits baseDelay * growthRate^attemptIndex milliseconds
|
|
* (with jitter disabled so the math is exact).
|
|
*/
|
|
const testExponentialBackoffIncreasesDelayExponentially = async (): Promise<void> => {
|
|
vi.useFakeTimers();
|
|
vi.spyOn(Math, 'random').mockReturnValue(0.5);
|
|
|
|
try {
|
|
const doubleRejectThenResolveFn = vi
|
|
.fn()
|
|
.mockRejectedValueOnce(new Error('attempt 1'))
|
|
.mockRejectedValueOnce(new Error('attempt 2'))
|
|
.mockResolvedValueOnce('success');
|
|
|
|
const promise = ExponentialBackoff.run(doubleRejectThenResolveFn, () => {}, {
|
|
baseDelay: 100,
|
|
growthRate: 2,
|
|
jitter: 0,
|
|
maxDelay: 10_000,
|
|
maxAttempts: 5,
|
|
});
|
|
|
|
// Attempt 0 fires synchronously on the first microtask tick.
|
|
await Promise.resolve();
|
|
expect(doubleRejectThenResolveFn).toHaveBeenCalledTimes(1);
|
|
|
|
// After attempt 0 fails, delay = 100 * 2^0 = 100ms before attempt 1.
|
|
await vi.advanceTimersByTimeAsync(100);
|
|
expect(doubleRejectThenResolveFn).toHaveBeenCalledTimes(2);
|
|
|
|
// After attempt 1 fails, delay = 100 * 2^1 = 200ms before attempt 2.
|
|
await vi.advanceTimersByTimeAsync(200);
|
|
expect(doubleRejectThenResolveFn).toHaveBeenCalledTimes(3);
|
|
|
|
await expect(promise).resolves.toBe('success');
|
|
} finally {
|
|
vi.useRealTimers();
|
|
vi.restoreAllMocks();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Tests that computed delay never exceeds maxDelay even when exponential growth would go higher.
|
|
*/
|
|
const testExponentialBackoffCapsDelayAtMaxDelay = async (): Promise<void> => {
|
|
vi.useFakeTimers();
|
|
vi.spyOn(Math, 'random').mockReturnValue(0.5);
|
|
|
|
try {
|
|
const doubleRejectThenResolveFn = vi
|
|
.fn()
|
|
.mockRejectedValueOnce(new Error('attempt 1'))
|
|
.mockRejectedValueOnce(new Error('attempt 2'))
|
|
.mockResolvedValueOnce('success');
|
|
|
|
const promise = ExponentialBackoff.run(doubleRejectThenResolveFn, () => {}, {
|
|
baseDelay: 1_000,
|
|
growthRate: 4,
|
|
jitter: 0,
|
|
maxDelay: 2_000,
|
|
maxAttempts: 5,
|
|
});
|
|
|
|
await Promise.resolve();
|
|
expect(doubleRejectThenResolveFn).toHaveBeenCalledTimes(1);
|
|
|
|
// attempt 0: 1000 * 4^0 = 1000ms, below the 2000ms cap.
|
|
await vi.advanceTimersByTimeAsync(1_000);
|
|
expect(doubleRejectThenResolveFn).toHaveBeenCalledTimes(2);
|
|
|
|
// attempt 1: uncapped would be 4000ms but maxDelay clamps to 2000ms.
|
|
await vi.advanceTimersByTimeAsync(2_000);
|
|
expect(doubleRejectThenResolveFn).toHaveBeenCalledTimes(3);
|
|
|
|
await expect(promise).resolves.toBe('success');
|
|
} finally {
|
|
vi.useRealTimers();
|
|
vi.restoreAllMocks();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Tests that jitter subtracts up to jitter * cappedDelay from the capped delay based on Math.random.
|
|
*/
|
|
const testExponentialBackoffAppliesJitter = async (): Promise<void> => {
|
|
vi.useFakeTimers();
|
|
// random = 1 → full 10% reduction: 1000 - (1 * 0.1 * 1000) = 900ms.
|
|
vi.spyOn(Math, 'random').mockReturnValue(1);
|
|
|
|
try {
|
|
const rejectThenResolveFn = vi.fn().mockRejectedValueOnce(new Error('attempt 1'))
|
|
.mockResolvedValueOnce('success');
|
|
|
|
const promise = ExponentialBackoff.run(rejectThenResolveFn, () => {}, {
|
|
baseDelay: 1_000,
|
|
growthRate: 1,
|
|
jitter: 0.1,
|
|
maxDelay: 10_000,
|
|
maxAttempts: 3,
|
|
});
|
|
|
|
await Promise.resolve();
|
|
expect(rejectThenResolveFn).toHaveBeenCalledTimes(1);
|
|
|
|
// Advancing 899ms is one ms short of the jittered delay; 900ms triggers the retry.
|
|
await vi.advanceTimersByTimeAsync(899);
|
|
expect(rejectThenResolveFn).toHaveBeenCalledTimes(1);
|
|
|
|
await vi.advanceTimersByTimeAsync(1);
|
|
expect(rejectThenResolveFn).toHaveBeenCalledTimes(2);
|
|
|
|
await expect(promise).resolves.toBe('success');
|
|
} finally {
|
|
vi.useRealTimers();
|
|
vi.restoreAllMocks();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Tests that {@link ExponentialBackoff.validateOptions} accepts valid options, including boundary values of 0 and 1.
|
|
*/
|
|
const testExponentialBackoffValidateOptionsAcceptsValidOptions = (): void => {
|
|
const validCases = [
|
|
validExponentialBackoffOptions,
|
|
{
|
|
...validExponentialBackoffOptions,
|
|
maxDelay: 0,
|
|
maxAttempts: 0,
|
|
baseDelay: 0,
|
|
growthRate: 0,
|
|
jitter: 0,
|
|
},
|
|
{
|
|
...validExponentialBackoffOptions,
|
|
jitter: 1,
|
|
},
|
|
] as const;
|
|
|
|
for (const options of validCases) {
|
|
expect(() => ExponentialBackoff.validateOptions(options)).not.toThrow();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Tests that {@link ExponentialBackoff.validateOptions} rejects negative numeric options.
|
|
*/
|
|
const testExponentialBackoffValidateOptionsRejectsNegativeValues = (): void => {
|
|
// Define our test cases with each value being less than 0
|
|
const negativeCases = [
|
|
{ field: 'maxDelay', value: -1 },
|
|
{ field: 'maxAttempts', value: -1 },
|
|
{ field: 'baseDelay', value: -1 },
|
|
{ field: 'growthRate', value: -1 },
|
|
] as const;
|
|
|
|
// Iterate through the test cases and expect an error to be thrown
|
|
for (const { field, value } of negativeCases) {
|
|
expect(() =>
|
|
ExponentialBackoff.validateOptions({
|
|
...validExponentialBackoffOptions,
|
|
[field]: value,
|
|
})).toThrow(`Invalid option: ${field} is less than 0`);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Tests that {@link ExponentialBackoff.validateOptions} rejects jitter below 0 or above 1.
|
|
*/
|
|
const testExponentialBackoffValidateOptionsRejectsInvalidJitter = (): void => {
|
|
// Define our test cases with each value being less than 0 or greater than 1
|
|
const invalidJitterCases: Array<{ value: number }> = [{ value: -0.1 }, { value: 1.1 }];
|
|
|
|
// Iterate through the test cases and expect an error to be thrown
|
|
for (const { value } of invalidJitterCases) {
|
|
expect(() =>
|
|
ExponentialBackoff.validateOptions({
|
|
...validExponentialBackoffOptions,
|
|
jitter: value,
|
|
})).toThrow('Invalid option: jitter is not between 0 and 1');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Tests that {@link ExponentialBackoff.validateOptions} rejects non-finite values such as Infinity.
|
|
*/
|
|
const testExponentialBackoffValidateOptionsRejectsNonFiniteValues = (): void => {
|
|
// Define our test cases with each value being Infinity
|
|
const nonFiniteCases = [
|
|
{ field: 'maxDelay', value: Infinity },
|
|
{ field: 'maxAttempts', value: Infinity },
|
|
{ field: 'baseDelay', value: Infinity },
|
|
{ field: 'growthRate', value: Infinity },
|
|
{ field: 'jitter', value: Infinity },
|
|
] as const;
|
|
|
|
// Iterate through the test cases and expect an error to be thrown
|
|
for (const { field, value } of nonFiniteCases) {
|
|
expect(() =>
|
|
ExponentialBackoff.validateOptions({
|
|
...validExponentialBackoffOptions,
|
|
[field]: value,
|
|
})).toThrow(`Invalid option: ${field} is not finite`);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Tests that {@link ExponentialBackoff.validateOptions} rejects NaN, which is also non-finite.
|
|
*/
|
|
const testExponentialBackoffValidateOptionsRejectsNaN = (): void => {
|
|
// Define our test cases with each value being NaN
|
|
const nanCases = [
|
|
{ field: 'maxDelay', value: Number.NaN },
|
|
{ field: 'maxAttempts', value: Number.NaN },
|
|
{ field: 'baseDelay', value: Number.NaN },
|
|
{ field: 'growthRate', value: Number.NaN },
|
|
{ field: 'jitter', value: Number.NaN },
|
|
] as const;
|
|
|
|
// Iterate through the test cases and expect an error to be thrown
|
|
for (const { field, value } of nanCases) {
|
|
expect(() =>
|
|
ExponentialBackoff.validateOptions({
|
|
...validExponentialBackoffOptions,
|
|
[field]: value,
|
|
})).toThrow(`Invalid option: ${field} is not finite`);
|
|
}
|
|
};
|
|
|
|
const runTests = async (): Promise<void> => {
|
|
test('ExponentialBackoff.run: delegates to a new instance using default options', testExponentialBackoffRunUsesDefaultOptions);
|
|
test('ExponentialBackoff.run: retries and succeeds with partial options', testExponentialBackoffRunWithPartialOptions);
|
|
test('ExponentialBackoff.run: uses the instance default onError when omitted', testExponentialBackoffInstanceRunUsesDefaultOnError);
|
|
test('ExponentialBackoff: returns the result on first success', testExponentialBackoffSucceedsOnFirstAttempt);
|
|
test('ExponentialBackoff: retries until the function succeeds', testExponentialBackoffRetriesUntilSuccess);
|
|
test('ExponentialBackoff: calls onError for each failed attempt', testExponentialBackoffCallsOnErrorForEachFailure);
|
|
test(
|
|
'ExponentialBackoff: throws ExponentialBackoffMaxRetriesHitError when max attempts are exhausted',
|
|
testExponentialBackoffThrowsMaxRetriesHitErrorWhenExhausted,
|
|
);
|
|
test('ExponentialBackoff: wraps non-Error throws before calling onError', testExponentialBackoffWrapsNonErrorThrows);
|
|
test('ExponentialBackoff: succeeds and aborts with abort signal', testExponentialBackoffRunSuccessAndAbortSignal);
|
|
test('ExponentialBackoff: aborts with abort signal', testExponentialBackoffRunWithAbortSignal);
|
|
test('ExponentialBackoff: aborts with aborted string creates error', testExponentialBackoffRunAbortedStringCreatesError);
|
|
test('ExponentialBackoff: works via from and instance run', testExponentialBackoffFromAndInstanceRun);
|
|
test('ExponentialBackoff: retries indefinitely when maxAttempts is 0', testExponentialBackoffRetriesIndefinitelyWhenMaxAttemptsIsZero);
|
|
test('ExponentialBackoff: increases delay exponentially between attempts', testExponentialBackoffIncreasesDelayExponentially);
|
|
test('ExponentialBackoff: caps delay at maxDelay', testExponentialBackoffCapsDelayAtMaxDelay);
|
|
test('ExponentialBackoff: subtracts jitter from the capped delay', testExponentialBackoffAppliesJitter);
|
|
test('ExponentialBackoff.validateOptions: accepts valid options', testExponentialBackoffValidateOptionsAcceptsValidOptions);
|
|
test('ExponentialBackoff.validateOptions: rejects negative values', testExponentialBackoffValidateOptionsRejectsNegativeValues);
|
|
test('ExponentialBackoff.validateOptions: rejects invalid jitter', testExponentialBackoffValidateOptionsRejectsInvalidJitter);
|
|
test('ExponentialBackoff.validateOptions: rejects Infinity', testExponentialBackoffValidateOptionsRejectsNonFiniteValues);
|
|
test('ExponentialBackoff.validateOptions: rejects NaN', testExponentialBackoffValidateOptionsRejectsNaN);
|
|
};
|
|
|
|
await runTests();
|