lesgo 1.0.0 → 2.1.0

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

@@ -1,203 +0,0 @@
-import {
-  errorHttpResponseHandler,
-  errorHttpResponseAfterHandler,
-} from '../errorHttpResponseMiddleware';
-import ValidationErrorException from '../__mocks__/ValidationErrorException';
-
-describe('MiddlewareGroup: test errorHandler middleware', () => {
-  it('test with thrown Error', async () => {
-    const data = await errorHttpResponseHandler({
-      error: new Error('Test validation error'),
-    });
-
-    expect(data.headers['Access-Control-Allow-Origin']).toBe('*');
-    expect(data.headers['Cache-Control']).toBe('no-cache');
-
-    expect(data.statusCode).toBe(500);
-
-    expect(typeof data.body).toBe('string');
-
-    const dataBody = JSON.parse(data.body);
-    expect(dataBody).toHaveProperty('status', 'error');
-    expect(dataBody).toHaveProperty('data', null);
-    expect(dataBody).toHaveProperty('error');
-    expect(dataBody).toHaveProperty('error.code', 'UNHANDLED_ERROR');
-    expect(dataBody).toHaveProperty(
-      'error.message',
-      'Error: Test validation error'
-    );
-    expect(dataBody).toHaveProperty('error.details', '');
-  });
-
-  it('test with thrown custom Error with default parameters', async () => {
-    const data = await errorHttpResponseHandler({
-      error: new ValidationErrorException('Test validation error'),
-    });
-    const dataBody = JSON.parse(data.body);
-
-    expect(data.statusCode).toBe(400);
-
-    expect(dataBody).toHaveProperty('error.code', 'VALIDATION_ERROR');
-    expect(dataBody).toHaveProperty(
-      'error.message',
-      'ValidationError: Test validation error'
-    );
-    expect(dataBody).toHaveProperty('error.details', '');
-  });
-
-  it('test with formatSuccess argument', async () => {
-    const data = await errorHttpResponseHandler({
-      error: new ValidationErrorException('Test validation error'),
-      formatError: options => {
-        return options.error.code;
-      },
-    });
-
-    expect(data.statusCode).toBe(400);
-
-    expect(data.body).toBe('VALIDATION_ERROR');
-  });
-
-  it('test with thrown custom Error with given parameters', async () => {
-    const data = await errorHttpResponseHandler({
-      error: new ValidationErrorException(
-        'Test validation error',
-        'VALIDATION_ERROR_SAMPLE',
-        401,
-        {
-          extraDataKey: 'extraDataValue',
-        }
-      ),
-    });
-    const dataBody = JSON.parse(data.body);
-
-    expect(data.statusCode).toBe(401);
-
-    expect(dataBody).toHaveProperty('error.code', 'VALIDATION_ERROR_SAMPLE');
-    expect(dataBody).toHaveProperty(
-      'error.message',
-      'ValidationError: Test validation error'
-    );
-    expect(dataBody).toHaveProperty('error.details', {
-      extraDataKey: 'extraDataValue',
-    });
-  });
-
-  it('test with error message', async () => {
-    const data = await errorHttpResponseHandler({
-      error: 'Test error message',
-    });
-    const dataBody = JSON.parse(data.body);
-
-    expect(data.statusCode).toBe(500);
-
-    expect(dataBody).toHaveProperty('error.code', 'UNHANDLED_ERROR');
-    expect(dataBody).toHaveProperty('error.message', 'Test error message');
-    expect(dataBody).toHaveProperty('error.details', '');
-  });
-
-  it('test with error message with event', async () => {
-    const data = await errorHttpResponseHandler({
-      error: 'Test error message',
-      event: {
-        someEventKey: 'someEventValue',
-      },
-      debugMode: true,
-    });
-    const dataBody = JSON.parse(data.body);
-
-    expect(data.statusCode).toBe(500);
-    expect(dataBody).toHaveProperty('_meta', {
-      someEventKey: 'someEventValue',
-    });
-  });
-
-  it('test with error message with event in non-debug mode', async () => {
-    const data = await errorHttpResponseHandler({
-      error: 'Test error message',
-      event: {
-        someEventKey: 'someEventValue',
-      },
-    });
-    const dataBody = JSON.parse(data.body);
-
-    expect(data.statusCode).toBe(500);
-    expect(dataBody).toHaveProperty('_meta', {});
-  });
-
-  it('test with undefined opts', async () => {
-    const data = await errorHttpResponseHandler();
-
-    expect(data.headers['Access-Control-Allow-Origin']).toBe('*');
-    expect(data.headers['Cache-Control']).toBe('no-cache');
-
-    expect(data.statusCode).toBe(500);
-
-    expect(typeof data.body).toBe('string');
-
-    const dataBody = JSON.parse(data.body);
-    expect(dataBody).toHaveProperty('status', 'error');
-    expect(dataBody).toHaveProperty('data', null);
-    expect(dataBody).toHaveProperty('error');
-    expect(dataBody).toHaveProperty('error.code', 'UNHANDLED_ERROR');
-    expect(dataBody).toHaveProperty('error.message', '');
-    expect(dataBody).toHaveProperty('error.details', '');
-  });
-
-  it('should call db.end() whenever a db options is set', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await errorHttpResponseHandler({
-      error: 'Test error message',
-      event: {
-        someEventKey: 'someEventValue',
-      },
-      db: {
-        end,
-      },
-    });
-
-    expect(end).toHaveBeenCalledTimes(1);
-  });
-
-  it('should call cache.end() whenever a cache options is set', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await errorHttpResponseHandler({
-      error: 'Test error message',
-      event: {
-        someEventKey: 'someEventValue',
-      },
-      cache: {
-        end,
-      },
-    });
-
-    expect(end).toHaveBeenCalledTimes(1);
-  });
-
-  it('should call dbRead.end() whenever a dbRead options is set', async () => {
-    const end = jest.fn().mockResolvedValue();
-    await errorHttpResponseHandler({
-      error: 'Test error message',
-      event: {
-        someEventKey: 'someEventValue',
-      },
-      dbRead: {
-        end,
-      },
-    });
-
-    expect(end).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('MiddlewareGroup: test errorHttpResponseAfterHandler', () => {
-  it('test with default parameters', async () => {
-    const handler = {
-      error: {},
-      event: {},
-    };
-
-    await errorHttpResponseAfterHandler(handler, () => {});
-    expect(handler.response).toHaveProperty('statusCode', 500);
-  });
-});

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).toMatch(/^GZIP_[A-Z]+_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,201 +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', '');
-  });
-
-  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 empty 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', '');
-    app.debug = true;
-  });
-
-  it.each`
-    debug    | allowResponse  | body
-    ${false} | ${() => true}  | ${JSON.stringify({ status: 'success', data: 'Some message', _meta: {} })}
-    ${true}  | ${() => true}  | ${JSON.stringify({ status: 'success', data: 'Some message', _meta: {} })}
-    ${false} | ${() => false} | ${''}
-    ${true}  | ${() => false} | ${''}
-    ${true}  | ${undefined}   | ${JSON.stringify({ status: 'success', data: 'Some message', _meta: {} })}
-    ${false} | ${undefined}   | ${''}
-  `(
-    'should return a specific response when allowResponse is $allowResponse and debug is $debug passed via options',
-    async ({ debug, allowResponse, body }) => {
-      app.debug = debug;
-
-      const handler = {
-        response: {},
-        event: {
-          someEventKey: 'someEventValue',
-          queryStringParameters: {
-            debug: 1,
-          },
-        },
-      };
-
-      await successHttpNoOutputResponseAfterHandler(handler, () => {}, {
-        response: 'Some message',
-        allowResponse,
-      });
-      expect(handler.response).toHaveProperty('statusCode', 200);
-      expect(handler.response).toHaveProperty('body', body);
-
-      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', '');
-  });
-
-  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 empty 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', '');
-    app.debug = true;
-  });
-
-  it('should have 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(JSON.parse(handler.response.body)).toStrictEqual({
-      status: 'error',
-      data: null,
-      error: {
-        code: 'UNHANDLED_ERROR',
-        message: 'Error: Test validation error',
-        details: '',
-      },
-      _meta: expect.anything(),
-    });
-  });
-});