@openstax/ts-utils 1.34.0 → 1.34.1

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

@@ -1,126 +0,0 @@
-import { assertDefined, assertErrorInstanceOf, assertFalse, assertInstanceOf, assertNotNaN, assertString, assertTrue } from '.';
-
-describe('assertNotNaN', () => {
-  it('throws when NaN', () => {
-    expect(() => assertNotNaN(NaN)).toThrow();
-  });
-  it('returns thing when not NaN', () => {
-    expect(() => assertNotNaN('asdf')).not.toThrow();
-    expect(assertNotNaN('asdf')).toBe('asdf');
-  });
-});
-
-describe('assertDefined', () => {
-  it('returns value', () => {
-    expect(assertDefined('foo', 'error')).toBe('foo');
-  });
-
-  it('throws on undefined', () => {
-    expect(() =>
-      assertDefined(undefined, 'error')
-    ).toThrowErrorMatchingInlineSnapshot('"error"');
-  });
-});
-
-describe('assertTrue', () => {
-  it('returns value', () => {
-    expect(assertTrue(true, 'error')).toBe(true);
-  });
-
-  it('throws on not true', () => {
-    expect(() =>
-      assertTrue(undefined, 'error')
-    ).toThrowErrorMatchingInlineSnapshot('"error"');
-    expect(() =>
-      assertTrue(3, 'error')
-    ).toThrowErrorMatchingInlineSnapshot('"error"');
-    expect(() =>
-      assertTrue(false, 'error')
-    ).toThrowErrorMatchingInlineSnapshot('"error"');
-  });
-});
-
-describe('assertFalse', () => {
-  it('returns value', () => {
-    expect(assertFalse(false, 'error')).toBe(false);
-  });
-
-  it('throws on not false', () => {
-    expect(() =>
-      assertFalse(undefined, 'error')
-    ).toThrowErrorMatchingInlineSnapshot('"error"');
-    expect(() =>
-      assertFalse(3, 'error')
-    ).toThrowErrorMatchingInlineSnapshot('"error"');
-    expect(() =>
-      assertFalse(true, 'error')
-    ).toThrowErrorMatchingInlineSnapshot('"error"');
-  });
-});
-
-describe('assertString', () => {
-  it('returns value', () => {
-    expect(assertString('string')).toBe('string');
-  });
-
-  it('throws on undefined', () => {
-    expect(() =>
-      assertString(undefined, new Error('cool error'))
-    ).toThrowErrorMatchingInlineSnapshot('"cool error"');
-  });
-
-  it('throws on not a string', () => {
-    expect(() =>
-      assertString(5, () => { throw new Error('cool error'); })
-    ).toThrowErrorMatchingInlineSnapshot('"cool error"');
-  });
-});
-
-describe('assertInstanceOf', () => {
-  it('returns value cast to the correct type, or throws if the value is not an instanceof the constructor', () => {
-    class A {}
-    class B extends A {
-      // This property makes it so type A cannot be assigned to type B
-      someProp = true;
-    }
-
-    const a = new A;
-    const b = new B;
-
-    // We call these methods just to verify the returned types are correct
-    const acceptsA = (a: A) => a;
-    const acceptsB = (b: B) => b;
-
-    expect(acceptsA(assertInstanceOf(a, A, 'not instanceof'))).toBe(a);
-    expect(acceptsA(assertInstanceOf(b, A, 'not instanceof'))).toBe(b);
-    expect(acceptsA(assertInstanceOf(b as A, A, 'not instanceof'))).toBe(b);
-    expect(() => acceptsA(assertInstanceOf(a, B, 'not instanceof'))).toThrow('not instanceof');
-    expect(acceptsA(assertInstanceOf(b, B, 'not instanceof'))).toBe(b);
-    expect(acceptsA(assertInstanceOf(b as A, B, 'not instanceof'))).toBe(b);
-
-    expect(() => acceptsB(assertInstanceOf(a, B, 'not instanceof'))).toThrow('not instanceof');
-    expect(acceptsB(assertInstanceOf(b, B, 'not instanceof'))).toBe(b);
-    expect(acceptsB(assertInstanceOf(b as A, B, 'not instanceof'))).toBe(b);
-  });
-});
-
-describe('assertErrorInstanceOf', () => {
-  it('works with Error and subclasses, rethrows original argument if check fails', () => {
-    const syntaxError = new SyntaxError;
-    const error = new Error;
-    expect(assertErrorInstanceOf(syntaxError, SyntaxError)).toBe(syntaxError);
-    expect(() => assertErrorInstanceOf(error, SyntaxError)).toThrow(error);
-  });
-
-  it('throws an Error if original argument is not an instance of Error', () => {
-    const error = 'I am Error';
-    expect(() => assertErrorInstanceOf(error, SyntaxError)).toThrow(
-      `assertErrorInstanceOf received non-Error argument of type "${
-        typeof error}" and string representation "${error}"`
-    );
-    expect(() => assertErrorInstanceOf(error as unknown, SyntaxError)).toThrow(
-      `assertErrorInstanceOf received non-Error argument of type "${
-        typeof error}" and string representation "${error}"`
-    );
-  });
-});

