lesgo 0.7.8 → 1.0.0

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.8",
+  "version": "1.0.0",
   "description": "Core framework for lesgo node.js serverless framework.",
   "main": "./src/index.js",
   "author": "Sufiyan Rahmat",

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

@@ -4,6 +4,38 @@ import basicAuthMiddleware, {
 } 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
@@ -21,7 +53,6 @@ describe('test basicAuthMiddleware middleware', () => {
     });
 
     expect(result).toHaveProperty('before');
-    expect(result).toHaveProperty('onError');
   });
 });
 
@@ -33,28 +64,33 @@ describe('test verifyBasicAuthBeforeHandler error handling', () => {
     'base64'
   );
   const invalidSecretKey = Buffer.from(
-    `${client.platform_2.key}:secret_key`
+    `${client.clients.platform_2.key}:secret_key`
   ).toString('base64');
 
   test.each`
-    headers                                           | errorName           | errorMessage                                  | errorStatusCode | errorCode                                                               | blacklistMode
+    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'}    | ${true}
-    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Invalid authorization type provided'}      | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE'}   | ${true}
-    ${{ Authorization: 'basic ' }}                    | ${'LesgoException'} | ${'Empty basic authentication hash provided'} | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_EMPTY_BASIC_HASH'}             | ${true}
-    ${{ Authorization: `basic ${invalidClientKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${true}
-    ${{ Authorization: `basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${true}
-    ${{ Authorization: `Basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${true}
-    ${{ Authorization: 'auth' }}                      | ${'LesgoException'} | ${'Invalid authorization type provided'}      | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_AUTHORIZATION_TYPE'}   | ${false}
-    ${{ Authorization: 'basic ' }}                    | ${'LesgoException'} | ${'Empty basic authentication hash provided'} | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_EMPTY_BASIC_HASH'}             | ${false}
-    ${{ Authorization: `basic ${invalidClientKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${false}
-    ${{ Authorization: `basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${false}
-    ${{ Authorization: `Basic ${invalidSecretKey}` }} | ${'LesgoException'} | ${'Invalid client key or secret provided'}    | ${403}          | ${'Middlewares/basicAuthMiddleware::AUTH_INVALID_CLIENT_OR_SECRET_KEY'} | ${false}
+    ${{}}                                             | ${'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 ({
@@ -63,23 +99,20 @@ describe('test verifyBasicAuthBeforeHandler error handling', () => {
       errorMessage,
       errorStatusCode,
       errorCode,
-      blacklistMode,
+      platform,
     }) => {
       const handler = {
         event: {
           headers,
-          site: {
-            id: 'platform_1',
+          platform: {
+            id: platform,
+            ...client.clients[platform],
           },
         },
       };
 
       try {
-        expect(
-          verifyBasicAuthBeforeHandler(handler, next, {
-            blacklistMode,
-          })
-        ).toThrow();
+        expect(await verifyBasicAuthBeforeHandler(handler, next)).toThrow();
       } catch (error) {
         expect(error.name).toBe(errorName);
         expect(error.message).toBe(errorMessage);
@@ -91,12 +124,45 @@ describe('test verifyBasicAuthBeforeHandler error handling', () => {
 });
 
 describe('test verifyBasicAuthBeforeHandler with valid credentials', () => {
-  const validBasicAuth = Buffer.from(
-    generateBasicAuthorizationHash(
-      client.platform_2.key,
-      client.platform_2.secret
-    )
-  ).toString('base64');
+  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
@@ -108,7 +174,7 @@ describe('test verifyBasicAuthBeforeHandler with valid credentials', () => {
     secret: '2222-2222-2222-2222',
   },
 }}
-  `('should return undefined when successful', ({ clientObj }) => {
+  `('should return undefined when successful', async ({ clientObj }) => {
     const handler = {
       event: {
         headers: {
@@ -123,7 +189,7 @@ describe('test verifyBasicAuthBeforeHandler with valid credentials', () => {
     let hasError = false;
 
     try {
-      verifyBasicAuthBeforeHandler(handler, next, {
+      await verifyBasicAuthBeforeHandler(handler, next, {
         client: clientObj,
       });
     } catch (e) {
@@ -134,22 +200,24 @@ describe('test verifyBasicAuthBeforeHandler with valid credentials', () => {
   });
 
   test.each`
-    Authorization                | blacklistMode
-    ${undefined}                 | ${false}
-    ${`basic ${validBasicAuth}`} | ${false}
-    ${`Basic ${validBasicAuth}`} | ${false}
-    ${`basic ${validBasicAuth}`} | ${true}
-    ${`Basic ${validBasicAuth}`} | ${true}
+    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',
-    ({ Authorization, blacklistMode }) => {
+    async ({ Authorization, platform }) => {
       const handler = {
         event: {
           headers: {
             Authorization,
           },
-          site: {
-            id: 'platform_2',
+          platform: {
+            id: platform,
+            ...client.clients[platform],
           },
         },
       };
@@ -157,9 +225,7 @@ describe('test verifyBasicAuthBeforeHandler with valid credentials', () => {
       let hasError = false;
 
       try {
-        verifyBasicAuthBeforeHandler(handler, next, {
-          blacklistMode,
-        });
+        await verifyBasicAuthBeforeHandler(handler, next);
       } catch (e) {
         hasError = true;
       }
@@ -170,39 +236,12 @@ describe('test verifyBasicAuthBeforeHandler with valid credentials', () => {
 
   test.each`
     siteObjects
+    ${{ platform: {
+    id: 'platform_2',
+    ...client.clients.platform_2,
+  } }}
     ${{}}
-    ${{ site: { id: undefined } }}
-    ${{ requestContext: { site: { id: undefined } } }}
-    ${{ platform: undefined }}
-  `('test Exception with no site ID', ({ siteObjects }) => {
-    const handler = {
-      event: {
-        headers: {
-          Authorization: `basic ${validBasicAuth}`,
-        },
-        ...siteObjects,
-      },
-    };
-
-    try {
-      expect(verifyBasicAuthBeforeHandler(handler, next)).toThrow();
-    } catch (error) {
-      expect(error.name).toBe('LesgoException');
-      expect(error.message).toBe('Site ID could not be found');
-      expect(error.statusCode).toBe(403);
-      expect(error.code).toBe(
-        'Middlewares/basicAuthMiddleware::SITE_ID_NOT_FOUND'
-      );
-    }
-  });
-
-  test.each`
-    siteObjects
-    ${{ site: { id: 'platform_2' } }}
-    ${{ requestContext: { site: { id: 'platform_2' } } }}
-    ${{ requestContext: { site: { id: undefined } }, platform: 'platform_2' }}
-    ${{ platform: 'platform_2' }}
-  `('valid site ids', ({ siteObjects }) => {
+  `('valid site ids', async ({ siteObjects }) => {
     const handler = {
       event: {
         headers: {
@@ -215,7 +254,7 @@ describe('test verifyBasicAuthBeforeHandler with valid credentials', () => {
     let hasError = false;
 
     try {
-      verifyBasicAuthBeforeHandler(handler, next);
+      await verifyBasicAuthBeforeHandler(handler, next);
     } catch (e) {
       hasError = true;
     }

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

@@ -7,7 +7,6 @@ describe('test authMiddleware', () => {
     // eslint-disable-next-line no-unused-vars
     const result = clientAuthMiddleware();
     expect(result).toHaveProperty('before');
-    expect(result).toHaveProperty('onError');
   });
 });
 
@@ -27,7 +26,7 @@ describe('test clientMiddlewareBeforeHandler', () => {
       expect(await clientAuthMiddlewareBeforeHandler(handler, next)).toThrow();
     } catch (error) {
       expect(error.name).toBe('LesgoException');
-      expect(error.message).toBe("Missing required 'x-client-id'");
+      expect(error.message).toBe("Missing required 'clientKey'");
       expect(error.statusCode).toBe(403);
       expect(error.code).toBe(
         'Middlewares/clientAuthMiddleware::INVALID_AUTH_DATA'
@@ -56,6 +55,46 @@ describe('test clientMiddlewareBeforeHandler', () => {
     }
   });
 
+  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: {
@@ -97,6 +136,32 @@ describe('test clientMiddlewareBeforeHandler', () => {
     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: {
@@ -115,7 +180,22 @@ describe('test clientMiddlewareBeforeHandler', () => {
     expect(handler.event).toHaveProperty('created_obj');
   });
 
-  test('should execute passed top object with callback function', async () => {
+  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: {},
@@ -126,12 +206,30 @@ describe('test clientMiddlewareBeforeHandler', () => {
     };
 
     await clientAuthMiddlewareBeforeHandler(handler, next, {
-      callback: h => {
+      callback: async h => {
+        await new Promise(resolve => setTimeout(resolve, 500));
         // eslint-disable-next-line no-param-reassign
-        h.event.created_obj = 'created_obj';
+        h.event.created_obj_async = 'created_obj_async';
       },
     });
 
-    expect(handler.event).toHaveProperty('created_obj');
+    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(

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$/);
     }
   });
 });