@openstax/ts-utils 1.34.0 → 1.34.1

package/packages/utils/src/fetch/fetchStatusRetry.ts

@@ -1,33 +0,0 @@
-import { RetryOptions, retryWithDelay } from '../misc/helpers';
-import { GenericFetch } from '.';
-
-interface Options extends RetryOptions {
-  status?: number[];
-  timeout?: number;
-}
-
-export const fetchStatusRetry = (base: GenericFetch, options: Options): GenericFetch => {
-
-  return (...params) => retryWithDelay(() => {
-    const fetchPromise = base(...params).then(r => {
-      if (options.status?.includes(r.status)) {
-        return r.text().then(text => {
-          throw new Error(`fetch failed ${params[0]} -- ${r.status}: ${text}`);
-        });
-      }
-      return r;
-    });
-
-    if (options.timeout) {
-      const timeoutPromise = new Promise<never>((_, reject) => {
-        setTimeout(() => {
-          reject(new Error(`fetch timeout after ${options.timeout}ms: ${params[0]}`));
-        }, options.timeout);
-      });
-
-      return Promise.race([fetchPromise, timeoutPromise]);
-    }
-
-    return fetchPromise;
-  }, options);
-};

package/packages/utils/src/fetch/index.spec.ts

@@ -1,34 +0,0 @@
-import { fetchError, fetchIdle, fetchLoading, FetchStateType, fetchSuccess, stateHasData, stateHasError } from '.';
-
-describe('creators', () => {
-  it('creates FetchStateLoading', () => {
-    expect(fetchLoading()).toEqual({type: 'loading'});
-  });
-  it('creates FetchStateLoading, with data', () => {
-    expect(fetchLoading({type: FetchStateType.ERROR, error: 'some error', data: 'other data'})).toEqual({type: 'loading', data: 'other data'});
-  });
-  it('creates FetchStateError', () => {
-    expect(fetchError('hello')).toEqual({type: 'error', error: 'hello'});
-  });
-  it('creates FetchStateSuccess', () => {
-    expect(fetchSuccess('wow, such success')).toEqual({type: 'success', data: 'wow, such success'});
-  });
-  it('creates FetchStateIdle', () => {
-    expect(fetchIdle()).toEqual({type: 'idle'});
-  });
-});
-
-describe('guards', () => {
-  it('returns true with data', () => {
-    expect(stateHasData(fetchSuccess('wow'))).toBe(true);
-  });
-  it('returns false with data', () => {
-    expect(stateHasData(fetchLoading())).toBe(false);
-  });
-  it('returns true with error', () => {
-    expect(stateHasError(fetchError('wow'))).toBe(true);
-  });
-  it('returns false with error', () => {
-    expect(stateHasError(fetchLoading())).toBe(false);
-  });
-});

package/packages/utils/src/fetch/index.ts