package/packages/utils/src/aws/ssmService.ts

@@ -1,7 +0,0 @@
-import {SSM} from '@aws-sdk/client-ssm';
-import { once } from '..';
-
-/**
- * A memoized instance of the AWS SSM client.
- */
-export const ssmService = once(() => new SSM({apiVersion: '2012-08-10'}));

package/packages/utils/src/config/awsParameterConfig.ts

@@ -1,24 +0,0 @@
-import {GetParameterCommand} from '@aws-sdk/client-ssm';
-import { assertDefined } from '../assertions';
-import { ssmService } from '../aws/ssmService';
-import { resolveConfigValue } from './resolveConfigValue';
-import { ConfigValueProvider } from '.';
-
-/**
- * Returns a value from the AWS Parameter Store.
- *
- * @param parameterName the name of the parameter; can be a literal name (string) or can itself
- * be accessed via another parameter by giving a configuration value provider.
- * @example const someValue = resolveConfig(awsParameterConfig('some-parameter-name'));
- * @returns the configuration value provider for the value
- */
-export const awsParameterConfig = (parameterName: ConfigValueProvider<string>): ConfigValueProvider<string> => {
-  return async() => {
-    const command = new GetParameterCommand({Name: await resolveConfigValue(parameterName), WithDecryption: true});
-    // send() throws ParameterNotFound if the parameter is missing,
-    // so it's not clear what missing Parameter or Value mean
-    const response = await ssmService().send(command);
-    const parameter = assertDefined(response.Parameter, `aws GetParameter response missing Parameter key for ${parameterName}"`);
-    return assertDefined(parameter.Value, `aws GetParameter response missing Parameter.Value key for ${parameterName}"`);
-  };
-};

package/packages/utils/src/config/envConfig.ts

