@openstax/ts-utils 1.34.0 → 1.34.1

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

@@ -1,553 +0,0 @@
-import { getKeyValue } from '..';
-import { InvalidRequestError, UnauthorizedError } from '../errors';
-import { makeComposeMiddleware } from '../middleware';
-import { apiHtmlResponse, apiJsonResponse, apiTextResponse, getHeader, getRequestBody, makeCreateRoute, makeGetRequestResponder, makeRenderRouteUrl, requestPayloadProvider, unsafePayloadValidator } from '../routing';
-import { createConsoleLogger } from '../services/logger/console';
-import { routesList } from '.';
-
-interface RouteRequest {
-  path: string;
-}
-interface RouteResponse {
-  body: string;
-}
-// ts weak type makes this fail if it has no properties
-type AppServices = {
-  asdf: string;
-};
-
-const composeMiddleware = makeComposeMiddleware<AppServices, {}>();
-const createRoute = makeCreateRoute<AppServices, RouteRequest, {}>();
-
-describe('getRequestBody', () => {
-  it('gets it', () => {
-    const request = {
-      headers: {
-        'content-type': 'application/json'
-      },
-      body: '{"foo":"bar"}'
-    };
-    expect(getRequestBody(request)).toEqual({foo: 'bar'});
-  });
-
-  it('defaults to empty object', () => {
-    const request = {
-      headers: {
-        'content-type': 'application/json'
-      },
-      body: ''
-    };
-    expect(getRequestBody(request)).toEqual({});
-  });
-
-  it('throws if json content type is not set', () => {
-    const request = {
-      headers: {
-        'content-type': 'application/text'
-      },
-      body: '{"foo":"bar"}'
-    };
-    expect(() => getRequestBody(request)).toThrow();
-  });
-
-  it('throws if content type is not set', () => {
-    const request = {
-      headers: {
-      },
-      body: '{"foo":"bar"}'
-    };
-    expect(() => getRequestBody(request)).toThrow();
-  });
-
-  it('throws if body is not valid json', () => {
-    const request = {
-      headers: {
-        'content-type': 'application/json'
-      },
-      body: 'foobar'
-    };
-    expect(() => getRequestBody(request)).toThrow();
-  });
-});
-
-describe('getRequestResponder', () => {
-  const services = {asdf: 'asdf'};
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('executes static route', () => {
-    const request = {
-      path: '/foo'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({
-      body: 'response to test route 1'
-    })});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path')
-    });
-    const result = getRequestResponder(services)(request);
-
-    expect(result?.body).toBe('response to test route 1');
-  });
-
-  it('uses route matcher', () => {
-    const request = {
-      path: '/foo'
-    };
-    const createRouteWithExtra = makeCreateRoute<AppServices, RouteRequest, {theOne: boolean}>();
-
-    const testRoute1 = createRouteWithExtra({name: 'test', theOne: false, path: '/foo', handler: () => ({
-      body: 'response to test route 1'
-    })});
-    const testRoute2 = createRouteWithExtra({name: 'test', theOne: true, path: '/foo', handler: () => ({
-      body: 'response to test route 2'
-    })});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute1 | typeof testRoute2, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute1, testRoute2]),
-      routeMatcher: (_request, route) => route.theOne,
-      pathExtractor: getKeyValue('path')
-    });
-    const result = getRequestResponder(services)(request);
-
-    expect(result?.body).toBe('response to test route 2');
-  });
-
-  it('executes parameterized route', () => {
-    const request = {
-      path: '/foo/some-path'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo/:part', handler: (params: {part: string}) => ({
-      body: 'response to test route 2: ' + params.part
-    })});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path')
-    });
-
-    const result = getRequestResponder(services)(request);
-
-    expect(result?.body).toBe('response to test route 2: some-path');
-  });
-
-  it('returns undefined for unknown route', () => {
-    const request = {
-      path: '/foobar'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({
-      body: 'response to test route 1'
-    })});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path')
-    });
-
-    const result = getRequestResponder(services)(request);
-
-    expect(result).toBeUndefined();
-  });
-
-  it('rethrows errors without an error handler', () => {
-    const request = {
-      path: '/foo'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: (): RouteResponse => {
-      throw new UnauthorizedError();
-    }});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path')
-    });
-
-    expect(() => getRequestResponder(services)(request)).toThrow(UnauthorizedError);
-  });
-
-  it('rethrows errors with an error handler', () => {
-    const request = {
-      path: '/foo'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: (): RouteResponse => {
-      throw new UnauthorizedError();
-    }});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path'),
-      errorHandler: (e: Error) => {
-        throw e;
-      }
-    });
-
-    expect(() => getRequestResponder(services)(request)).toThrow(UnauthorizedError);
-  });
-
-  it('handles errors with an error handler', () => {
-    const request = {
-      path: '/foo'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: (): RouteResponse => {
-      throw new UnauthorizedError();
-    }});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path'),
-      errorHandler: (_e: Error) => {
-        return {body: 'handled'};
-      }
-    });
-
-    const result = getRequestResponder(services)(request);
-
-    expect(result?.body).toBe('handled');
-  });
-
-  it('handles async errors with an error handler', async() => {
-    const request = {
-      path: '/foo'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: async() => {
-      throw new UnauthorizedError();
-    }});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, Promise<RouteResponse>>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path'),
-      errorHandler: async(_e: Error) => {
-        return {body: 'handled'};
-      }
-    });
-
-    const result = await getRequestResponder(services)(request);
-
-    expect(result?.body).toBe('handled');
-  });
-
-  it('handles errors with middleware with an error handler', () => {
-    const request = {
-      path: '/foo'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: (): RouteResponse => {
-      throw new UnauthorizedError();
-    }});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path'),
-      errorHandler: (_e: Error) => {
-        return {body: 'handled'};
-      }
-    });
-
-    const result = getRequestResponder(services, () => (response) => response ? {body: `hello - ${response.body}`} : response)(request);
-
-    expect(result?.body).toBe('hello - handled');
-  });
-
-  it('handles async errors with middleware with an error handler', async() => {
-    const request = {
-      path: '/foo'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: async() => {
-      throw new UnauthorizedError();
-    }});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, Promise<RouteResponse>>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path'),
-      errorHandler: async(_e: Error) => {
-        return {body: 'handled'};
-      }
-    });
-
-    const result = await getRequestResponder(services, () => async(response) => {
-      const result = await response;
-      return result ? {body: `hello - ${result.body}`} : result;
-    })(request);
-
-    expect(result?.body).toBe('hello - handled');
-  });
-
-  it('handles errors from middleware with an error handler', () => {
-    const request = {
-      path: '/foo'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo',
-      requestServiceProvider: composeMiddleware(
-        () => (): {} => {
-          throw new Error();
-        }
-      )},
-      (): RouteResponse => {
-        return {body: 'asdf'};
-      }
-    );
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path'),
-      errorHandler: (_e: Error) => {
-        return {body: 'handled'};
-      }
-    });
-
-    const result = getRequestResponder(services)(request);
-
-    expect(result?.body).toBe('handled');
-  });
-
-  it('handles async errors from middleware with an error handler', async() => {
-    const request = {
-      path: '/foo'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo',
-      requestServiceProvider: composeMiddleware(
-        () => (): {} => {
-          throw new Error();
-        }
-      )},
-      async() => {
-        return {body: 'asdf'};
-      }
-    );
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, Promise<RouteResponse>>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path'),
-      errorHandler: async(_e: Error) => {
-        return {body: 'handled'};
-      }
-    });
-
-    const result = await getRequestResponder(services)(request);
-
-    expect(result?.body).toBe('handled');
-  });
-
-  it('rethrows errors from middleware without an error handler', () => {
-    const request = {
-      path: '/foo'
-    };
-
-    const requestServiceProvider = composeMiddleware(
-      () => (): {} => {
-        throw new UnauthorizedError();
-      }
-    );
-
-    const testRoute = createRoute({name: 'test', path: '/foo', requestServiceProvider, handler: (): RouteResponse => {
-      return {body: 'asdf'};
-    }});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path'),
-    });
-
-    expect(() => getRequestResponder(services)(request)).toThrow(UnauthorizedError);
-  });
-
-  it('rethrows errors from middleware with an error handler', () => {
-    const request = {
-      path: '/foo'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: (): RouteResponse => {
-      throw new UnauthorizedError();
-    }});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path'),
-      errorHandler: (e: Error) => {
-        throw e;
-      }
-    });
-
-    expect(() => getRequestResponder(services)(request)).toThrow(UnauthorizedError);
-  });
-
-  it('uses middleware on route response', () => {
-    const request = {
-      path: '/foo'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({
-      body: 'response to test route 1'
-    })});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path'),
-    });
-
-    const result = getRequestResponder(services, () => (response) => response ? {body: `hello - ${response.body}`} : response)(request);
-
-    expect(result?.body).toBe('hello - response to test route 1');
-  });
-
-  it('uses middleware on unknown response', () => {
-    const request = {
-      path: '/foobar'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({
-      body: 'response to test route 1'
-    })});
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      pathExtractor: getKeyValue('path'),
-    });
-
-    const result = getRequestResponder(services, () => (response) => response ? response : 'default')(request);
-
-    expect(result).toBe('default');
-  });
-
-  it('attaches request context to logger', () => {
-    const request = {
-      path: '/foo'
-    };
-
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({
-      body: 'response to test route 1'
-    })});
-
-    const logger = createConsoleLogger();
-    const subContext = logger.createSubContext();
-    const setContextSpy = jest.spyOn(logger, 'setContext');
-    jest.spyOn(logger, 'createSubContext').mockReturnValue(subContext);
-    const setSubContextSpy = jest.spyOn(subContext, 'setContext');
-
-    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
-      routes: () => ([testRoute]),
-      logExtractor: request => ({path: request.path}),
-      pathExtractor: getKeyValue('path')
-    });
-    getRequestResponder({...services, logger})(request);
-
-    expect(setContextSpy).not.toHaveBeenCalled();
-    expect(setSubContextSpy).toHaveBeenCalledWith({path: '/foo'});
-  });
-});
-
-describe('getHeader', () => {
-  it('ignores multi-value headers', () => {
-    expect(getHeader({headerKey: ['value1', 'value2']}, 'headerKey')).toBe('value1');
-  });
-});
-
-describe('renderRouteUrl', () => {
-  it('renders routes', () => {
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({body: 'asdf'})});
-    const renderRouteUrl = makeRenderRouteUrl<typeof testRoute>();
-
-    expect(renderRouteUrl(testRoute, undefined)).toBe('/foo');
-  });
-
- it('renders routes with params', () => {
-    const testRoute = createRoute({name: 'test', path: '/foo/:part', handler: (_param: {part: string}) => ({body: 'asdf'})});
-    const renderRouteUrl = makeRenderRouteUrl<typeof testRoute>();
-
-    expect(renderRouteUrl(testRoute, {part: 'foo'})).toBe('/foo/foo');
-  });
-
-  it('renders routes with query', () => {
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({body: 'asdf'})});
-    const renderRouteUrl = makeRenderRouteUrl<typeof testRoute>();
-
-    expect(renderRouteUrl(testRoute, undefined, {param: 'someParam'})).toBe('/foo?param=someParam');
-  });
-});
-
-describe('apiJsonResponse', () => {
-  it('makes a response', () => {
-    expect(apiJsonResponse(200, {key: 'value'})).toEqual({
-      statusCode: 200,
-      data: {key: 'value'},
-      body: '{"key":"value"}',
-      headers: {'content-type': 'application/json'}
-    });
-  });
-});
-
-describe('apiTextResponse', () => {
-  it('makes a response', () => {
-    expect(apiTextResponse(200, 'some text')).toEqual({
-      statusCode: 200,
-      data: 'some text',
-      body: 'some text',
-      headers: {'content-type': 'text/plain'}
-    });
-  });
-});
-
-describe('apiHtmlResponse', () => {
-  it('makes a response', () => {
-    expect(apiHtmlResponse(200, 'some text')).toEqual({
-      statusCode: 200,
-      data: 'some text',
-      body: 'some text',
-      headers: {'content-type': 'text/html'}
-    });
-  });
-});
-
-describe('requestPayloadProvider', () => {
-  it('provides a payload', () => {
-    const provider = requestPayloadProvider(unsafePayloadValidator<{key: string}>());
-    const {payload} = provider()({
-      request: {headers: {'content-type': 'application/json'}, body: '{"key":"string"}'}
-    });
-
-    expect(payload).toEqual({key: 'string'});
-  });
-
-  it('doesn\'t fuss with type', () => {
-    const request = {otherRequestValue: 'someValue', headers: {'content-type': 'application/json'}, body: '{"key":"string"}'};
-    const composeMiddleware = makeComposeMiddleware<{}, {request: typeof request}>();
-    const provider = requestPayloadProvider(unsafePayloadValidator<{key: string}>());
-    const result = composeMiddleware(provider)({})({request});
-
-    expect(result.request.otherRequestValue).toBe('someValue');
-  });
-
-  it('throws when validator fails', () => {
-    const validatorThatFails = (_input: any): _input is {key: string} => false;
-
-    const provider = requestPayloadProvider(validatorThatFails);
-
-    expect(() =>
-      provider()({
-        request: {headers: {'content-type': 'application/json'}, body: '{"key":"string"}'}
-      })
-    ).toThrow(InvalidRequestError);
-  });
-});
-
-describe('routesList', () => {
-  it ('returns route list', () => {
-    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({body: 'asdf'})});
-    const list = routesList([testRoute]);
-    expect(list[0]).toBe(testRoute);
-  });
-});