lesgo 0.7.8 → 2.1.0

package/src/middlewares/__tests__/gzipHttpResponse.spec.js

@@ -1,185 +0,0 @@
-import {
-  determineRequestAcceptEncoding,
-  determineRequestOrigin,
-  gzip,
-  gzipHttpResponse,
-} from '../gzipHttpResponse';
-
-describe('test gzipHttpResponse determineRequestOrigin', () => {
-  it('should return APIGATEWAY by default', () => {
-    const handler = { event: { requestContext: {} } };
-
-    expect(determineRequestOrigin(handler)).toEqual('APIGATEWAY');
-  });
-
-  it('should return ELB when requestContext has property elb', () => {
-    const handler = { event: { requestContext: { elb: {} } } };
-
-    expect(determineRequestOrigin(handler)).toEqual('ELB');
-  });
-
-  it('should return APIGATEWAY when requestContext has property apiId', () => {
-    const handler = { event: { requestContext: { apiId: 'asd-123' } } };
-
-    expect(determineRequestOrigin(handler)).toEqual('APIGATEWAY');
-  });
-});
-
-describe('test gzipHttpResponse determineRequestAcceptEncoding', () => {
-  it('should return false when no Accept-Encoding header exists', () => {
-    const handler = { event: { headers: {} } };
-
-    expect(determineRequestAcceptEncoding(handler)).toBeFalsy();
-  });
-
-  it('should return true when Accept-Encoding header exists with gzip', () => {
-    const handler = { event: { headers: { 'Accept-Encoding': 'gzip' } } };
-
-    expect(determineRequestAcceptEncoding(handler)).toBeTruthy();
-  });
-
-  it('should return true when Accept-encoding header exists with gzip', () => {
-    const handler = { event: { headers: { 'Accept-encoding': 'gzip' } } };
-
-    expect(determineRequestAcceptEncoding(handler)).toBeTruthy();
-  });
-
-  it('should return true when accept-encoding header exists with gzip', () => {
-    const handler = { event: { headers: { 'accept-encoding': 'gzip' } } };
-
-    expect(determineRequestAcceptEncoding(handler)).toBeTruthy();
-  });
-
-  it('should return true when Accept-Encoding header exists with Multiple algorithms containing gzip', () => {
-    const handler = {
-      event: { headers: { 'Accept-Encoding': 'deflate, gzip' } },
-    };
-
-    expect(determineRequestAcceptEncoding(handler)).toBeTruthy();
-  });
-
-  // FIXME: Currently this is not being handled
-  // it('should return true when Accept-Encoding header exists with Multiple algorithms containing gzip, weighted with the quality value syntax', () => {
-  //   const handler = {
-  //     event: { headers: { 'Accept-Encoding': 'deflate, gzip;q=1.0, *;q=0.5' } },
-  //   };
-
-  //   expect(determineRequestAcceptEncoding(handler)).toBeTruthy();
-  // });
-
-  it('should return false when Accept-Encoding header exists with other than gzip', () => {
-    const handler = { event: { headers: { 'Accept-Encoding': 'compress' } } };
-
-    expect(determineRequestAcceptEncoding(handler)).toBeFalsy();
-  });
-});
-
-describe('test gzipHttpResponse gzip', () => {
-  it('should return gzipped data with necessary headers', async () => {
-    const response = {
-      body: JSON.stringify({ someKey: 'someValue' }),
-    };
-    // const gzippedBody = 'H4sIAAAAAAAAE6tWKs7PTfVOrVSyArPCEnNKU5VqASj48/MXAAAA';
-
-    const resp = await gzip(response);
-    // expect(resp.body).toEqual(gzippedBody);
-    expect(resp.isBase64Encoded).toBeTruthy();
-    expect(resp.headers['Content-Encoding']).toEqual('gzip');
-  });
-
-  it('should return zlib.gzip error when passing non-string object', async () => {
-    const response = {
-      body: { someKey: 'someValue' },
-    };
-
-    try {
-      const resp = await gzip(response);
-      expect(resp).toThrow();
-    } catch (err) {
-      expect(err.name).toEqual('LesgoException');
-      expect(err.code).toEqual('GZIP_LIB_ERROR');
-    }
-  });
-});
-
-describe('test gzipHttpResponse gzipHttpResponse', () => {
-  it('should return gzipped response for ELB requests', async () => {
-    const handler = {
-      event: {
-        headers: { 'accept-encoding': 'gzip' },
-        requestContext: { elb: {} },
-      },
-      response: {
-        body: JSON.stringify({ someKey: 'someValue' }),
-      },
-    };
-
-    // const gzippedBody = 'H4sIAAAAAAAAE6tWKs7PTfVOrVSyArPCEnNKU5VqASj48/MXAAAA';
-
-    const handlerResp = await gzipHttpResponse(handler);
-
-    // expect(handlerResp.body).toEqual(gzippedBody);
-    expect(handlerResp.isBase64Encoded).toBeTruthy();
-    expect(handlerResp.headers['Content-Encoding']).toEqual('gzip');
-  });
-
-  it('should return non-gzipped response for API Gateway requests', async () => {
-    const handler = {
-      event: {
-        headers: { 'accept-encoding': 'gzip' },
-        requestContext: { apiId: 'asd-123' },
-      },
-      response: {
-        body: JSON.stringify({ someKey: 'someValue' }),
-      },
-    };
-
-    const handlerResp = await gzipHttpResponse(handler);
-
-    expect(handlerResp.body).toEqual(handler.response.body);
-    expect(handlerResp.isBase64Encoded).toBeUndefined();
-    expect(handlerResp.headers).toBeUndefined();
-  });
-
-  it('should return gzipped response for ELB requests from options', async () => {
-    const handler = {
-      event: {
-        headers: { 'accept-encoding': 'gzip' },
-        requestContext: { elb: {} },
-      },
-      response: {
-        body: JSON.stringify({ someKey: 'someValue' }),
-      },
-    };
-
-    // const gzippedBody = 'H4sIAAAAAAAAE6tWKs7PTfVOrVSyArPCEnNKU5VqASj48/MXAAAA';
-
-    const handlerResp = await gzipHttpResponse(handler, {
-      zipWhenRequest: ['ELB'],
-    });
-
-    // expect(handlerResp.body).toEqual(gzippedBody);
-    expect(handlerResp.isBase64Encoded).toBeTruthy();
-    expect(handlerResp.headers['Content-Encoding']).toEqual('gzip');
-  });
-
-  it('should return non-gzipped response for ELB requests with custom non-elb option', async () => {
-    const handler = {
-      event: {
-        headers: { 'accept-encoding': 'gzip' },
-        requestContext: { elb: {} },
-      },
-      response: {
-        body: JSON.stringify({ someKey: 'someValue' }),
-      },
-    };
-
-    const handlerResp = await gzipHttpResponse(handler, {
-      zipWhenRequest: ['apiId'],
-    });
-
-    expect(handlerResp.body).toEqual(handler.response.body);
-    expect(handlerResp.isBase64Encoded).toBeUndefined();
-    expect(handlerResp.headers).toBeUndefined();
-  });
-});