@@ -1,58 +0,0 @@
-import { resolveConfigValue } from './resolveConfigValue';
-import type { ConfigValueProvider } from '.';
-
-/**
- * A list of environment variables that were requested at build time. Used by webpack to
- * capture build-time environment variables values.
- */
-export const ENV_BUILD_CONFIGS: string[] = [];
-
-/**
- * Returns an environment variable from the process environment. Depending on the `type` in the
- * call to get the variable, the variable's value may be what it was at build time, not at runtime.
- * The return value is not the variable value itself, but rather a provider that has to be called
- * to read the variable value (meaning, this is safe to call even if the variable doesn't exist,
- * because someone else later needs to call the provider to get the value -- that call may explode,
- * but this one won't).
- *
- * @param name The name of the environment variable to retrieve.
- * @param type The mode for accessing the variable. Defaults to `'build'`, i.e. getting the
- * variable as it was set at build time (webpack is connected here to make this possible). This
- * argument can also be `'runtime'` in which case the value at build time is ignored and the
- * variable is pulled live from `process.env`.
- * @param [defaultValue] The default value to use if the variable is not found.
- *
- * @example const config = { configValue: envConfig('environment_variable_name') };
- */
-export const envConfig = (
-  name: string, type?: 'build' | 'runtime', defaultValue?: ConfigValueProvider<string>
-): ConfigValueProvider<string> => {
-  // this doesn't use a default parameter value because of a:
-  //   "Regular parameters should not come after default parameters."
-  // error that occurs when the defaultValue optional default of `undefined`
-  // gets optimized out, causing a problem in cloudfront functions.
-  type ??= 'build';
-
-  if (type === 'build') {
-    ENV_BUILD_CONFIGS.push(name);
-  }
-  return (): string | Promise<string> => {
-    /*global __PROCESS_ENV*/
-    // @ts-ignore - hack to get around the way webpack/define works
-    // - https://github.com/webpack/webpack/issues/14800
-    // - https://github.com/webpack/webpack/issues/5392
-    // also, spread operator not supported in cloudfront functions
-    const envs: typeof process.env = Object.assign({}, process.env, typeof __PROCESS_ENV !== 'undefined' ? __PROCESS_ENV : {});
-    const value = envs[name];
-
-    if (value === undefined) {
-      if (defaultValue === undefined) {
-        throw new Error(`expected to find environment variable with name: ${name}`);
-      } else {
-        return resolveConfigValue(defaultValue);
-      }
-    } else {
-      return value;
-    }
-  };
-};

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

