From 4a2199bd0595409ab79ed2a5b877df3e8ea708af Mon Sep 17 00:00:00 2001
From: Chris Troutner <chris.troutner@gmail.com>
Date: Sat, 29 May 2021 17:26:59 -0700
Subject: [PATCH] fix(tests): Adding tests that were left out of merge with koa
 upstream

---
 test/e2e/automated/a08-validators.rest-e2e.js | 318 ++++++++++++++++++
 test/e2e/automated/a09-admin.rest-e2e.js      | 116 +++++++
 .../unit/biz-logic/a07-json-files.lib-unit.js | 139 ++++++++
 3 files changed, 573 insertions(+)
 create mode 100644 test/e2e/automated/a08-validators.rest-e2e.js
 create mode 100644 test/e2e/automated/a09-admin.rest-e2e.js
 create mode 100644 test/unit/biz-logic/a07-json-files.lib-unit.js

diff --git a/test/e2e/automated/a08-validators.rest-e2e.js b/test/e2e/automated/a08-validators.rest-e2e.js
new file mode 100644
index 0000000..633936f
--- /dev/null
+++ b/test/e2e/automated/a08-validators.rest-e2e.js
@@ -0,0 +1,318 @@
+const assert = require('chai').assert
+const testUtils = require('../../utils/test-utils')
+
+const Validators = require('../../../src/middleware/validators')
+
+const sinon = require('sinon')
+const mockContext = require('../../unit/mocks/ctx-mock').context
+
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+const context = {}
+
+let sandbox
+let uut
+describe('Validators', () => {
+  before(async () => {
+    // console.log(`config: ${JSON.stringify(config, null, 2)}`)
+
+    // Create a second test user.
+    const userObj = {
+      email: 'testvalidator@test.com',
+      password: 'pass2',
+      name: 'testvalidator'
+    }
+    const testUser = await testUtils.createUser(userObj)
+    // console.log(`testUser2: ${JSON.stringify(testUser, null, 2)}`)
+
+    context.user = testUser.user
+    context.token = testUser.token
+    context.id = testUser.user._id
+
+    // Get the JWT used to log in as the admin 'system' user.
+    const adminJWT = await testUtils.getAdminJWT()
+    // console.log(`adminJWT: ${adminJWT}`)
+    context.adminJWT = adminJWT
+
+    // const admin = await testUtils.loginAdminUser()
+    // context.adminJWT = admin.token
+
+    // const admin = await adminLib.loginAdmin()
+    // console.log(`admin: ${JSON.stringify(admin, null, 2)}`)
+  })
+  beforeEach(() => {
+    uut = new Validators()
+
+    sandbox = sinon.createSandbox()
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('ensureUser()', () => {
+    it('should throw 401 if user cant be found', async () => {
+      try {
+      // Force an error
+        sandbox.stub(uut.User, 'findById').resolves(false)
+
+        // Mock the context object.
+        const ctx = mockContext()
+        ctx.request = {
+          header: {
+            authorization: `Bearer ${context.token}`
+          }
+        }
+
+        await uut.ensureUser(ctx)
+
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 401)
+        assert.include(err.message, 'Unauthorized')
+      }
+    })
+    it('should throw 401 if token not found', async () => {
+      try {
+        // Mock the context object.
+        const ctx = mockContext()
+
+        await uut.ensureUser(ctx)
+
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 401)
+        assert.include(err.message, 'Unauthorized')
+      }
+    })
+    it('should throw 401 if token is invalid', async () => {
+      try {
+        // Mock the context object.
+        const ctx = mockContext()
+        ctx.request = {
+          header: {
+            authorization: 'Bearer 1'
+          }
+        }
+        await uut.ensureUser(ctx)
+
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 401)
+        assert.include(err.message, 'Unauthorized')
+      }
+    })
+    it('should trigger the "next" function if user is admin', async () => {
+      try {
+        // Mock the context object.
+        const ctx = mockContext()
+        ctx.params = { id: context.id }
+
+        ctx.request = {
+          header: {
+            authorization: `Bearer ${context.adminJWT}`
+          }
+        }
+        // Function that execute if the validations
+        // are successful
+        const next = () => { return 'next function' }
+
+        const result = await uut.ensureUser(ctx, next)
+
+        assert.isString(result)
+        assert.equal(result, 'next function')
+      } catch (err) {
+        assert(false, 'Unexpected result')
+      }
+    })
+  })
+
+  describe('ensureAdmin()', () => {
+    it('should throw 401 if token not found', async () => {
+      try {
+        // Mock the context object.
+        const ctx = mockContext()
+
+        await uut.ensureAdmin(ctx)
+
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 401)
+        assert.include(err.message, 'Unauthorized')
+      }
+    })
+    it('should throw 401 if token is invalid', async () => {
+      try {
+        // Mock the context object.
+        const ctx = mockContext()
+        ctx.request = {
+          header: {
+            authorization: 'Bearer 1'
+          }
+        }
+        await uut.ensureAdmin(ctx)
+
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 401)
+        assert.include(err.message, 'Unauthorized')
+      }
+    })
+    it('should throw 401 if user cant be found', async () => {
+      try {
+        // Force an error
+        sandbox.stub(uut.User, 'findById').resolves(false)
+
+        // Mock the context object.
+        const ctx = mockContext()
+        ctx.request = {
+          header: {
+            authorization: `Bearer ${context.token}`
+          }
+        }
+        await uut.ensureAdmin(ctx)
+
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 401)
+        assert.include(err.message, 'Unauthorized')
+      }
+    })
+    it('should throw 401 if user is not admin type', async () => {
+      try {
+        // Mock the context object.
+        const ctx = mockContext()
+        ctx.request = {
+          header: {
+            authorization: `Bearer ${context.token}`
+          }
+        }
+        await uut.ensureAdmin(ctx)
+
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 401)
+        assert.include(err.message, 'not admin')
+      }
+    })
+    it('should trigger the "next" function if user is admin', async () => {
+      try {
+        // Mock the context object.
+        const ctx = mockContext()
+        ctx.request = {
+          header: {
+            authorization: `Bearer ${context.adminJWT}`
+          }
+        }
+        // Function that execute if the validations
+        // are successful
+        const next = () => { return 'next function' }
+
+        const result = await uut.ensureAdmin(ctx, next)
+
+        assert.isString(result)
+        assert.equal(result, 'next function')
+      } catch (err) {
+        assert(false, 'Unexpected result')
+      }
+    })
+  })
+
+  describe('ensureTargetUserOrAdmin()', () => {
+    it('should throw 401 if token not found', async () => {
+      try {
+        // Mock the context object.
+        const ctx = mockContext()
+        ctx.params = { id: context.id }
+        await uut.ensureTargetUserOrAdmin(ctx)
+
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 401)
+        assert.include(err.message, 'Unauthorized')
+      }
+    })
+    it('should throw 401 if token is invalid', async () => {
+      try {
+        // Mock the context object.
+        const ctx = mockContext()
+        ctx.params = { id: context.id }
+
+        ctx.request = {
+          header: {
+            authorization: 'Bearer 1'
+          }
+        }
+        await uut.ensureTargetUserOrAdmin(ctx)
+
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 401)
+        assert.include(err.message, 'Unauthorized')
+      }
+    })
+    it('should throw 401 if user cant be found', async () => {
+      try {
+        // Force an error
+        sandbox.stub(uut.User, 'findById').resolves(false)
+
+        // Mock the context object.
+        const ctx = mockContext()
+        ctx.params = { id: context.id }
+
+        ctx.request = {
+          header: {
+            authorization: `Bearer ${context.token}`
+          }
+        }
+        await uut.ensureTargetUserOrAdmin(ctx)
+
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 401)
+        assert.include(err.message, 'Unauthorized')
+      }
+    })
+    it('should throw 401 if user is not admin type', async () => {
+      try {
+        // Mock the context object.
+        const ctx = mockContext()
+        ctx.params = { id: 'Target Id' }
+
+        ctx.request = {
+          header: {
+            authorization: `Bearer ${context.token}`
+          }
+        }
+        await uut.ensureTargetUserOrAdmin(ctx)
+
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.equal(err.status, 401)
+        assert.include(err.message, 'not admin')
+      }
+    })
+    it('should trigger the "next" function if user is admin', async () => {
+      try {
+        // Mock the context object.
+        const ctx = mockContext()
+        ctx.params = { id: context.id }
+
+        ctx.request = {
+          header: {
+            authorization: `Bearer ${context.adminJWT}`
+          }
+        }
+        // Function that execute if the validations
+        // are successful
+        const next = () => { return 'next function' }
+
+        const result = await uut.ensureTargetUserOrAdmin(ctx, next)
+
+        assert.isString(result)
+        assert.equal(result, 'next function')
+      } catch (err) {
+        assert(false, 'Unexpected result')
+      }
+    })
+  })
+})
diff --git a/test/e2e/automated/a09-admin.rest-e2e.js b/test/e2e/automated/a09-admin.rest-e2e.js
new file mode 100644
index 0000000..2563631
--- /dev/null
+++ b/test/e2e/automated/a09-admin.rest-e2e.js
@@ -0,0 +1,116 @@
+const assert = require('chai').assert
+
+const Admin = require('../../../src/lib/admin')
+
+const sinon = require('sinon')
+
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+let sandbox
+let uut
+describe('Admin', () => {
+  beforeEach(() => {
+    uut = new Admin()
+
+    sandbox = sinon.createSandbox()
+  })
+
+  afterEach(() => sandbox.restore())
+  describe('loginAdmin()', () => {
+    it('should logind admin', async () => {
+      try {
+        const error = new Error('test error')
+        error.response = {
+          status: 422
+        }
+        // sandbox.stub(uut.axios, 'request').onFirstCall().throws(error)
+
+        const result = await uut.loginAdmin()
+        const user = result.data.user
+
+        assert.property(user, '_id')
+        assert.property(user, 'email')
+        assert.property(user, 'type')
+
+        assert.isString(user._id)
+        assert.isString(user.email)
+        assert.isString(user.type)
+
+        assert.equal(user.type, 'admin')
+      } catch (err) {
+        assert(false, 'Unexpected result')
+      }
+    })
+    it('should handle axios error', async () => {
+      try {
+        // Returns an erroneous password to force
+        // an auth error
+        sandbox
+          .stub(uut.jsonFiles, 'readJSON').resolves({ password: 'wrong' })
+
+        await uut.loginAdmin()
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.equal(err.response.status, 401)
+        assert.include(err.response.data, 'Unauthorized')
+      }
+    })
+  })
+  describe('createSystemUser()', () => {
+    it('should create admin', async () => {
+      try {
+        const result = await uut.createSystemUser()
+
+        assert.property(result, 'email')
+        assert.property(result, 'password')
+        assert.property(result, 'id')
+        assert.property(result, 'token')
+      } catch (err) {
+        assert(false, 'Unexpected result')
+      }
+    })
+    it('should handle axios error', async () => {
+      try {
+        const error1 = new Error('test error')
+        error1.response = {
+          status: 422
+        }
+        const error2 = new Error('test error')
+        error1.response = {
+          status: 500
+        }
+        // The loginAdmin() function in some use cases is recursive
+        // after handling the 422 error, it gets called again
+        sandbox
+          .stub(uut.axios, 'request')
+          .onFirstCall()
+          .throws(error1)
+          .onSecondCall()
+          .throws(error2)
+
+        await uut.createSystemUser()
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+    it('should handle errors when remove user', async () => {
+      try {
+        const error1 = new Error('test error')
+        error1.response = {
+          status: 422
+        }
+        sandbox
+          .stub(uut.axios, 'request').throws(error1)
+        sandbox
+          .stub(uut.User, 'deleteOne').throws(new Error('test error'))
+
+        await uut.createSystemUser()
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+})
diff --git a/test/unit/biz-logic/a07-json-files.lib-unit.js b/test/unit/biz-logic/a07-json-files.lib-unit.js
new file mode 100644
index 0000000..a62a485
--- /dev/null
+++ b/test/unit/biz-logic/a07-json-files.lib-unit.js
@@ -0,0 +1,139 @@
+const assert = require('chai').assert
+const fs = require('fs')
+const sinon = require('sinon')
+
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+const JsonFiles = require('../../../src/lib/utils/json-files')
+
+const JSON_FILE = 'test-json-file.json'
+const JSON_PATH = `${__dirname.toString()}/${JSON_FILE}`
+
+const deleteFile = filepath => {
+  try {
+    // Delete state if exist
+    fs.unlinkSync(filepath)
+  } catch (error) {}
+}
+let sandbox
+let uut
+describe('JsonFiles', () => {
+  const obj = {
+    json: 'file'
+  }
+  beforeEach(() => {
+    uut = new JsonFiles()
+    sandbox = sinon.createSandbox()
+  })
+  afterEach(() => sandbox.restore())
+
+  after(() => {
+    deleteFile(JSON_PATH)
+  })
+  describe('writeJSON()', () => {
+    it('should throw error if  inputs is not provided', async () => {
+      try {
+        await uut.writeJSON()
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'obj property is required')
+      }
+    })
+    it('should throw error if  filename property is not provided', async () => {
+      try {
+        await uut.writeJSON(obj)
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'fileName property must be a string')
+      }
+    })
+    it('should throw error if  filename property is not string', async () => {
+      try {
+        await uut.writeJSON(obj, 1)
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'fileName property must be a string')
+      }
+    })
+    it('should throw error if fs library return an error', async () => {
+      try {
+        // https://sinonjs.org/releases/latest/stubs/
+        // About yields
+        sandbox.stub(uut.fs, 'writeFile').yields(new Error('test error'))
+
+        await uut.writeJSON(obj, JSON_PATH)
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+    it('should write a json file', async () => {
+      try {
+        await uut.writeJSON(obj, JSON_PATH)
+
+        assert.isTrue(fs.existsSync(JSON_PATH))
+      } catch (err) {
+        assert(false, 'Unexpected result')
+      }
+    })
+  })
+
+  describe('readJSON()', () => {
+    it('should throw error if  filename property is not provided', async () => {
+      try {
+        await uut.readJSON(obj)
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'fileName property must be a string')
+      }
+    })
+    it('should throw error if  filename property is not string', async () => {
+      try {
+        await uut.readJSON(obj, 1)
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'fileName property must be a string')
+      }
+    })
+    it('should throw error if fs library return an error', async () => {
+      try {
+        // https://sinonjs.org/releases/latest/stubs/
+        // About yields
+        sandbox.stub(uut.fs, 'readFile').yields(new Error('test error'))
+
+        await uut.readJSON(JSON_PATH)
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+    it('should throw error if file not found', async () => {
+      try {
+        const testError = new Error('test error')
+        testError.code = 'ENOENT'
+
+        sandbox.stub(uut.fs, 'readFile').yields(testError)
+
+        await uut.readJSON(JSON_PATH)
+        assert(false, 'Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+
+    it('should read a json file', async () => {
+      try {
+        const result = await uut.readJSON(JSON_PATH)
+
+        const objKeys = Object.keys(obj)
+        const resultKeys = Object.keys(result)
+
+        assert.isObject(result)
+        assert.equal(objKeys.length, resultKeys.length)
+      } catch (err) {
+        assert(false, 'Unexpected result')
+      }
+    })
+  })
+})