package/src/middlewares/__tests__/httpNoOutputMiddleware.spec.js

@@ -1,199 +0,0 @@
-import app from 'Config/app'; // eslint-disable-line import/no-unresolved
-import {
-  successHttpNoOutputResponseAfterHandler,
-  errorHttpNoOutputResponseAfterHandler,
-} from '../httpNoOutputMiddleware';
-
-describe('MiddlewareGroup: test successHttpNoOutputResponseAfterHandler', () => {
-  it('should have no body without debug', async () => {
-    const handler = {
-      response: {},
-      event: {},
-    };
-
-    await successHttpNoOutputResponseAfterHandler(handler, () => {}, {
-      response: 'Some message',
-    });
-    expect(handler.response).toHaveProperty('statusCode', 200);
-    expect(handler.response).toHaveProperty('body', null);
-  });
-
-  it('should return the body when debug is enabled via query string parameters', async () => {
-    const handler = {
-      response: {},
-      event: {
-        queryStringParameters: {
-          debug: '1',
-        },
-        someEventKey: 'someEventValue',
-      },
-    };
-
-    await successHttpNoOutputResponseAfterHandler(handler, () => {}, {
-      response: 'Some message',
-    });
-    expect(handler.response).toHaveProperty('statusCode', 200);
-    expect(handler.response).toHaveProperty(
-      'body',
-      JSON.stringify({
-        status: 'success',
-        data: 'Some message',
-        _meta: {},
-      })
-    );
-  });
-
-  it('should have null body even when enabled when configuration has is disabled', async () => {
-    app.debug = false;
-
-    const handler = {
-      response: {},
-      event: {
-        queryStringParameters: {
-          debug: '1',
-        },
-        someEventKey: 'someEventValue',
-      },
-    };
-
-    await successHttpNoOutputResponseAfterHandler(handler, () => {}, {
-      response: 'Some message',
-    });
-    expect(handler.response).toHaveProperty('statusCode', 200);
-    expect(handler.response).toHaveProperty('body', null);
-    app.debug = true;
-  });
-
-  it('should return a response when allowResponse override is passed via options', async () => {
-    app.debug = false;
-
-    const handler = {
-      response: {},
-      event: {
-        someEventKey: 'someEventValue',
-      },
-    };
-
-    await successHttpNoOutputResponseAfterHandler(handler, () => {}, {
-      response: 'Some message',
-      allowResponse: () => true,
-    });
-    expect(handler.response).toHaveProperty('statusCode', 200);
-    expect(handler.response).toHaveProperty(
-      'body',
-      JSON.stringify({
-        status: 'success',
-        data: 'Some message',
-        _meta: {},
-      })
-    );
-
-    app.debug = true;
-  });
-});
-
-describe('MiddlewareGroup: test errorHttpNoOutputResponseAfterHandler', () => {
-  it('should have no body without debug', async () => {
-    const handler = {
-      response: {},
-      event: {},
-    };
-
-    await errorHttpNoOutputResponseAfterHandler(handler, () => {}, {
-      error: new Error('Test validation error'),
-    });
-    expect(handler.response).toHaveProperty('statusCode', 200);
-    expect(handler.response).toHaveProperty('body', null);
-  });
-
-  it('should return the body when debug is enabled via query string parameters', async () => {
-    const handler = {
-      response: {},
-      event: {
-        queryStringParameters: {
-          debug: '1',
-        },
-        someEventKey: 'someEventValue',
-      },
-    };
-
-    await errorHttpNoOutputResponseAfterHandler(handler, () => {}, {
-      error: new Error('Test validation error'),
-    });
-    expect(handler.response).toHaveProperty('statusCode', 500);
-    expect(handler.response).toHaveProperty(
-      'body',
-      JSON.stringify({
-        status: 'error',
-        data: null,
-        error: {
-          code: 'UNHANDLED_ERROR',
-          message: 'Error: Test validation error',
-          details: '',
-        },
-        _meta: {
-          queryStringParameters: {
-            debug: '1',
-          },
-          someEventKey: 'someEventValue',
-        },
-      })
-    );
-  });
-
-  it('should have null body even when enabled when configuration has is disabled', async () => {
-    app.debug = false;
-
-    const handler = {
-      response: {},
-      event: {
-        queryStringParameters: {
-          debug: '1',
-        },
-        someEventKey: 'someEventValue',
-      },
-    };
-
-    await errorHttpNoOutputResponseAfterHandler(handler, () => {}, {
-      error: new Error('Test validation error'),
-    });
-    expect(handler.response).toHaveProperty('statusCode', 200);
-    expect(handler.response).toHaveProperty('body', null);
-    app.debug = true;
-  });
-
-  it('should return a response when allowResponse override is passed via options', async () => {
-    app.debug = false;
-
-    const handler = {
-      response: {},
-      event: {
-        queryStringParameters: {
-          debug: '1',
-        },
-        someEventKey: 'someEventValue',
-      },
-    };
-
-    await errorHttpNoOutputResponseAfterHandler(handler, () => {}, {
-      error: new Error('Test validation error'),
-      allowResponse: () => true,
-    });
-    expect(handler.response).toHaveProperty('statusCode', 500);
-    expect(handler.response).toHaveProperty(
-      'body',
-      JSON.stringify({
-        status: 'error',
-        data: null,
-        error: {
-          code: 'UNHANDLED_ERROR',
-          message: 'Error: Test validation error',
-          details: '',
-        },
-        _meta: {},
-      })
-    );
-
-    app.debug = false;
-  });
-});