@@ -1,165 +0,0 @@
-import { ParameterNotFound, SSM } from '@aws-sdk/client-ssm';
-import fetch from 'node-fetch';
-import { awsParameterConfig, ENV_BUILD_CONFIGS, envConfig, lambdaParameterConfig, replaceConfig, resolveConfigValue, stubConfig } from '.';
-
-jest.mock('@aws-sdk/client-ssm', () => {
-  const sendSpy = jest.fn(() => Promise.resolve()) as any;
-  return {
-    ...jest.requireActual('@aws-sdk/client-ssm'),
-    SSM: class {
-      static sendSpy = sendSpy;
-      send(...a: any[]) { return sendSpy(...a); }
-    }
-  };
-});
-
-jest.mock('node-fetch', jest.fn);
-
-afterEach(() => {
-  jest.clearAllMocks();
-});
-
-describe('envConfig', () => {
-  it('collects build configs', () => {
-    envConfig('build config');
-    expect(ENV_BUILD_CONFIGS).toContain('build config');
-  });
-
-  it('ignores runtime configs', () => {
-    envConfig('runtime config', 'runtime');
-    expect(ENV_BUILD_CONFIGS).not.toContain('runtime config');
-  });
-
-  it('returns config value', async() => {
-    process.env.MY_COOL_CONFIG = 'cool';
-    expect(await resolveConfigValue(envConfig('MY_COOL_CONFIG'))).toBe('cool');
-  });
-
-  it('uses __PROCESS_ENV', async() => {
-    (global as any).__PROCESS_ENV = {MY_COOL_CONFIG_2: 'cool2'};
-    expect(await resolveConfigValue(envConfig('MY_COOL_CONFIG_2'))).toBe('cool2');
-  });
-
-  it('returns defaultValue if env variable is absent', async() => {
-    expect(
-      await resolveConfigValue(envConfig('MY_COOL_CONFIG_3', 'runtime', 'cool3'))
-    ).toBe('cool3');
-  });
-
-  it('works with any ConfigValueProvider<string> as a defaultValue', async() => {
-    expect(
-      await resolveConfigValue(envConfig('MY_COOL_CONFIG_3', 'runtime', () => Promise.resolve('cool4')))
-    ).toBe('cool4');
-  });
-
-  it('throws an error if the env variable is undefined and there is no defaultValue', async() => {
-    await expect(resolveConfigValue(envConfig('MY_UNCOOL_CONFIG', 'runtime'))).rejects.toThrow(
-      'expected to find environment variable with name: MY_UNCOOL_CONFIG'
-    );
-  });
-});
-
-describe('resolveConfigValue', () => {
-  it('resolves string', async() => {
-    expect(await resolveConfigValue('asdf')).toBe('asdf');
-  });
-  it('resolves function', async() => {
-    expect(await resolveConfigValue(() => 'asdf')).toBe('asdf');
-  });
-  it('resolves promise function', async() => {
-    expect(await resolveConfigValue(() => Promise.resolve('asdf'))).toBe('asdf');
-  });
-});
-
-describe('awsParameterConfig', () => {
-  const sendSpy: jest.SpyInstance = (SSM as any).sendSpy;
-
-  it('resolves parameter', async() => {
-    sendSpy.mockReturnValueOnce(Promise.resolve({Parameter: {Value: 'parameterValue'}}));
-    expect(await resolveConfigValue(awsParameterConfig('parameterName'))).toBe('parameterValue');
-    expect(sendSpy).toHaveBeenCalledWith(
-      expect.objectContaining({input: {Name: 'parameterName', WithDecryption: true}})
-    );
-  });
-
-  it('throws when parameter is not found', async() => {
-    sendSpy.mockImplementationOnce(async() => {throw new ParameterNotFound({$metadata: {}});});
-    await expect(
-      resolveConfigValue(awsParameterConfig('parameterName'))
-    ).rejects.toThrow(ParameterNotFound);
-    expect(sendSpy).toHaveBeenCalledWith(
-      expect.objectContaining({input: {Name: 'parameterName', WithDecryption: true}})
-    );
-  });
-});
-
-describe('lambdaParameterConfig', () => {
-  const fetchSpy = fetch as unknown as jest.SpyInstance;
-
-  beforeAll(() => {
-    fetchSpy.mockReturnValueOnce(Promise.resolve());
-    process.env['AWS_SESSION_TOKEN'] = 'someToken';
-  });
-
-  afterAll(() => delete process.env['AWS_SESSION_TOKEN']);
-
-  it('resolves parameter', async() => {
-    fetchSpy.mockReturnValueOnce(
-      Promise.resolve(
-        { ok: true, json: () => Promise.resolve({ Parameter: { Value: 'parameterValue' } }) }
-      )
-    );
-    expect(
-      await resolveConfigValue(lambdaParameterConfig(async() => 'parameterName'))
-    ).toBe('parameterValue');
-    expect(fetchSpy).toHaveBeenCalledWith(
-      'http://localhost:2773/systemsmanager/parameters/get?name=parameterName&withDecryption=true',
-      { headers: { 'X-Aws-Parameters-Secrets-Token': 'someToken' } }
-    );
-  });
-
-  it('throws when parameter is not found', async() => {
-    fetchSpy.mockReturnValueOnce(
-      Promise.resolve({ ok: false, status: 404, statusText: 'Not Found' })
-    );
-    await expect(
-      resolveConfigValue(lambdaParameterConfig(async() => 'parameterName'))
-    ).rejects.toThrow('HTTP Error Response');
-    expect(fetchSpy).toHaveBeenCalledWith(
-      'http://localhost:2773/systemsmanager/parameters/get?name=parameterName&withDecryption=true',
-      { headers: { 'X-Aws-Parameters-Secrets-Token': 'someToken' } }
-    );
-  });
-});
-
-describe('stubConfig', () => {
-  it('stubs', async() => {
-    expect(await resolveConfigValue(stubConfig('stubbed'))).toBe('stubbed');
-  });
-});
-
-describe('replaceConfig', () => {
-  it('replaces string', async() => {
-    const result = replaceConfig('base [token] value', {
-      '[token]': 'replaced'
-    });
-
-    expect(await resolveConfigValue(result)).toBe('base replaced value');
-  });
-
-  it('replaces with async values', async() => {
-    const result = replaceConfig('base [token] value', {
-      '[token]': stubConfig('replaced')
-    });
-
-    expect(await resolveConfigValue(result)).toBe('base replaced value');
-  });
-
-  it('replaces with async base', async() => {
-    const result = replaceConfig(stubConfig('base [token] value'), {
-      '[token]': stubConfig('replaced')
-    });
-
-    expect(await resolveConfigValue(result)).toBe('base replaced value');
-  });
-});