@@ -1,87 +0,0 @@
-import { METHOD } from '../routing';
-
-/*
- * these are just helpers for formatting responses, they don't actually do any loading. especially in UI development they
- * help with continuity over loading, reloading, saving, and errors. this is pretty nice in typescript because you have to deal
- * with the possibility that the result state is in a loading or error state. if you avoid dealing with those states you need
- * to write very clear code to ignore them, which easily presents missing functionality like errors that are not being messaged
- * to the user.
- * */
-export enum FetchStateType {
-  SUCCESS = 'success',
-  ERROR = 'error',
-  LOADING = 'loading',
-  IDLE = 'idle',
-}
-
-export type FetchState<D, E> = FetchStateLoading<D>
-  | FetchStateError<D, E>
-  | FetchStateSuccess<D>
-  | FetchStateIdle;
-
-type FetchStateLoading<D> = {type: FetchStateType.LOADING; data?: D};
-type FetchStateError<D, E> = {type: FetchStateType.ERROR; data?: D; error: E};
-type FetchStateSuccess<D> = {type: FetchStateType.SUCCESS; data: D};
-type FetchStateIdle = {type: FetchStateType.IDLE};
-
-/*
- * keeps existing data but sets the new status
- *
- * const state = fetchLoading(previousState)
- * */
-export const fetchLoading = <D, E>(previous?: FetchState<D, E>): FetchStateLoading<D>  => ({type: FetchStateType.LOADING, ...(previous && 'data' in previous ? {data: previous.data} : {})});
-
-/*
- * keeps existing data but sets the new status and error value
- *
- * const state = fetchError(error, previousState)
- * */
-export const fetchError = <D, E>(error: E, previous?: FetchState<D, E>): FetchStateError<D, E> => ({...previous, type: FetchStateType.ERROR, error});
-
-/*
- * formats data with success type
- *
- * const state = fetchSuccess(newData)
- * */
-export const fetchSuccess = <D>(data: D): FetchStateSuccess<D> => ({type: FetchStateType.SUCCESS, data});
-
-/*
- * formats data with idle type
- *
- * const state = fetchIdle(newData)
- * */
-export const fetchIdle = (): FetchStateIdle => ({type: FetchStateType.IDLE});
-
-/*
- * guard for checking if the state has result data, it might be true for any state type.
- * */
-export const stateHasData = <D, E>(state: {type: FetchStateType; data?: D; error?: E}): state is {type: FetchStateType; data: D} => 'data' in state;
-/*
- * guard for checking if the state has an error, it might be true for error or loading states.
- * */
-export const stateHasError = <D, E>(state: {type: FetchStateType; data?: D; error?: E}): state is {type: FetchStateType; error: E} => 'error' in state;
-
-/*
- * a minimal fetch interface that is compatible with both WindowOrWorkerGlobalScope['fetch'] and node-fetch
- * only the features needed by this library are defined here. the generic is so that utilities can set
- * themselves up to accept input fetchConfig that may extend this.
- */
-export type FetchConfig = {
-  credentials?: 'include' | 'omit' | 'same-origin';
-  method?: METHOD;
-  body?: string;
-  headers?: {[key: string]: string};
-};
-type Headers = {
-  get: (name: string) => string | null;
-};
-export type Response = {
-  status: number;
-  headers: Headers;
-  json: () => Promise<any>;
-  text: () => Promise<string>;
-};
-export type GenericFetch<C extends FetchConfig = FetchConfig, R extends Response = Response> =
-  (url: string, fetchConfig?: C) => Promise<R>;
-
-export type ConfigForFetch<F> = F extends GenericFetch<infer C, any> ? C : never;

package/packages/utils/src/guards/index.spec.ts

@@ -1,58 +0,0 @@
-import { ifDefined, isDefined, isNotNull, isNumber, isPlainObject } from '.';
-
-describe('ifDefined', () => {
-  it('returns input', () => {
-    expect(ifDefined('input', 'default')).toBe('input');
-  });
-  it('returns default', () => {
-    expect(ifDefined(undefined, 'default')).toBe('default');
-  });
-});
-
-describe('isNumber', () => {
-  it('returns true', () => {
-    expect(isNumber(5)).toBe(true);
-  });
-  it('returns false', () => {
-    expect(isNumber('5')).toBe(false);
-  });
-});
-
-describe('isDefined', () => {
-  it('is defined', () => {
-    expect(isDefined('asdf')).toBe(true);
-  });
-  it('null is defined', () => {
-    expect(isDefined(null)).toBe(true);
-  });
-  it('false is defined', () => {
-    expect(isDefined(false)).toBe(true);
-  });
-  it('isn\'t defined', () => {
-    expect(isDefined(undefined)).toBe(false);
-  });
-});
-
-describe('isNotNull', () => {
-  it('is not null', () => {
-    expect(isNotNull('asdf')).toBe(true);
-  });
-  it('null is null', () => {
-    expect(isNotNull(null)).toBe(false);
-  });
-  it('false is not null', () => {
-    expect(isNotNull(false)).toBe(true);
-  });
-  it('undefined is not null', () => {
-    expect(isNotNull(undefined)).toBe(true);
-  });
-});
-
-describe('isPlainObject', () => {
-  it('is plain', () => {
-    expect(isPlainObject({})).toBe(true);
-  });
-  it('is not plain', () => {
-    expect(isPlainObject(new Error())).toBe(false);
-  });
-});

package/packages/utils/src/index.spec.ts