package/src/middlewares/__tests__/normalizeHttpRequestMiddleware.spec.js

@@ -1,181 +0,0 @@
-import app from 'Config/app'; // eslint-disable-line import/no-unresolved
-import {
-  normalizeRequest,
-  normalizeHttpRequestBeforeHandler,
-} from '../normalizeHttpRequestMiddleware';
-import logger from '../../utils/logger';
-
-describe('MiddlewareGroup: test normalizeRequest', () => {
-  it('test with default parameters', () => {
-    const data = normalizeRequest({ headers: null, qs: null, body: null });
-    expect(data).toBe(null);
-  });
-
-  it('test with empty parameters from alb', () => {
-    const data = normalizeRequest({ headers: null, qs: {}, body: null });
-    expect(data).toBe(null);
-  });
-
-  it('test with empty header parameters', () => {
-    const data = normalizeRequest({ headers: {}, qs: null, body: null });
-    expect(data).toBe(null);
-  });
-
-  it('test with valid query string', () => {
-    const data = normalizeRequest({
-      headers: {},
-      qs: { someKey: 'someValue', body: null },
-    });
-    expect(data).toMatchObject({ someKey: 'someValue' });
-  });
-
-  it('test with valid body and content-type', () => {
-    const data = normalizeRequest({
-      headers: { 'content-type': 'application/json' },
-      qs: null,
-      body: JSON.stringify({ someKey: 'someValue' }),
-    });
-
-    expect(data).toMatchObject({ someKey: 'someValue' });
-  });
-
-  it('test with valid body and Content-Type', () => {
-    const data = normalizeRequest({
-      headers: { 'Content-Type': 'application/json' },
-      qs: null,
-      body: JSON.stringify({ someKey: 'someValue' }),
-    });
-
-    expect(data).toMatchObject({ someKey: 'someValue' });
-  });
-
-  it('test with valid query string and body and Content-Type', () => {
-    const data = normalizeRequest({
-      headers: { 'Content-Type': 'application/json' },
-      qs: { someKeyQS: 'someValueQS' },
-      body: JSON.stringify({ someKeyBody: 'someValueBody' }),
-    });
-
-    expect(data).toMatchObject({
-      someKeyQS: 'someValueQS',
-      someKeyBody: 'someValueBody',
-    });
-  });
-
-  it('test with invalid body and valid Content-Type', () => {
-    expect(() => {
-      normalizeRequest({
-        headers: { 'Content-Type': 'application/json' },
-        qs: null,
-        body: {
-          someKey: 'someValue',
-        },
-      });
-    }).toThrow(
-      new Error('Content type defined as JSON but an invalid JSON was provided')
-    );
-  });
-});
-
-describe('MiddlewareGroup: test normalizeHttpRequestBeforeHandler', () => {
-  it('test with default parameters', () => {
-    const handler = {
-      event: {
-        headers: {},
-        queryStringParameters: null,
-        body: null,
-      },
-    };
-
-    normalizeHttpRequestBeforeHandler(handler, () => {});
-    expect(handler.event.input).toBe(null);
-  });
-
-  it('test with request context', () => {
-    const handler = {
-      event: {
-        headers: {},
-        requestContext: {
-          requestId: 'requestId',
-        },
-      },
-    };
-
-    normalizeHttpRequestBeforeHandler(handler, () => {});
-  });
-
-  it('should return auth.sub if Authorization exists', () => {
-    const handler = {
-      event: {
-        headers: {
-          Authorization:
-            'eyJraWQiOiIzSHc3YmRuUHBIMnJSZWhjT3k5NFRLZm5ybzU0Y1RFUW1lcGtVYWc2bW1vPSIsImFsZyI6IlJTMjU2In0.eyJzdWIiOiJmMmI1MzQ5ZC1mNWUzLTQ0ZjUtOWMwOC1hZTZiMDFlOTU0MzQiLCJhdWQiOiI0aHM0a2ZpNTAwZWtkajJhZTdiOWExazU4byIsImVtYWlsX3ZlcmlmaWVkIjpmYWxzZSwiZXZlbnRfaWQiOiJlNzdiZGZmYy0wYjFjLTQzMzMtYWUxZS1lM2QwNjZkNzAyZGMiLCJ0b2tlbl91c2UiOiJpZCIsImF1dGhfdGltZSI6MTYxNTYxMTc3NywiaXNzIjoiaHR0cHM6XC9cL2NvZ25pdG8taWRwLmFwLXNvdXRoZWFzdC0xLmFtYXpvbmF3cy5jb21cL2FwLXNvdXRoZWFzdC0xXzR3QjFuSmNvSyIsImNvZ25pdG86dXNlcm5hbWUiOiJmMmI1MzQ5ZC1mNWUzLTQ0ZjUtOWMwOC1hZTZiMDFlOTU0MzQiLCJleHAiOjE2MTU2MTUzNzcsImlhdCI6MTYxNTYxMTc3NywiZW1haWwiOiJzdWZpeWFuK3Rlc3RAaW5jdWJlOC5zZyJ9.hbNYnVt6_fhX5KJEfn6Fi9cOZkQAldHGitVBWXSd0_YcWDU_BJ1OVu_VFEKzIvaRLR_zy2eW3dIJ27pn1_6U0sS8MZMsvtz0SKQP4M1hTEnhb5TOSIcOs9Y6ZPy1e1ShIqQmq2j_K1JFzEZH7u3eOmCTmFcs8X5vUk8O1sT2KqBP5UCBVB_4rCVEjbRGdyynqEKcdKkd7Nk6v9onpxRbG3FOg6vlsKSlfZ6RIz3jbjO4ZkCJiYAgrI7bsh2VGwE8pZq80GuQy9pocLkTcZiAFcni50-yvePQX8tkXhPzbp7DibAI6nU87Ol6TW4ZmB-0BZ56Nfeowoe7tT-7hvGkGA',
-        },
-      },
-    };
-
-    normalizeHttpRequestBeforeHandler(handler, () => {});
-    expect(handler.event.auth.sub).toBe('f2b5349d-f5e3-44f5-9c08-ae6b01e95434');
-  });
-
-  it.each`
-    version  | tags
-    ${'1.0'} | ${{ path: '/v1/path', httpMethod: 'GET' }}
-    ${'2.0'} | ${{ path: '/v2/path', httpMethod: 'POST' }}
-    ${'3.0'} | ${{ path: '/v2/path', httpMethod: 'POST' }}
-  `(
-    'should identify path and httpMethod based on version',
-    ({ version, tags }) => {
-      const handler = {
-        event: {
-          version,
-          headers: {},
-          ...tags,
-          requestContext: {
-            http: {
-              ...tags,
-              method: tags.httpMethod,
-            },
-          },
-        },
-      };
-      normalizeHttpRequestBeforeHandler(handler, () => {});
-      expect(logger.meta.tags).toStrictEqual(tags);
-    }
-  );
-
-  it('should not set tags when using API Gateway v2 and requestContext is empty', () => {
-    const handler = {
-      event: {
-        version: '2.0',
-        headers: {},
-      },
-    };
-
-    normalizeHttpRequestBeforeHandler(handler, () => {});
-    expect(logger.meta.tags).toStrictEqual({});
-  });
-
-  it('should not set meta on debug', () => {
-    app.debug = true;
-    const handler = {
-      event: {
-        headers: {},
-        auth: '1',
-        queryStringParameters: {
-          foo: 'bar',
-        },
-        body: {
-          test: 'body',
-        },
-      },
-    };
-
-    normalizeHttpRequestBeforeHandler(handler, () => {});
-    expect(logger.meta.auth).toBe(handler.event.auth);
-    expect(logger.meta.queryStringParameters).toStrictEqual(
-      handler.event.queryStringParameters
-    );
-    expect(logger.meta.body).toStrictEqual(handler.event.body);
-  });
-});