package/packages/utils/src/config/lambdaParameterConfig.ts

@@ -1,49 +0,0 @@
-import type { GetParameterCommandOutput } from '@aws-sdk/client-ssm';
-import fetch from 'node-fetch';
-import { assertDefined } from '../assertions';
-import { retryWithDelay } from '../misc/helpers';
-import { envConfig } from './envConfig';
-import { ConfigValueProvider, resolveConfigValue } from '.';
-
-const lambdaExtensionUrl = 'http://localhost:2773';
-let lambdaExtensionReadyPromise: Promise<unknown>;
-
-/**
- * Returns a value from the AWS Parameter Store. Can only be used during in AWS Lambda, and
- * requires that the AWS Parameters and Secrets Lambda Extension Layer be included in the Lambda.
- * This extension has built-in caching for requested parameters.
- *
- * @param parameterName the name of the parameter; can be a literal name (string) or can itself
- * be accessed via another parameter by giving a configuration value provider.
- * @example const someValue = resolveConfig(lambdaParameterConfig('some-parameter-name'));
- * @returns the configuration value provider for the value
- */
-export const lambdaParameterConfig = (parameterName: ConfigValueProvider<string>): ConfigValueProvider<string> => async() => {
-  const token = await resolveConfigValue(envConfig('AWS_SESSION_TOKEN', 'runtime'));
-  const name = await resolveConfigValue(parameterName);
-
-  if (!lambdaExtensionReadyPromise) {
-    // This request will return 400 Bad Request,
-    // but we only care that it'll block until the extension is ready
-    lambdaExtensionReadyPromise = retryWithDelay(() => fetch(lambdaExtensionUrl));
-  }
-  await lambdaExtensionReadyPromise;
-
-  const resp = await retryWithDelay(() => fetch(
-    // Port 2773 is the default port for the extension
-    `${lambdaExtensionUrl}/systemsmanager/parameters/get?name=${name}&withDecryption=true`,
-    { headers: { 'X-Aws-Parameters-Secrets-Token': token } }
-  ));
-
-  if (resp.ok) {
-    const response = await resp.json() as GetParameterCommandOutput;
-    const parameter = assertDefined(
-      response.Parameter, `aws GetParameter response missing Parameter key for ${name}"`
-    );
-    return assertDefined(parameter.Value, `aws GetParameter response missing Parameter.Value key for ${name}"`);
-  } else {
-    throw new Error(
-      `HTTP Error Response ${resp.status} ${resp.statusText} while fetching parameter ${name}`
-    );
-  }
-};

package/packages/utils/src/config/resolveConfigValue.ts

@@ -1,10 +0,0 @@
-import type { ConfigValue, ConfigValueProvider } from '.';
-
-/**
- * resolves a config value into a string, to be used inside of things that are provided configurations
- */
-export const resolveConfigValue = async<V extends ConfigValue>(provider: ConfigValueProvider<V>): Promise<V> => {
-  return typeof provider === 'function'
-    ? await provider()
-    : provider;
-};

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

