lesgo 0.7.7 → 1.0.0

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

@@ -0,0 +1,201 @@
+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(),
+    });
+  });
+});

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

@@ -59,6 +59,17 @@ describe('MiddlewareGroup: test disconnectConnections db middleware', () => {
 
     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', () => {
@@ -69,6 +80,13 @@ describe('MiddlewareGroup: test disconnectConnections dbRead middleware', () =>
     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({

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

@@ -73,6 +73,19 @@ describe('MiddlewareGroup: test successHttpResponseHandler middleware', () => {
     });
   });
 
+  it('test with formatSuccess argument', async () => {
+    const data = await successHttpResponseHandler({
+      response: 'Some message',
+      formatSuccess: options => {
+        return options.response;
+      },
+    });
+
+    expect(data.statusCode).toBe(200);
+
+    expect(data.body).toBe('Some message');
+  });
+
   it('test with configurable header', async () => {
     const data = await successHttpResponseHandler({
       response: 'Some message',

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

@@ -1,6 +1,7 @@
 import config from 'Config/jwt'; // eslint-disable-line import/no-unresolved
-import { verifyJwtMiddlewareBeforeHandler } from '../verifyJwtMiddleware';
-import LesgoException from '../../exceptions/LesgoException';
+import verifyJwtMiddleware, {
+  verifyJwtMiddlewareBeforeHandler,
+} from '../verifyJwtMiddleware';
 
 describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
   const handler = {
@@ -11,17 +12,35 @@ describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
     },
   };
 
-  it('test without authorization header', () => {
-    expect(() => verifyJwtMiddlewareBeforeHandler(handler, () => {})).toThrow(
-      new LesgoException(
-        'Authorization Header is required!',
-        'JWT_MISSING_AUTHORIZATION_HEADER',
-        403
-      )
-    );
+  it('should return before object', () => {
+    const newHandler = {
+      event: {
+        ...handler.event,
+        headers: {
+          Authorization:
+            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZGVwYXJ0bWVudF9pZCI6MX0.pa2TBRqdVSFUhmiglB8SD8ImthqhqZBn0stAdNRcJ3w',
+        },
+      },
+    };
+    const result = verifyJwtMiddleware(newHandler, () => {});
+
+    expect(result).toHaveProperty('before');
+  });
+
+  it('test without authorization header', async () => {
+    try {
+      expect(
+        await verifyJwtMiddlewareBeforeHandler(handler, () => {})
+      ).toThrow();
+    } catch (e) {
+      expect(e.name).toEqual('LesgoException');
+      expect(e.message).toEqual('Authorization Header is required!');
+      expect(e.code).toEqual('JWT_MISSING_AUTHORIZATION_HEADER');
+      expect(e.statusCode).toEqual(403);
+    }
   });
 
-  it('test with missing bearer token', () => {
+  it('test with missing bearer token', async () => {
     const newHandler = {
       event: {
         ...handler.event,
@@ -31,18 +50,19 @@ describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
       },
     };
 
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(
-      new LesgoException(
-        'Authorization Header is required!',
-        'JWT_MISSING_AUTHORIZATION_HEADER',
-        403
-      )
-    );
+    try {
+      expect(
+        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
+      ).toThrow();
+    } catch (e) {
+      expect(e.name).toEqual('LesgoException');
+      expect(e.message).toEqual('Authorization Header is required!');
+      expect(e.code).toEqual('JWT_MISSING_AUTHORIZATION_HEADER');
+      expect(e.statusCode).toEqual(403);
+    }
   });
 
-  it('test with invalid token', () => {
+  it('test with invalid token', async () => {
     const newHandler = {
       event: {
         ...handler.event,
@@ -52,18 +72,19 @@ describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
       },
     };
 
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(
-      new LesgoException(
-        'Missing Bearer token!',
-        'JWT_MISSING_BEARER_TOKEN',
-        403
-      )
-    );
+    try {
+      expect(
+        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
+      ).toThrow();
+    } catch (e) {
+      expect(e.name).toEqual('LesgoException');
+      expect(e.message).toEqual('Missing Bearer token!');
+      expect(e.code).toEqual('JWT_MISSING_BEARER_TOKEN');
+      expect(e.statusCode).toEqual(403);
+    }
   });
 
-  it('test with malformed token', () => {
+  it('test with malformed token', async () => {
     const newHandler = {
       event: {
         ...handler.event,
@@ -73,12 +94,19 @@ describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
       },
     };
 
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(new LesgoException('jwt malformed', 'JWT_ERROR', 403));
+    try {
+      expect(
+        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
+      ).toThrow();
+    } catch (e) {
+      expect(e.name).toEqual('LesgoException');
+      expect(e.message).toEqual('jwt malformed');
+      expect(e.code).toEqual('JWT_ERROR');
+      expect(e.statusCode).toEqual(403);
+    }
   });
 
-  it('test with incorrect secret key', () => {
+  it('test with incorrect secret key', async () => {
     const newHandler = {
       event: {
         ...handler.event,
@@ -89,12 +117,19 @@ describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
       },
     };
 
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(new LesgoException('invalid signature', 'JWT_ERROR', 403));
+    try {
+      expect(
+        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
+      ).toThrow();
+    } catch (e) {
+      expect(e.name).toEqual('LesgoException');
+      expect(e.message).toEqual('invalid signature');
+      expect(e.code).toEqual('JWT_ERROR');
+      expect(e.statusCode).toEqual(403);
+    }
   });
 
-  it('test with invalid ISS', () => {
+  it('test with invalid ISS', async () => {
     const newHandler = {
       event: {
         ...handler.event,
@@ -105,18 +140,19 @@ describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
       },
     };
 
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(
-      new LesgoException(
-        "Token's [iss] is not valid!",
-        'JWT_ISS_NOT_VALID',
-        403
-      )
-    );
+    try {
+      expect(
+        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
+      ).toThrow();
+    } catch (e) {
+      expect(e.name).toEqual('LesgoException');
+      expect(e.message).toEqual("Token's [iss] is not valid!");
+      expect(e.code).toEqual('JWT_ISS_NOT_VALID');
+      expect(e.statusCode).toEqual(403);
+    }
   });
 
-  it('test with missing custom claim', () => {
+  it('test with missing custom claim', async () => {
     const newHandler = {
       event: {
         ...handler.event,
@@ -127,18 +163,21 @@ describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
       },
     };
 
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(
-      new LesgoException(
-        `Token's custom claim [${config.customClaims.data[0]}] not found!`,
-        'JWT_CUSTOM_CLAIM_NOT_FOUND',
-        403
-      )
-    );
+    try {
+      expect(
+        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
+      ).toThrow();
+    } catch (e) {
+      expect(e.name).toEqual('LesgoException');
+      expect(e.message).toEqual(
+        `Token's custom claim [${config.customClaims.data[0]}] not found!`
+      );
+      expect(e.code).toEqual('JWT_CUSTOM_CLAIM_NOT_FOUND');
+      expect(e.statusCode).toEqual(403);
+    }
   });
 
-  it('test with expired token', () => {
+  it('test with expired token', async () => {
     const newHandler = {
       event: {
         ...handler.event,
@@ -149,12 +188,19 @@ describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
       },
     };
 
-    expect(() =>
-      verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
-    ).toThrow(new LesgoException('jwt expired', 'JWT_EXPIRED', 403));
+    try {
+      expect(
+        await verifyJwtMiddlewareBeforeHandler(newHandler, () => {})
+      ).toThrow();
+    } catch (e) {
+      expect(e.name).toEqual('LesgoException');
+      expect(e.message).toEqual('jwt expired');
+      expect(e.code).toEqual('JWT_EXPIRED');
+      expect(e.statusCode).toEqual(403);
+    }
   });
 
-  it('test with valid token', () => {
+  it('test with valid token', async () => {
     const newHandler = {
       event: {
         ...handler.event,
@@ -165,7 +211,84 @@ describe('MiddlewareGroup: test verifyJwtMiddleware middleware', () => {
       },
     };
 
-    verifyJwtMiddlewareBeforeHandler(newHandler, () => {});
+    await verifyJwtMiddlewareBeforeHandler(newHandler, () => {});
+    expect(newHandler.event.decodedJwt).toMatchObject({
+      sub: '1234567890',
+      iss: config.iss.data[0],
+    });
+  });
+
+  it('test with secret as a function argument', async () => {
+    const { secret } = config;
+    config.secret = secretHandler => {
+      return `111${secretHandler.key}`;
+    };
+    const newHandler = {
+      key: '1',
+      event: {
+        ...handler.event,
+        headers: {
+          Authorization:
+            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZGVwYXJ0bWVudF9pZCI6MX0.7RdbXJhzrn_yV7CPqkuX0Yvtms0xaIw1q4LPe8O0BDY',
+        },
+      },
+    };
+
+    await verifyJwtMiddlewareBeforeHandler(newHandler, () => {});
+    expect(newHandler.event.decodedJwt).toMatchObject({
+      sub: '1234567890',
+      iss: config.iss.data[0],
+    });
+
+    config.secret = secret;
+  });
+
+  it('test with callback argument', async () => {
+    const callback = jest.fn();
+    config.callback = callback;
+    const newHandler = {
+      event: {
+        ...handler.event,
+        headers: {
+          Authorization:
+            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZGVwYXJ0bWVudF9pZCI6MX0.pa2TBRqdVSFUhmiglB8SD8ImthqhqZBn0stAdNRcJ3w',
+        },
+      },
+    };
+
+    await verifyJwtMiddlewareBeforeHandler(newHandler, () => {});
+    expect(newHandler.event.decodedJwt).toMatchObject({
+      sub: '1234567890',
+      iss: config.iss.data[0],
+    });
+    expect(callback).toHaveBeenCalledWith(newHandler);
+  });
+
+  it('test with custom config', async () => {
+    const newHandler = {
+      event: {
+        ...handler.event,
+        headers: {
+          Authorization:
+            'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZGVwYXJ0bWVudF9pZCI6MX0.pa2TBRqdVSFUhmiglB8SD8ImthqhqZBn0stAdNRcJ3w',
+        },
+      },
+    };
+
+    await verifyJwtMiddlewareBeforeHandler(newHandler, () => {}, {
+      jwtConfig: {
+        secret:
+          'c4156b94c80b7f163feabd4ff268c99eb11ce8995df370a4fd872afb4377b273',
+        iss: {
+          validate: true,
+          data: ['domain.com'],
+        },
+        customClaims: {
+          validate: true,
+          data: ['department_id'],
+        },
+      },
+    });
     expect(newHandler.event.decodedJwt).toMatchObject({
       sub: '1234567890',
       iss: config.iss.data[0],