package/src/middlewares/__tests__/normalizeSQSMessageMiddleware.spec.js

@@ -1,120 +0,0 @@
-import {
-  normalizeHandler,
-  disconnectConnections,
-} from '../normalizeSQSMessageMiddleware';
-
-describe('MiddlewareGroup: test normalizeRecords middleware', () => {
-  it('test without parameters', () => {
-    const data = normalizeHandler(undefined);
-    expect(data).toBe(null);
-  });
-
-  it('test with valid empty records', () => {
-    const data = normalizeHandler({});
-    expect(data).toBe(null);
-  });
-
-  it('test with valid SQS records', () => {
-    const data = normalizeHandler([
-      {
-        messageId: 'messageId',
-        receiptHandle: 'receiptHandle',
-        body: '{"data":{"testQueueKey":"testQueueValue"}}',
-      },
-    ]);
-    expect(data).toMatchObject([
-      {
-        messageId: 'messageId',
-        receiptHandle: 'receiptHandle',
-        data: {
-          testQueueKey: 'testQueueValue',
-        },
-      },
-    ]);
-  });
-});
-
-describe('MiddlewareGroup: test disconnectConnections db middleware', () => {
-  it('should not call db.end() whenever a db options is not present', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await disconnectConnections();
-
-    expect(end).toHaveBeenCalledTimes(0);
-  });
-
-  it('should not call db.end() whenever a db options is not set', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await disconnectConnections({ db: {} });
-
-    expect(end).toHaveBeenCalledTimes(0);
-  });
-
-  it('should call db.end() whenever a db options is set', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await disconnectConnections({
-      db: {
-        end,
-      },
-    });
-
-    expect(end).toHaveBeenCalledTimes(1);
-  });
-
-  it('should return exception if failure is detected', async () => {
-    const end = jest.fn().mockImplementationOnce(() => {
-      throw new Error('Test Error');
-    });
-    await disconnectConnections({
-      db: {
-        end,
-      },
-    });
-  });
-});
-
-describe('MiddlewareGroup: test disconnectConnections dbRead middleware', () => {
-  it('should not call dbRead.end() whenever a dbRead options is not set', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await disconnectConnections({ dbRead: {} });
-
-    expect(end).toHaveBeenCalledTimes(0);
-  });
-
-  it('should not call anything whenever no options is passed', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await disconnectConnections();
-
-    expect(end).toHaveBeenCalledTimes(0);
-  });
-
-  it('should call dbRead.end() whenever a dbRead options is set', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await disconnectConnections({
-      dbRead: {
-        end,
-      },
-    });
-
-    expect(end).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('MiddlewareGroup: test disconnectConnections cache middleware', () => {
-  it('should not call cache.end() whenever a cache options is not set', async () => {
-    const cache = jest.fn().mockResolvedValue();
-    await disconnectConnections({ cache: {} });
-
-    expect(cache).toHaveBeenCalledTimes(0);
-  });
-
-  it('should call cache.end() whenever a cache options is set', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await disconnectConnections({
-      cache: {
-        end,
-      },
-    });
-
-    expect(end).toHaveBeenCalledTimes(1);
-  });
-});