@@ -1,35 +0,0 @@
-import { ConflictError, ForbiddenError, InvalidRequestError, NotFoundError, SessionExpiredError, UnauthorizedError } from '.';
-
-describe('errorIsType', () => {
-  it('returns true for same error type', () => {
-    expect(InvalidRequestError.matches(new InvalidRequestError())).toBe(true);
-  });
-  it('returns false for different error type', () => {
-    expect(InvalidRequestError.matches(new UnauthorizedError())).toBe(false);
-  });
-  it('returns false random input', () => {
-    expect(InvalidRequestError.matches(new Error())).toBe(false);
-    expect(InvalidRequestError.matches('asdf')).toBe(false);
-  });
-});
-
-describe('custom error constructors', () => {
-  it('use TYPE as default message', () => {
-    expect(new InvalidRequestError().message).toBe(InvalidRequestError.TYPE);
-    expect(new UnauthorizedError().message).toBe(UnauthorizedError.TYPE);
-    expect(new ForbiddenError().message).toBe(ForbiddenError.TYPE);
-    expect(new NotFoundError().message).toBe(NotFoundError.TYPE);
-    expect(new SessionExpiredError().message).toBe(SessionExpiredError.TYPE);
-    expect(new ConflictError().message).toBe(ConflictError.TYPE);
-  });
-
-  it('allow custom messages', () => {
-    const customMessage = 'Some Error';
-    expect(new InvalidRequestError(customMessage).message).toBe(customMessage);
-    expect(new UnauthorizedError(customMessage).message).toBe(customMessage);
-    expect(new ForbiddenError(customMessage).message).toBe(customMessage);
-    expect(new NotFoundError(customMessage).message).toBe(customMessage);
-    expect(new SessionExpiredError(customMessage).message).toBe(customMessage);
-    expect(new ConflictError(customMessage).message).toBe(customMessage);
-  });
-});

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