@@ -1,471 +0,0 @@
-import { retryWithDelay } from './misc/helpers';
-import { coerceArray, flow, fnIf, getKeyValue, getKeyValueOr, hashValue, mapFind, memoize, merge, once, partitionSequence, putKeyValue, roundToPrecision, tuple } from '.';
-
-afterEach(() => {
-  jest.clearAllMocks();
-});
-
-describe('mapFind', () => {
-  it('finds first result', () => {
-    const array = [{a: 0}, {a: 2}, {a: 0}, {a: 1}];
-    const result = mapFind(array, x => x.a);
-
-    expect(result).toBe(2);
-  });
-
-  it('finds first result with predicate', () => {
-    const array = [{a: 0}, {a: 2}, {a: 0}, {a: 1}];
-    const result = mapFind(array, x => x.a, x => x === 1);
-
-    expect(result).toBe(1);
-  });
-
-  it('fails to find result', () => {
-    const array: {a: number; b?: number}[] = [{a: 0}, {a: 2}, {a: 0}, {a: 1}];
-    const result = mapFind(array, x => x.b);
-
-    expect(result).toBeUndefined();
-  });
-
-  it('fails to find result with predicate', () => {
-    const array = [{a: 0}, {a: 2}, {a: 0}, {a: 1}];
-    const result = mapFind(array, x => x.a, x => x === 3);
-
-    expect(result).toBeUndefined();
-  });
-});
-
-describe('hashValue', () => {
-  it('hashes a string', () => {
-    expect(hashValue('a string')).toEqual(expect.any(String));
-    expect(hashValue('a string')).toEqual(hashValue('a string'));
-    expect(hashValue('a string')).not.toEqual(hashValue('a different string'));
-  });
-  it('hashes a boolean', () => {
-    expect(hashValue(true)).toEqual(expect.any(String));
-    expect(hashValue(true)).toEqual(hashValue(true));
-    expect(hashValue(true)).not.toEqual(hashValue(false));
-  });
-  it('hashes a number', () => {
-    expect(hashValue(1)).toEqual(expect.any(String));
-    expect(hashValue(1)).toEqual(hashValue(1));
-    expect(hashValue(1)).not.toEqual(hashValue(2));
-  });
-  it('hashes a list', () => {
-    expect(hashValue([1,2])).toEqual(expect.any(String));
-    expect(hashValue([1,2])).toEqual(hashValue([1,2]));
-    expect(hashValue([1,2])).not.toEqual(hashValue([2,3]));
-  });
-  it('hashes an object', () => {
-    expect(hashValue({one: 'one'})).toEqual(expect.any(String));
-    expect(hashValue({one: 'one'})).toEqual(hashValue({one: 'one'}));
-    expect(hashValue({one: 'one'})).not.toEqual(hashValue({two: 'two'}));
-    expect(hashValue({one: 'one', two: 'two'})).toEqual(hashValue({two: 'two', one: 'one'}));
-  });
-});
-
-describe('object access', () => {
-  it('gets key value', () => {
-    expect(getKeyValue('theKey')({theKey: 'theValue'})).toBe('theValue');
-  });
-  it('gets key value with default', () => {
-    expect(getKeyValueOr('theKey', 'defaultValue')({theKey: 'theValue'})).toBe('theValue');
-  });
-  it('gets default value', () => {
-    expect(getKeyValueOr('theKey', 'defaultValue')({theKey: null})).toBe('defaultValue');
-  });
-  it('puts key value', () => {
-    expect(putKeyValue('theKey')({theKey: 'theValue'}, 'newValue')).toEqual({theKey: 'newValue'});
-  });
-});
-
-describe('once', () => {
-  it('calls once', () => {
-    const spy = jest.fn(x => x);
-    const onceSpy = once(spy);
-
-    expect(onceSpy(5)).toBe(5);
-    expect(onceSpy(1)).toBe(5);
-    expect(onceSpy(7)).toBe(5);
-    expect(onceSpy(2)).toBe(5);
-
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-
-  it('calls once when result is falsy', () => {
-    const spy = jest.fn(_x => null);
-    const onceSpy = once(spy);
-
-    expect(onceSpy(5)).toBeNull();
-    expect(onceSpy(1)).toBeNull();
-    expect(onceSpy(7)).toBeNull();
-    expect(onceSpy(2)).toBeNull();
-
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-
-  it('calls multiple times when the function throws', () => {
-    const spy = jest.fn((_x) => { throw new Error('Bad Request'); });
-    const onceSpy = once(spy);
-
-    expect(() => onceSpy(1)).toThrow('Bad Request');
-    expect(() => onceSpy(2)).toThrow('Bad Request');
-
-    expect(spy).toHaveBeenCalledTimes(2);
-  });
-
-  it('calls multiple times when the function returns a Promise that rejects (when it rejects)', async() => {
-    const spy = jest.fn(async(_x) => { throw new Error('Bad Request'); });
-    const onceSpy = once(spy);
-
-    const promise1 = onceSpy(1);
-    const promise2 = onceSpy(2);
-
-    await expect(promise1).rejects.toThrow('Bad Request');
-    await expect(promise2).rejects.toThrow('Bad Request');
-
-    expect(spy).toHaveBeenCalledTimes(1);
-
-    await expect(onceSpy(3)).rejects.toThrow('Bad Request');
-
-    expect(spy).toHaveBeenCalledTimes(2);
-  });
-});
-
-describe('merge', () => {
-  it('merges simple object', () => {
-    expect(merge({key1: 'value1'}, {key2: 'value2'})).toEqual({key1: 'value1', key2: 'value2'});
-  });
-
-  it('merges objects recursively', () => {
-    expect(merge(
-      {key1: 'value1', subObject: {subKey1: 'subValue1'}},
-      {key2: 'value2', subObject: {subKey2: 'subValue2'}}
-    )).toEqual({key1: 'value1', key2: 'value2', subObject: {subKey1: 'subValue1', subKey2: 'subValue2'}});
-  });
-
-  it('merges arrays recursively', () => {
-    expect(merge(
-      {key1: 'value1', subArray: ['subValue1']},
-      {key2: 'value2', subArray: ['subValue2']}
-    )).toEqual({key1: 'value1', key2: 'value2', subArray: ['subValue1', 'subValue2']});
-  });
-
-  it('last value for common key wins', () => {
-    expect(merge({key: 'value1'}, {key: 'value2'})).toEqual({key: 'value2'});
-  });
-
-  it('object references work when unmerged', () => {
-    const subObject1 = {subKey1: 'subValue1'};
-    const subObject2 = {subKey2: 'subValue2'};
-    const merged = merge(
-      {key1: 'value1', subObject1, subObject: subObject1},
-      {key2: 'value2', subObject2, subObject: subObject2}
-    );
-
-    expect(merged.subObject1).toBe(subObject1);
-    expect(merged.subObject2).toBe(subObject2);
-    expect(merged.subObject).not.toBe(subObject1);
-    expect(merged.subObject).not.toBe(subObject2);
-  });
-});
-
-describe('tuple', () => {
-  it('works', () => {
-    expect(tuple(1,2)).toEqual([1,2]);
-  });
-});
-
-describe('fnIf', () => {
-  it('returns one', () => {
-    expect(fnIf(true, 'this one', 'not this one')).toBe('this one');
-  });
-
-  it('returns two', () => {
-    expect(fnIf(false, 'not this one', 'this one')).toBe('this one');
-  });
-});
-
-describe('roundToPrecision', () => {
-  it('rounds positive places', () => {
-    expect(roundToPrecision(1234.123, 2)).toBe(1200);
-  });
-
-  it('rounds negative places', () => {
-    expect(roundToPrecision(1234.123, -2)).toBe(1234.12);
-  });
-
-  it('rounds up 5s', () => {
-    expect(roundToPrecision(1234.125, -2)).toBe(1234.13);
-  });
-});
-
-describe('memoize', () => {
-  it('memoizes', () => {
-    const fn = jest.fn((x: number) => x * 2);
-    const fnM = memoize(fn);
-
-    expect(fnM(3)).toBe(6);
-    expect(fnM(3)).toBe(6);
-    expect(fnM(3)).toBe(6);
-    expect(fnM(1)).toBe(2);
-    expect(fnM(1)).toBe(2);
-    expect(fnM(7)).toBe(14);
-
-    expect(fn).toHaveBeenCalledTimes(3);
-  });
-
-  it('handles multiple arguments', () => {
-    const fn = jest.fn((x: number, y: number, z: number = 1) => x * y * z);
-    const fnM = memoize(fn);
-
-    expect(fnM(3, 2)).toBe(6);
-    expect(fnM(3, 2)).toBe(6);
-    expect(fnM(3, 3)).toBe(9);
-    expect(fnM(3, 3, 2)).toBe(18);
-    expect(fnM(3, 3, 2)).toBe(18);
-    expect(fnM(1, 2)).toBe(2);
-    expect(fnM(1, 2)).toBe(2);
-    expect(fnM(7, 2)).toBe(14);
-
-    expect(fn).toHaveBeenCalledTimes(5);
-  });
-
-  it('memoizes object arguments', () => {
-    const fn = jest.fn((x: number, {y, z}: {y: number; z?: number}) => x * y * (z || 1));
-    const fnM = memoize(fn);
-
-    const two = {y: 2};
-    const threeTwo = {y:3, z: 2};
-
-    expect(fnM(3, two)).toBe(6);
-    expect(fnM(3, two)).toBe(6);
-    expect(fnM(3, {y: 3})).toBe(9);
-    expect(fnM(3, threeTwo)).toBe(18);
-    expect(fnM(3, threeTwo)).toBe(18);
-    expect(fnM(1, two)).toBe(2);
-    expect(fnM(1, two)).toBe(2);
-    expect(fnM(7, two)).toBe(14);
-
-    expect(fn).toHaveBeenCalledTimes(5);
-  });
-
-  describe('without WeakMap support', () => {
-    const weakMapBak = global.WeakMap;
-
-    beforeEach(() => {
-      delete (global as any).WeakMap;
-    });
-
-    afterEach(() => {
-      (global as any).WeakMap = weakMapBak;
-    });
-
-    it('still works', () => {
-      const fn = jest.fn((x: number, y: number, z: number = 1) => x * y * z);
-      const fnM = memoize(fn);
-
-      expect(fnM(3, 2)).toBe(6);
-      expect(fnM(3, 2)).toBe(6);
-      expect(fnM(3, 3)).toBe(9);
-      expect(fnM(3, 3, 2)).toBe(18);
-      expect(fnM(3, 3, 2)).toBe(18);
-      expect(fnM(1, 2)).toBe(2);
-      expect(fnM(1, 2)).toBe(2);
-      expect(fnM(7, 2)).toBe(14);
-
-      expect(fn).toHaveBeenCalledTimes(5);
-    });
-
-    it('doesn\'t memoize object arguments', () => {
-      const fn = jest.fn((x: number, {y, z}: {y: number; z?: number}) => x * y * (z || 1));
-      const fnM = memoize(fn);
-
-      const two = {y: 2};
-      const threeTwo = {y:3, z: 2};
-
-      expect(fnM(3, two)).toBe(6);
-      expect(fnM(3, two)).toBe(6);
-      expect(fnM(3, {y: 3})).toBe(9);
-      expect(fnM(3, threeTwo)).toBe(18);
-      expect(fnM(3, threeTwo)).toBe(18);
-      expect(fnM(1, two)).toBe(2);
-      expect(fnM(1, two)).toBe(2);
-      expect(fnM(7, two)).toBe(14);
-
-      expect(fn).toHaveBeenCalledTimes(8);
-    });
-  });
-
-  it('calls multiple times when the function returns a Promise that rejects (when it rejects)', async() => {
-    const spy = jest.fn(async(_x) => { throw new Error('Bad Request'); });
-    const memoized = memoize(spy);
-
-    const promise1 = memoized(1);
-    const promise2 = memoized(1);
-    const promise3 = memoized(2);
-
-    await expect(promise1).rejects.toThrow('Bad Request');
-    await expect(promise2).rejects.toThrow('Bad Request');
-    await expect(promise3).rejects.toThrow('Bad Request');
-
-    expect(spy).toHaveBeenCalledTimes(2);
-
-    await expect(memoized(2)).rejects.toThrow('Bad Request');
-
-    expect(spy).toHaveBeenCalledTimes(3);
-  });
-});
-
-describe('partitionSequence', () => {
-  it('partitions a sequence by predicate', () => {
-    expect(partitionSequence(
-      (n: number) => ({value: n % 2}),
-      [1,2,3,4,5,6,7,8]
-    )).toEqual([
-      [1, [1]],
-      [0, [2]],
-      [1, [3]],
-      [0, [4]],
-      [1, [5]],
-      [0, [6]],
-      [1, [7]],
-      [0, [8]],
-    ]);
-    expect(partitionSequence(
-      (n: number) => ({value: Math.floor(n / 3)}),
-      [1,2,3,4,5,6,7,8]
-    )).toEqual([
-      [0, [1,2]],
-      [1, [3,4, 5]],
-      [2, [6,7,8]],
-    ]);
-  });
-
-  it('partitions a sequence with running predicate', () => {
-    expect(partitionSequence(
-      (n: number, p?: {min: number; max: number}) =>
-        p && p.max + 1 === n
-          ? {value: {...p, max: n}, matches: true}
-          : {value: {min: n, max: n}, matches: false}
-      , [1,2,3,5,6,8]
-    )).toEqual([
-      [{min: 1, max: 3}, [1,2,3]],
-      [{min: 5,max: 6}, [5,6]],
-      [{min: 8,max: 8}, [8]],
-    ]);
-  });
-});
-
-describe('flow', () => {
-  it('flows', () => {
-    const fn = flow(
-      (n: number) => n * 4,
-      (n: number) => n.toString(),
-      (s: string) => [s, s],
-      (a: string[]) => a.join(', ')
-    );
-
-    expect(fn(2)).toBe('8, 8');
-  });
-});
-
-describe('coerceArray', () => {
-  it('coerces', () => {
-    expect(coerceArray('value')).toEqual(['value']);
-  });
-
-  it('no-ops', () => {
-    const array = ['foo'];
-    expect(coerceArray(array)).toBe(array);
-  });
-
-  it('handles undefined', () => {
-    expect(coerceArray(undefined)).toEqual([]);
-  });
-});
-
-describe('retryWithDelay', () => {
-  let setTimeoutSpy: jest.SpyInstance;
-  let timeouts: Array<number | undefined>;
-
-  const doBeforeEach = () => {
-    timeouts = [];
-    setTimeoutSpy = jest.spyOn(global, 'setTimeout')
-      .mockImplementation((fn, timeout) => {
-        timeouts.push(timeout);
-        fn();
-        return 1 as any;
-      });
-  };
-
-  const doAfterEach = () => {
-    setTimeoutSpy.mockReset();
-  };
-
-  beforeEach(doBeforeEach);
-  afterEach(doAfterEach);
-
-  it('runs once without delay', async() => {
-    const fn = jest.fn().mockReturnValue(Promise.resolve('hello'));
-    const result = await retryWithDelay(fn);
-    expect(setTimeoutSpy).not.toHaveBeenCalled();
-    expect(result).toBe('hello');
-  });
-
-  it('aborts without retrying', async() => {
-    const fn = jest.fn().mockImplementation(async abort => {
-      abort(new Error('cool error'));
-      throw new Error('unreachable code');
-    });
-    await expect(() => retryWithDelay(fn)).rejects.toThrow('cool error');
-    expect(setTimeoutSpy).not.toHaveBeenCalled();
-  });
-
-  it('retries within expected delay bounds', async() => {
-    for (let i = 0; i < 100; i++) {
-      doBeforeEach();
-      const fn = jest.fn()
-        .mockReturnValueOnce(Promise.reject(new Error('nope')))
-        .mockReturnValue(Promise.resolve('hello'));
-
-      const result = await retryWithDelay<string>(fn);
-
-      expect(result).toBe('hello');
-
-      expect(setTimeoutSpy).toHaveBeenCalledTimes(1);
-      expect(timeouts).toHaveLength(1);
-
-      expect(timeouts[0]).toBeGreaterThan(50);
-      expect(timeouts[0]).toBeLessThan(150);
-      doAfterEach();
-    }
-  });
-
-  it('throws when it runs out of attempts', async() => {
-    for (let i = 0; i < 100; i++) {
-      doBeforeEach();
-      const fn = jest.fn()
-        .mockReturnValueOnce(Promise.reject(new Error('nope')))
-        .mockReturnValueOnce(Promise.reject(new Error('nope')))
-        .mockReturnValueOnce(Promise.reject(new Error('nope')))
-        .mockReturnValueOnce(Promise.reject(new Error('nope')))
-        .mockReturnValue(Promise.resolve('hello'));
-
-      await expect(() => retryWithDelay<string>(fn, {retries: 3})).rejects.toThrow('nope');
-
-      expect(setTimeoutSpy).toHaveBeenCalledTimes(3);
-      expect(timeouts).toHaveLength(3);
-
-      expect(timeouts[0]).toBeGreaterThan(50);
-      expect(timeouts[0]).toBeLessThan(150);
-
-      expect(timeouts[1]).toBeGreaterThan(150);
-      expect(timeouts[1]).toBeLessThan(250);
-
-      expect(timeouts[2]).toBeGreaterThan(250);
-      expect(timeouts[2]).toBeLessThan(350);
-      doAfterEach();
-    }
-  });
-});