improve test Coverage

.gitignore

@@ -61,3 +61,4 @@ tmp/
 ehthumbs.db
 Icon?
 .webpack/*
+.coverage/*

.npmignore

@@ -14,5 +14,7 @@ example/*
 .circleci/*
 .idea/*
 .coverage
+__mocks__
+__tests__
 keycloak-cloudfront-dynamodb
 package-lock.json

README.md

@@ -401,7 +401,7 @@ const privateKey = ...;
 const publicKey = ...;
 
 lamdaEdge.routes.addRoute({
-      isRoute: (request) => isRequest(request, '/someUrl'),
+      isRoute: async (request) => await isRequest(request, '/someUrl'),
       handle: async (request, config, callback) => {
         const response=... ;
          YOUR LOGIC
@@ -434,7 +434,7 @@ const privateKey = ...;
 const publicKey = ...;
 
 lamdaEdge.routes.addRoute({
-      isRoute: (request) => isRequest(request, '/someUrl'),
+      isRoute: async (request) => await isRequest(request, '/someUrl'),
       handle: async (request, config, callback) => {
         if (config.eventType === 'viewer-request') { // original-request, origin-response, viewer-request, viewer-response, local-request
             const response=... ;

__mocks__/fs.js

@@ -0,0 +1,16 @@
+
+const fs = jest.genMockFromModule('fs');
+fs.promises = {};
+fs.promises.readFile = async (fullPath) => {
+  const filename = fullPath.replace(/^.*[\\\/]/, ''); // eslint-disable-line no-useless-escape
+  if (filename === 'storage.json') {
+    return JSON.stringify({
+      'oldId':{
+        exp:0
+      }
+    });
+  }
+  throw new Error('file does not exists');
+};
+fs.promises.writeFile = async () =>{};
+module.exports = fs;

__tests__/src/edge/lambdaEdgeUtilsTest.js

@@ -0,0 +1,184 @@
+jest.mock('../../../src/clientAuthorization');
+jest.mock('jsonwebtoken');
+
+const jsonwebtoken = require('jsonwebtoken');
+const { clientJWT } = require('../../../src/clientAuthorization');
+const {
+  signState,
+  validateState,
+  tenantName,
+  updateResponse,
+  getHostUrl,
+} = require('../../../src/edge/lambdaEdgeUtils');
+
+describe('testing lambdaEdgeUtils', () => {
+  beforeEach(() => {
+    clientJWT.mockImplementation(async () => 'signature');
+    jsonwebtoken.decode.mockImplementation(() => ({
+      header: { alg: 'rs256' },
+    }));
+    jsonwebtoken.verify.mockImplementation(() => ({
+      n: 'undefined-undefined',
+    }));
+  });
+
+  afterEach(() => {
+  });
+
+  test('test signState', async () => {
+    const ret = await signState('/', {
+      logger: console,
+      keycloakJson: {},
+      sessionManager:
+            { sessionOptions: { sessionOptions: {} } },
+    });
+    expect(ret).toEqual('signature');
+  });
+
+  test('test validateState', async () => {
+    const ret = await validateState('Token', {
+      logger: console,
+      keycloakJson: {},
+      sessionManager: {
+        sessionOptions: { keys: { publicKey: { key: 'PUBLIC_KEY' } } },
+      },
+    });
+    expect(ret).toEqual({ n: 'undefined-undefined' });
+  });
+
+  test('test validateState none', async () => {
+    jsonwebtoken.decode.mockImplementation(() => ({
+      header: { alg: 'none' },
+    }));
+    try {
+      await validateState('Token', {
+        logger: console,
+        keycloakJson: {},
+        sessionManager: {
+          sessionOptions: { keys: { publicKey: { key: 'PUBLIC_KEY' } } },
+        },
+      });
+      throw new Error('Unexpected state');
+    } catch (e) {
+      expect(e.message).toEqual('invalid token');
+    }
+  });
+
+
+  test('test validateState invalid token', async () => {
+    jsonwebtoken.decode.mockImplementation(() => ({
+    }));
+    try {
+      await validateState('Token', {
+        logger: console,
+        keycloakJson: {},
+        sessionManager: {
+          sessionOptions: { keys: { publicKey: { key: 'PUBLIC_KEY' } } },
+        },
+      });
+      throw new Error('Unexpected state');
+    } catch (e) {
+      expect(e.message).toEqual('invalid token (header part)');
+    }
+  });
+
+  test('test validateState invalid token 3', async () => {
+    const newVar = await validateState(null, {
+      logger: console,
+      keycloakJson: {},
+      sessionManager: {
+        sessionOptions: { keys: { publicKey: { key: 'PUBLIC_KEY' } } },
+      },
+    });
+    expect(newVar).toEqual(null);
+  });
+
+  test('test validateState invalid token 2', async () => {
+    jsonwebtoken.decode.mockImplementation(() => null);
+    try {
+      await validateState('Token', {
+        logger: console,
+        keycloakJson: {},
+        sessionManager: {
+          sessionOptions: { keys: { publicKey: { key: 'PUBLIC_KEY' } } },
+        },
+      });
+      throw new Error('Unexpected state');
+    } catch (e) {
+      expect(e.message).toEqual('invalid token (header part)');
+    }
+  });
+
+  test('test validateState hs', async () => {
+    jsonwebtoken.decode.mockImplementation(() => ({
+      header: { alg: 'hs64' },
+    }));
+    try {
+      await validateState('Token', {
+        logger: console,
+        keycloakJson: {},
+        sessionManager: {
+          sessionOptions: { keys: { publicKey: { key: 'PUBLIC_KEY' } } },
+        },
+      });
+      throw new Error('Unexpected state');
+    } catch (e) {
+      expect(e.message).toEqual('invalid token');
+    }
+  });
+
+  test('test tenantName', async () => {
+    const tn = tenantName({ realm: 'name', resource: 'resource' });
+    expect(tn).toEqual('name-resource');
+  });
+
+  test('test getHostUrl', async () => {
+    const request = { headers: { referer: [{ value: 'https:/test.com' }] } };
+    const url = getHostUrl(request);
+    expect(url).toEqual('https:/test.com');
+  });
+
+  test('updateResponse test empty', async () => {
+    const request = {};
+    const response = {};
+    updateResponse(request, response);
+    expect(response).toEqual({});
+  });
+
+  test('updateResponse test', async () => {
+    const request = {};
+    const response = {
+      headers: {
+        'set-cookie': [{ value: 'test' }],
+      },
+    };
+    updateResponse(request, response);
+    expect(response).toEqual({
+      headers: {
+        'set-cookie': [
+          {
+            value: 'test',
+          },
+        ],
+      },
+    });
+  });
+  test('updateResponse test 2', async () => {
+    const request = { headers: { referer: [{ value: 'https:/test.com' }] } };
+    const response = {
+      headers: {
+        'set-cookie': [{ value: 'test' }],
+      },
+    };
+    updateResponse(request, response);
+    expect(response).toEqual({
+      headers: {
+        'set-cookie': [
+          {
+            value: 'test; Domain=https:/test.com; Secure',
+          },
+        ],
+      },
+    });
+  });
+});

__tests__/src/edge/lamdaEdgeTest.js

@@ -0,0 +1,60 @@
+jest.mock('../../../src/edge/router');
+jest.mock('../../../src/edge/lambdaEdgeUtils');
+const { getRoute } = require('../../../src/edge/router');
+
+const { updateResponse } = require('../../../src/edge/lambdaEdgeUtils');
+
+const lamdaEdge = require('../../../src/edge/lamdaEdge');
+
+describe('testing lamdaEdge', () => {
+  beforeEach(() => {
+    getRoute.mockImplementation(async () => ({ handle: async (request, config, f) => { f(null, { response: 'test' }); } }));
+    updateResponse.mockImplementation((request, response) => response);
+  });
+
+  afterEach(() => {
+  });
+
+  test('test lambdaEdgeRouter', async () => {
+    await lamdaEdge.lambdaEdgeRouter({
+      Records: [{
+        cf: { request: {}, config: {} },
+      }],
+    }, {}, {}, (error, response) => {
+      expect(response.response).toEqual('test');
+    });
+  });
+
+  test('test lambdaEdgeRouter error', async () => {
+    getRoute.mockImplementation(() => ({ handle: async () => { throw new Error('test'); } }));
+    await lamdaEdge.lambdaEdgeRouter({
+      Records: [{
+        cf: { request: {}, config: {} },
+      }],
+    }, {}, {
+      sessionOptions: {
+        route: {
+          internalServerError: (request, callback) => {
+            callback(null, { response: 'error' });
+          },
+        },
+      },
+    }, (error, response) => {
+      expect(response.response).toEqual('error');
+    });
+  });
+  test('test lambdaEdgeRouter error2', async () => {
+    getRoute.mockImplementation(async () => ({ handle: async () => { throw new Error('test'); } }));
+    await lamdaEdge.lambdaEdgeRouter({ Records: [] }, {}, {
+      sessionOptions: {
+        route: {
+          internalServerError: (request, callback) => {
+            callback(null, { response: 'error' });
+          },
+        },
+      },
+    }, (error, response) => {
+      expect(response.response).toEqual('error');
+    });
+  });
+});

__tests__/src/edge/routerTest.js

@@ -0,0 +1,25 @@
+jest.mock('yallist');
+const yallist = require('yallist');
+
+yallist.create.mockImplementation(() => ({
+  toArray: () => [{ name: 'test', isRoute: () => true }],
+  push: () => {
+  },
+
+}));
+const router = require('../../../src/edge/router');
+
+describe('testing edgeRouter', () => {
+  beforeEach(() => {
+
+  });
+
+  afterEach(() => {
+  });
+
+  test('test registerRoute/getRouter', async () => {
+    router.registerRoute({});
+    const route = await router.getRoute({}, {});
+    expect(route.name).toEqual('test');
+  });
+});