@@ -1,197 +0,0 @@
-import { fetchStatusRetry } from './fetchStatusRetry';
-import { Response } from '.';
-
-describe('fetchStatusRetry', () => {
-  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('fetches normally', async() => {
-    const base = jest.fn();
-    const withRetry = fetchStatusRetry(base, {status: [502], retries: 7});
-
-    const response: Response = {
-      status: 200,
-      headers: {get: () => 'application/json'},
-      json: () => Promise.resolve({}),
-      text: () => Promise.resolve('some error')
-    };
-
-    base.mockReturnValue(Promise.resolve(response));
-
-    expect(await withRetry('/some/url')).toBe(response);
-    expect(base).toHaveBeenCalledTimes(1);
-  });
-
-  it('fetches normally with no statuses', async() => {
-    const base = jest.fn();
-    const withRetry = fetchStatusRetry(base, {retries: 7});
-
-    const response: Response = {
-      status: 200,
-      headers: {get: () => 'application/json'},
-      json: () => Promise.resolve({}),
-      text: () => Promise.resolve('some error')
-    };
-
-    base.mockReturnValue(Promise.resolve(response));
-
-    expect(await withRetry('/some/url')).toBe(response);
-    expect(base).toHaveBeenCalledTimes(1);
-  });
-
-  it('retries on bad status', async() => {
-    const base = jest.fn();
-    const withRetry = fetchStatusRetry(base, {status: [502], retries: 7});
-
-    base.mockReturnValueOnce(Promise.resolve({
-      status: 502,
-      headers: {get: () => 'application/json'},
-      json: () => Promise.resolve({}),
-      text: () => Promise.resolve('some error')
-    }));
-
-    const response: Response = {
-      status: 200,
-      headers: {get: () => 'application/json'},
-      json: () => Promise.resolve({}),
-      text: () => Promise.resolve('some error')
-    };
-
-    base.mockReturnValue(Promise.resolve(response));
-
-    expect(await withRetry('/some/url')).toBe(response);
-    expect(base).toHaveBeenCalledTimes(2);
-  });
-
-  it('has limited retries', async() => {
-    const base = jest.fn();
-    const withRetry = fetchStatusRetry(base, {status: [502], retries: 1});
-
-    base.mockReturnValueOnce(Promise.resolve({
-      status: 502,
-      headers: {get: () => 'application/json'},
-      json: () => Promise.resolve({}),
-      text: () => Promise.resolve('some error')
-    }));
-    base.mockReturnValueOnce(Promise.resolve({
-      status: 502,
-      headers: {get: () => 'application/json'},
-      json: () => Promise.resolve({}),
-      text: () => Promise.resolve('some error')
-    }));
-
-    const response: Response = {
-      status: 200,
-      headers: {get: () => 'application/json'},
-      json: () => Promise.resolve({}),
-      text: () => Promise.resolve('some error')
-    };
-
-    base.mockReturnValue(Promise.resolve(response));
-
-    await expect(withRetry('/some/url')).rejects.toThrowErrorMatchingInlineSnapshot('"fetch failed /some/url -- 502: some error"');
-    expect(base).toHaveBeenCalledTimes(2);
-  });
-
-  it('retries on failed fetch', async() => {
-    const base = jest.fn();
-    const withRetry = fetchStatusRetry(base, {status: [502], retries: 7});
-
-    base.mockReturnValueOnce(Promise.reject(new Error('type error failed to fetch or whatever')));
-
-    const response: Response = {
-      status: 200,
-      headers: {get: () => 'application/json'},
-      json: () => Promise.resolve({}),
-      text: () => Promise.resolve('some error')
-    };
-
-    base.mockReturnValue(Promise.resolve(response));
-
-    expect(await withRetry('/some/url')).toBe(response);
-    expect(base).toHaveBeenCalledTimes(2);
-  });
-
-  it('has limited retries on failed to fetch', async() => {
-    const base = jest.fn();
-    const withRetry = fetchStatusRetry(base, {status: [502], retries: 1});
-
-    base.mockReturnValueOnce(Promise.reject(new Error('type error failed to fetch or whatever')));
-    base.mockReturnValueOnce(Promise.reject(new Error('type error failed to fetch or whatever')));
-
-    const response: Response = {
-      status: 200,
-      headers: {get: () => 'application/json'},
-      json: () => Promise.resolve({}),
-      text: () => Promise.resolve('some error')
-    };
-
-    base.mockReturnValue(Promise.resolve(response));
-
-    await expect(withRetry('/some/url')).rejects.toThrowErrorMatchingInlineSnapshot('"type error failed to fetch or whatever"');
-    expect(base).toHaveBeenCalledTimes(2);
-  });
-
-  describe('timeout functionality', () => {
-    beforeEach(() => {
-      setTimeoutSpy.mockRestore();
-      jest.useFakeTimers();
-    });
-
-    afterEach(() => {
-      jest.useRealTimers();
-      doBeforeEach();
-    });
-
-    it('fetches normally with timeout option but completes before timeout', async() => {
-      const base = jest.fn();
-      const withRetry = fetchStatusRetry(base, {status: [502], timeout: 1000, retries: 1});
-
-      const response: Response = {
-        status: 200,
-        headers: {get: () => 'application/json'},
-        json: () => Promise.resolve({}),
-        text: () => Promise.resolve('some error')
-      };
-
-      base.mockReturnValue(Promise.resolve(response));
-
-      const result = withRetry('/some/url');
-      expect(await result).toBe(response);
-      expect(base).toHaveBeenCalledTimes(1);
-    });
-
-    it('times out when request takes too long', async() => {
-      const base = jest.fn();
-      const withRetry = fetchStatusRetry(base, {timeout: 100, retries: 0});
-
-      const pendingPromise = new Promise(() => {});
-      base.mockReturnValue(pendingPromise);
-
-      const resultPromise = withRetry('/some/url');
-      
-      jest.advanceTimersByTime(100);
-      
-      await expect(resultPromise).rejects.toThrowErrorMatchingInlineSnapshot('"fetch timeout after 100ms: /some/url"');
-      expect(base).toHaveBeenCalledTimes(1);
-    });
-
-  });
-});