lesgo 0.7.7 → 1.0.0

package/README.md

@@ -1,6 +1,6 @@
 # Lesgo!
 
-[![Build Status]](https://github.com/reflex-media/lesgo-framework/actions/workflows/release.yml/badge.svg)
+![Build Status](https://github.com/reflex-media/lesgo-framework/actions/workflows/release.yml/badge.svg)
 [![Coverage Status](https://coveralls.io/repos/github/reflex-media/lesgo-framework/badge.svg?branch=master)](https://coveralls.io/github/reflex-media/lesgo-framework?branch=master)
 
 Bootstrap your next microservice with a lightweight node.js serverless framework.

package/bin/lesgo-scripts.sh

@@ -93,6 +93,21 @@ NC='\033[0m';
 # FUNCTION DECLARATIONS                                                       #
 #                                                                             #
 ###############################################################################
+LOCAL_SERVERLESS_VERSION=`npm ls --depth=0 serverless | grep -o "serverless@.*" || true`
+GLOBAL_SERVERLESS_VERSION=`npm ls -g --depth=0 serverless | grep -o "serverless@.*" || true`
+LATEST_SERVERLESS_VERSION_NUMBER=3
+
+if [ -z "$LOCAL_SERVERLESS_VERSION" ]
+then
+    CURRENT_SERVERLESS_VERSION=$GLOBAL_SERVERLESS_VERSION
+else
+    CURRENT_SERVERLESS_VERSION=$LOCAL_SERVERLESS_VERSION
+fi
+SERVERLESS_VERSION=${CURRENT_SERVERLESS_VERSION#*@}
+SERVERLESS_VERSION_NUMBER=${SERVERLESS_VERSION%%.*}
+
+echo -e "Running Serverless version:\n${CURRENT_SERVERLESS_VERSION}\n"
+echo -e "Current Serverless version: ${SERVERLESS_VERSION_NUMBER}\n"
 
 function deploy_func_check ()
 {
@@ -106,7 +121,12 @@ function deploy_func_check ()
 function deploy_func ()
 {
     echo -e "${YELLOW}Deploying ${FUNCTION} to ${STAGE}${NC} using ${CONFIG}"
-    sls deploy -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+
+    if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+        sls deploy function -f ${FUNCTION} --stage ${STAGE} --param="env=${ENVFILE}" --config ${CONFIG}
+    else
+        sls deploy  -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    fi
 }
 
 function prompt_confirmation_deploy_all ()
@@ -140,29 +160,50 @@ function prompt_confirmation_deploy_function ()
 function deploy_full ()
 {
     echo -e "${YELLOW}Deploying service to ${STAGE}${NC}"
-    sls deploy --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+        sls deploy --stage ${STAGE} --param="env=${ENVFILE}" --config ${CONFIG}
+    else
+        sls deploy --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    fi
 }
 
 function invoke_func ()
 {
     echo -e "${YELLOW}Invoking function ${FUNCTION} on ${STAGE}${NC} using ${CONFIG}"
     if [ ${INVOKE_LOCAL} == 1 ]; then
-        sls invoke local -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -d ${DATA} -l --config ${CONFIG}
+        if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+            sls invoke local function -f ${FUNCTION} --stage ${STAGE} --param="env=${ENVFILE}" -d ${DATA} -l --config ${CONFIG}
+        else
+            sls invoke local -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -d ${DATA} -l --config ${CONFIG}
+        fi
+
     else
-        sls invoke -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -d ${DATA} -l --config ${CONFIG}
+        if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+            sls invoke function -f ${FUNCTION} --stage ${STAGE} --param="env=${ENVFILE}" -d ${DATA} -l --config ${CONFIG}
+        else
+            sls invoke -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -d ${DATA} -l --config ${CONFIG}
+        fi
     fi
 }
 
 function log_stream_func ()
 {
     echo -e "${YELLOW}Log Streaming function ${FUNCTION} on ${STAGE}${NC} using ${CONFIG}"
-    sls logs -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -t --config ${CONFIG}
+    if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+        sls logs function -f ${FUNCTION} --stage ${STAGE} --param="env=${ENVFILE}" -t --config ${CONFIG}
+    else
+        sls logs -f ${FUNCTION} --stage ${STAGE} --env ${ENVFILE} -t --config ${CONFIG}
+    fi
 }
 
 function build ()
 {
     echo -e "${YELLOW}Building bundle without deployment${NC} using ${CONFIG}"
-    sls webpack --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+        sls webpack --stage ${STAGE} --param="env=${ENVFILE}" --config ${CONFIG}
+    else
+        sls webpack --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    fi
 }
 
 function prompt_confirmation_destroy_service ()
@@ -180,7 +221,11 @@ function prompt_confirmation_destroy_service ()
 function destroy_service ()
 {
     echo -e "${YELLOW}Removing service to ${STAGE}${NC}"
-    sls remove --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    if [ ${SERVERLESS_VERSION_NUMBER} -ge ${LATEST_SERVERLESS_VERSION_NUMBER} ]; then
+        sls remove --stage ${STAGE} --param="env=${ENVFILE}" --config ${CONFIG}
+    else
+        sls remove --stage ${STAGE} --env ${ENVFILE} --config ${CONFIG}
+    fi
 }
 
 ###############################################################################

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lesgo",
-  "version": "0.7.7",
+  "version": "1.0.0",
   "description": "Core framework for lesgo node.js serverless framework.",
   "main": "./src/index.js",
   "author": "Sufiyan Rahmat",
@@ -30,7 +30,7 @@
     "lesgo-scripts": "./bin/lesgo-scripts.sh"
   },
   "engines": {
-    "node": "12.x"
+    "node": ">=12.0.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.17.6",

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

@@ -0,0 +1,264 @@
+import basicAuthMiddleware, {
+  generateBasicAuthorizationHash,
+  verifyBasicAuthBeforeHandler,
+} from '../basicAuthMiddleware';
+import client from '../../../tests/__mocks__/config/client';
+
+describe('test generateBasicAuthorizationHash', () => {
+  test('should return custom when overriden through opts', () => {
+    expect(
+      generateBasicAuthorizationHash(
+        'e5bb52b012ad4a4e9d862a3410e7013d',
+        '4cd19af8f7ca4448bcb2c427754095b5',
+        {
+          getPreHashString: key => {
+            return `=${key}=`;
+          },
+        }
+      )
+    ).toBe('PWU1YmI1MmIwMTJhZDRhNGU5ZDg2MmEzNDEwZTcwMTNkPQ==');
+  });
+
+  test('should return basic auth by default', () => {
+    const { getPreHashString } = client;
+    client.getPreHashString = null;
+
+    expect(
+      generateBasicAuthorizationHash(
+        'e5bb52b012ad4a4e9d862a3410e7013d',
+        '4cd19af8f7ca4448bcb2c427754095b5'
+      )
+    ).toBe(
+      'ZTViYjUyYjAxMmFkNGE0ZTlkODYyYTM0MTBlNzAxM2Q6NGNkMTlhZjhmN2NhNDQ0OGJjYjJjNDI3NzU0MDk1YjU='
+    );
+
+    client.getPreHashString = getPreHashString;
+  });
+});
+
+describe('test basicAuthMiddleware middleware', () => {
+  test.each`
+    clientObj
+    ${undefined}
+    ${{}}
+    ${{
+  default: {
+    key: '1111-1111-1111-1111',
+    secret: '1111-1111-1111-1111',
+  },
+}}
+  `('should return object', ({ clientObj }) => {
+    const result = basicAuthMiddleware({
+      client: clientObj,
+    });
+
+    expect(result).toHaveProperty('before');
+  });
+});
+
+// eslint-disable-next-line
+const next = () => {};
+
+describe('test verifyBasicAuthBeforeHandler error handling', () => {
+  const invalidClientKey = Buffer.from('client_key:secret_key').toString(
+    'base64'
+  );
+  const invalidSecretKey = Buffer.from(
+    `${client.clients.platform_2.key}:secret_key`
+  ).toString('base64');
+
+  test.each`
+    headers                                           | errorName           | errorMessage                                  | errorStatusCode | errorCode                                                               | platform
+    ${{}}                                             | ${'LesgoException'} | ${'Authorization header not found'}           | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTHORIZATION_HEADER_NOT_FOUND'}    | ${undefined}
+    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Invalid authorization type provided'}      | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE'}   | ${undefined}
+    ${{ Authorization: 'basic ' }}                    | ${'LesgoException'} | ${'Empty basic authentication hash provided'} | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_EMPTY_BASIC_HASH'}             | ${undefined}
+    ${{ Authorization: `basic ${invalidClientKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${undefined}
+    ${{ Authorization: `basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${undefined}
+    ${{ Authorization: `Basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${undefined}
+    ${{}}                                             | ${'LesgoException'} | ${'Authorization header not found'}           | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTHORIZATION_HEADER_NOT_FOUND'}    | ${'platform_1'}
+    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Invalid authorization type provided'}      | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE'}   | ${'platform_1'}
+    ${{ Authorization: 'basic ' }}                    | ${'LesgoException'} | ${'Empty basic authentication hash provided'} | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_EMPTY_BASIC_HASH'}             | ${'platform_1'}
+    ${{ Authorization: `basic ${invalidClientKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'platform_1'}
+    ${{ Authorization: `basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'platform_1'}
+    ${{ Authorization: `Basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'platform_1'}
+    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Invalid authorization type provided'}      | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE'}   | ${'blacklist_platform'}
+    ${{ Authorization: 'basic ' }}                    | ${'LesgoException'} | ${'Empty basic authentication hash provided'} | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_EMPTY_BASIC_HASH'}             | ${'blacklist_platform'}
+    ${{ Authorization: `basic ${invalidClientKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'blacklist_platform'}
+    ${{ Authorization: `basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'blacklist_platform'}
+    ${{ Authorization: `Basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'blacklist_platform'}
+    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Invalid authorization type provided'}      | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE'}   | ${'blacklist_platform_1'}
+    ${{ Authorization: 'basic ' }}                    | ${'LesgoException'} | ${'Empty basic authentication hash provided'} | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_EMPTY_BASIC_HASH'}             | ${'blacklist_platform_1'}
+    ${{ Authorization: `basic ${invalidClientKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'blacklist_platform_1'}
+    ${{ Authorization: `basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'blacklist_platform_1'}
+    ${{ Authorization: `Basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${'blacklist_platform_1'}
+  `(
+    'should throw $errorMessage when authorization header is $headers',
+    async ({
+      headers,
+      errorName,
+      errorMessage,
+      errorStatusCode,
+      errorCode,
+      platform,
+    }) => {
+      const handler = {
+        event: {
+          headers,
+          platform: {
+            id: platform,
+            ...client.clients[platform],
+          },
+        },
+      };
+
+      try {
+        expect(await verifyBasicAuthBeforeHandler(handler, next)).toThrow();
+      } catch (error) {
+        expect(error.name).toBe(errorName);
+        expect(error.message).toBe(errorMessage);
+        expect(error.statusCode).toBe(errorStatusCode);
+        expect(error.code).toBe(errorCode);
+      }
+    }
+  );
+});
+
+describe('test verifyBasicAuthBeforeHandler with valid credentials', () => {
+  const validBasicAuth = generateBasicAuthorizationHash(
+    client.clients.platform_2.key,
+    client.clients.platform_2.secret
+  );
+
+  test.each`
+    clientObj
+    ${undefined}
+    ${{}}
+    ${{
+  platform_2: {
+    key: '2222-2222-2222-2222',
+    secret: '2222-2222-2222-2222',
+  },
+}}
+  `('should return undefined when successful', async ({ clientObj }) => {
+    const handler = {
+      event: {
+        headers: {
+          Authorization: `basic ${validBasicAuth}`,
+        },
+        site: {
+          id: 'platform_2',
+        },
+      },
+    };
+
+    let hasError = false;
+
+    try {
+      await verifyBasicAuthBeforeHandler(handler, next, {
+        client: clientObj,
+      });
+    } catch (e) {
+      hasError = true;
+    }
+
+    expect(hasError).toBeFalsy();
+  });
+
+  test.each`
+    clientObj
+    ${undefined}
+    ${{}}
+    ${{
+  platform_2: {
+    key: '2222-2222-2222-2222',
+    secret: '2222-2222-2222-2222',
+  },
+}}
+  `('should return undefined when successful', async ({ clientObj }) => {
+    const handler = {
+      event: {
+        headers: {
+          Authorization: `basic ${validBasicAuth}`,
+        },
+        site: {
+          id: 'platform_2',
+        },
+      },
+    };
+
+    let hasError = false;
+
+    try {
+      await verifyBasicAuthBeforeHandler(handler, next, {
+        client: clientObj,
+      });
+    } catch (e) {
+      hasError = true;
+    }
+
+    expect(hasError).toBeFalsy();
+  });
+
+  test.each`
+    Authorization                | platform
+    ${undefined}                 | ${'blacklist_platform'}
+    ${undefined}                 | ${'blacklist_platform_1'}
+    ${`basic ${validBasicAuth}`} | ${'platform_2'}
+    ${`Basic ${validBasicAuth}`} | ${'platform_2'}
+    ${`basic ${validBasicAuth}`} | ${'platform_2'}
+    ${`Basic ${validBasicAuth}`} | ${'platform_2'}
+  `(
+    'test Exception with valid credentials',
+    async ({ Authorization, platform }) => {
+      const handler = {
+        event: {
+          headers: {
+            Authorization,
+          },
+          platform: {
+            id: platform,
+            ...client.clients[platform],
+          },
+        },
+      };
+
+      let hasError = false;
+
+      try {
+        await verifyBasicAuthBeforeHandler(handler, next);
+      } catch (e) {
+        hasError = true;
+      }
+
+      expect(hasError).toBeFalsy();
+    }
+  );
+
+  test.each`
+    siteObjects
+    ${{ platform: {
+    id: 'platform_2',
+    ...client.clients.platform_2,
+  } }}
+    ${{}}
+  `('valid site ids', async ({ siteObjects }) => {
+    const handler = {
+      event: {
+        headers: {
+          Authorization: `basic ${validBasicAuth}`,
+        },
+        ...siteObjects,
+      },
+    };
+
+    let hasError = false;
+
+    try {
+      await verifyBasicAuthBeforeHandler(handler, next);
+    } catch (e) {
+      hasError = true;
+    }
+
+    expect(hasError).toBeFalsy();
+  });
+});

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

@@ -0,0 +1,235 @@
+import clientAuthMiddleware, {
+  clientAuthMiddlewareBeforeHandler,
+} from '../clientAuthMiddleware';
+
+describe('test authMiddleware', () => {
+  test('should return object', async () => {
+    // eslint-disable-next-line no-unused-vars
+    const result = clientAuthMiddleware();
+    expect(result).toHaveProperty('before');
+  });
+});
+
+const next = () => {};
+
+describe('test clientMiddlewareBeforeHandler', () => {
+  test('should throw LesgoException when invalid api key is provided', async () => {
+    const handler = {
+      event: {
+        headers: {
+          'X-Api-Key': '123',
+        },
+      },
+    };
+
+    try {
+      expect(await clientAuthMiddlewareBeforeHandler(handler, next)).toThrow();
+    } catch (error) {
+      expect(error.name).toBe('LesgoException');
+      expect(error.message).toBe("Missing required 'clientKey'");
+      expect(error.statusCode).toBe(403);
+      expect(error.code).toBe(
+        'Middlewares/clientAuthMiddleware::INVALID_AUTH_DATA'
+      );
+    }
+  });
+
+  test('should throw LesgoException when x-client-id is incorrect', async () => {
+    const handler = {
+      event: {
+        headers: {
+          'x-client-id': 'notexisting',
+        },
+      },
+    };
+
+    try {
+      expect(await clientAuthMiddlewareBeforeHandler(handler, next)).toThrow();
+    } catch (error) {
+      expect(error.name).toBe('LesgoException');
+      expect(error.message).toBe('Invalid ClientId provided');
+      expect(error.statusCode).toBe(403);
+      expect(error.code).toBe(
+        'Middlewares/clientAuthMiddleware::INVALID_CLIENT_ID'
+      );
+    }
+  });
+
+  test('should be able to validate from multiple header keys', async () => {
+    const handler = {
+      event: {
+        headers: {
+          'X-Client-Id': '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    let hasError = false;
+
+    try {
+      await clientAuthMiddlewareBeforeHandler(handler, next);
+    } catch (e) {
+      hasError = e;
+    }
+
+    expect(hasError).toBe(false);
+  });
+
+  test('should allow getting from query string parameters', async () => {
+    const handler = {
+      event: {
+        queryStringParameters: {
+          'x-client-id': '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    let hasError = false;
+
+    try {
+      await clientAuthMiddlewareBeforeHandler(handler, next);
+    } catch (e) {
+      hasError = e;
+    }
+
+    expect(hasError).toBe(false);
+  });
+
+  test('should return success with valid client id', async () => {
+    const handler = {
+      event: {
+        headers: {
+          'x-client-id': '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    let hasError = false;
+
+    try {
+      await clientAuthMiddlewareBeforeHandler(handler, next);
+    } catch (e) {
+      hasError = true;
+    }
+
+    expect(hasError).toBe(false);
+  });
+
+  test('should return success with valid client id on input', async () => {
+    const handler = {
+      event: {
+        headers: {},
+        input: {
+          clientid: '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    let hasError = false;
+
+    try {
+      await clientAuthMiddlewareBeforeHandler(handler, next);
+    } catch (e) {
+      hasError = true;
+    }
+
+    expect(hasError).toBe(false);
+  });
+
+  test('should set handler.event.platform with valid client id on input', async () => {
+    const handler = {
+      event: {
+        headers: {},
+        input: {
+          clientid: '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    let hasError = false;
+
+    try {
+      await clientAuthMiddlewareBeforeHandler(handler, next);
+    } catch (e) {
+      hasError = true;
+    }
+
+    expect(hasError).toBe(false);
+    expect(handler.event.platform).toStrictEqual({
+      id: 'platform_1',
+      key: '1111-1111-1111-1111',
+      secret: '1111-1111-1111-1111',
+    });
+  });
+
+  test('should execute passed callback function', async () => {
+    const handler = {
+      event: {
+        headers: {},
+        input: {
+          clientid: '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    await clientAuthMiddlewareBeforeHandler(handler, next, h => {
+      // eslint-disable-next-line no-param-reassign
+      h.event.created_obj = 'created_obj';
+    });
+
+    expect(handler.event).toHaveProperty('created_obj');
+  });
+
+  test('should execute with callback function from config', async () => {
+    const handler = {
+      event: {
+        headers: {},
+        input: {
+          clientid: '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    await clientAuthMiddlewareBeforeHandler(handler, next);
+
+    expect(handler.event).toHaveProperty('created_obj');
+  });
+
+  test('should execute passed opt object with async callback function', async () => {
+    const handler = {
+      event: {
+        headers: {},
+        input: {
+          clientid: '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    await clientAuthMiddlewareBeforeHandler(handler, next, {
+      callback: async h => {
+        await new Promise(resolve => setTimeout(resolve, 500));
+        // eslint-disable-next-line no-param-reassign
+        h.event.created_obj_async = 'created_obj_async';
+      },
+    });
+
+    expect(handler.event).toHaveProperty('created_obj_async');
+  });
+
+  test('should not execute passed opt object with callback function if not a function', async () => {
+    const handler = {
+      event: {
+        headers: {},
+        input: {
+          clientid: '1111-1111-1111-1111',
+        },
+      },
+    };
+
+    await clientAuthMiddlewareBeforeHandler(handler, next, {
+      callback: 'not_function',
+    });
+
+    expect(handler.event).not.toHaveProperty('created_obj');
+  });
+});

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

@@ -45,6 +45,19 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
     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(
@@ -145,6 +158,36 @@ describe('MiddlewareGroup: test errorHandler middleware', () => {
 
     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', () => {

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

@@ -97,7 +97,7 @@ describe('test gzipHttpResponse gzip', () => {
       expect(resp).toThrow();
     } catch (err) {
       expect(err.name).toEqual('LesgoException');
-      expect(err.code).toEqual('GZIP_LIB_ERROR');
+      expect(err.code).toMatch(/^GZIP_[A-Z]+_ERROR$/);
     }
   });
 });