@mojaloop/central-ledger 9.2.2 → 15.1.3-snapshot.2

package/test/unit/models/participant/facade.test.js

@@ -30,17 +30,33 @@
 const Test = require('tapes')(require('tape'))
 const Sinon = require('sinon')
 const Db = require('../../../../src/lib/db')
+const Cache = require('../../../../src/lib/cache')
 const Logger = require('@mojaloop/central-services-logger')
-const Model = require('../../../../src/models/participant/facade')
+const Proxyquire = require('proxyquire').callThru()
+const Model = Proxyquire('../../../../src/models/participant/facade', {
+  '../../lib/config': {
+    HUB_NAME: 'Hub'
+  }
+})
 const Enum = require('@mojaloop/central-services-shared').Enum
+const ParticipantModel = require('../../../../src/models/participant/participantCached')
 const ParticipantCurrencyModel = require('../../../../src/models/participant/participantCurrencyCached')
+const ParticipantLimitModel = require('../../../../src/models/participant/participantLimitCached')
+const SettlementModel = require('../../../../src/models/settlement/settlementModel')
 
 Test('Participant facade', async (facadeTest) => {
   let sandbox
 
   facadeTest.beforeEach(t => {
     sandbox = Sinon.createSandbox()
+    sandbox.stub(ParticipantModel, 'getById')
+    sandbox.stub(ParticipantModel, 'getByName')
+    sandbox.stub(ParticipantCurrencyModel, 'findOneByParams')
     sandbox.stub(ParticipantCurrencyModel, 'invalidateParticipantCurrencyCache')
+    sandbox.stub(ParticipantLimitModel, 'getByParticipantCurrencyId')
+    sandbox.stub(ParticipantLimitModel, 'invalidateParticipantLimitCache')
+    sandbox.stub(SettlementModel, 'getAll')
+    sandbox.stub(Cache)
     Db.participant = {
       query: sandbox.stub()
     }
@@ -56,6 +72,9 @@ Test('Participant facade', async (facadeTest) => {
     Db.participantPosition = {
       query: sandbox.stub()
     }
+    Db.from = (table) => {
+      return Db[table]
+    }
     t.end()
   })
 
@@ -97,8 +116,38 @@ Test('Participant facade', async (facadeTest) => {
       name: 'ALARM_NOTIFICATION_URL'
     }
   ]
+  const settlementModelFixtures = [
+    {
+      settlementModelId: 1,
+      name: 'DEFERREDNET',
+      isActive: 1,
+      settlementGranularityId: 2,
+      settlementInterchangeId: 2,
+      settlementDelayId: 2,
+      currencyId: 'USD',
+      requireLiquidityCheck: 1,
+      ledgerAccountTypeId: 1,
+      autoPositionReset: 1,
+      adjustPosition: 0,
+      settlementAccountTypeId: 2
+    },
+    {
+      settlementModelId: 2,
+      name: 'INTERCHANGEFEE',
+      isActive: 1,
+      settlementGranularityId: 2,
+      settlementInterchangeId: 2,
+      settlementDelayId: 2,
+      currencyId: 'USD',
+      requireLiquidityCheck: 0,
+      ledgerAccountTypeId: 5,
+      autoPositionReset: 1,
+      adjustPosition: 0,
+      settlementAccountTypeId: 6
+    }
+  ]
 
-  await facadeTest.test('getByNameAndCurrency', async (assert) => {
+  await facadeTest.test('getByNameAndCurrency (cache off)', async (assert) => {
     try {
       const builderStub = sandbox.stub()
       Db.participant.query.callsArgWith(0, builderStub)
@@ -126,7 +175,7 @@ Test('Participant facade', async (facadeTest) => {
     }
   })
 
-  await facadeTest.test('getByNameAndCurrency', async (assert) => {
+  await facadeTest.test('getByNameAndCurrency (cache off)', async (assert) => {
     try {
       const builderStub = sandbox.stub()
       Db.participant.query.callsArgWith(0, builderStub)
@@ -156,7 +205,7 @@ Test('Participant facade', async (facadeTest) => {
     }
   })
 
-  await facadeTest.test('getByNameAndCurrency should throw error', async (assert) => {
+  await facadeTest.test('getByNameAndCurrency should throw error (cache off)', async (assert) => {
     try {
       Db.participant.query.throws(new Error('message'))
       await Model.getByNameAndCurrency({ name: 'fsp1', currencyId: 'USD', ledgerAccountTypeId: 1 })
@@ -169,11 +218,11 @@ Test('Participant facade', async (facadeTest) => {
     }
   })
 
-  await facadeTest.test('getByNameAndCurrency should throw error when participant not found', async (assert) => {
+  await facadeTest.test('getByNameAndCurrency should throw error when participant not found (cache off)', async (assert) => {
     try {
       Db.participant.query.throws(new Error('message'))
       await Model.getByNameAndCurrency({ name: 'fsp3', currencyId: 'USD', ledgerAccountTypeId: 1 })
-      assert.fail(' should throw')
+      assert.fail('should throw')
       assert.end()
     } catch (err) {
       Logger.error(`getByNameAndCurrency failed with error - ${err}`)
@@ -182,6 +231,49 @@ Test('Participant facade', async (facadeTest) => {
     }
   })
 
+  await facadeTest.test('getByNameAndCurrency (cache on)', async (assert) => {
+    try {
+      Cache.isCacheEnabled.returns(true)
+
+      ParticipantModel.getByName.withArgs(participant.name).returns(participant)
+      ParticipantCurrencyModel.findOneByParams.withArgs({
+        participantId: participant.participantId,
+        currencyId: participant.currency,
+        ledgerAccountTypeId: Enum.Accounts.LedgerAccountType.POSITION
+      }).returns(participant)
+
+      const result = await Model.getByNameAndCurrency(participant.name, participant.currency, Enum.Accounts.LedgerAccountType.POSITION)
+      assert.deepEqual(result, participant)
+      assert.end()
+    } catch (err) {
+      Logger.error(`getByNameAndCurrency failed with error - ${err}`)
+      assert.fail()
+      assert.end()
+    }
+  })
+
+  await facadeTest.test('getByNameAndCurrency isCurrencyActive:true (cache on)', async (assert) => {
+    try {
+      Cache.isCacheEnabled.returns(true)
+
+      ParticipantModel.getByName.withArgs(participant.name).returns(participant)
+      ParticipantCurrencyModel.findOneByParams.withArgs({
+        participantId: participant.participantId,
+        currencyId: participant.currency,
+        ledgerAccountTypeId: Enum.Accounts.LedgerAccountType.POSITION,
+        isActive: true
+      }).returns(participant)
+
+      const result = await Model.getByNameAndCurrency(participant.name, participant.currency, Enum.Accounts.LedgerAccountType.POSITION, true)
+      assert.deepEqual(result, participant)
+      assert.end()
+    } catch (err) {
+      Logger.error(`getByNameAndCurrency failed with error - ${err}`)
+      assert.fail()
+      assert.end()
+    }
+  })
+
   await facadeTest.test('getEndpoint', async (assert) => {
     try {
       const builderStub = sandbox.stub()
@@ -438,7 +530,7 @@ Test('Participant facade', async (facadeTest) => {
     }
   })
 
-  await facadeTest.test('addLimitAndInitialPosition', async (assert) => {
+  await facadeTest.test('addLimitAndInitialPosition with settlementModel', async (assert) => {
     try {
       const limitPositionObj = {
         currency: 'USD',
@@ -468,32 +560,89 @@ Test('Participant facade', async (facadeTest) => {
           insert: insertStub
         })
       })
-      const participantPosition = {
-        participantCurrencyId: 1,
-        value: limitPositionObj.initialPosition,
-        reservedValue: 0,
-        participantPositionId: 1
-      }
-      const settlementPosition = {
-        participantCurrencyId: 2,
-        value: 0,
-        reservedValue: 0,
-        participantPositionId: 1
-      }
-      const participantLimit = {
-        participantCurrencyId: 1,
-        participantLimitTypeId: 1,
-        value: limitPositionObj.limit.value,
-        isActive: 1,
-        createdBy: 'unknown',
-        participantLimitId: 1
+      const builderStub = sandbox.stub()
+      Db.participant.query.callsArgWith(0, builderStub)
+      builderStub.where = sandbox.stub()
+
+      builderStub.where.returns({
+        andWhere: sandbox.stub().returns({
+          andWhere: sandbox.stub().returns({
+            innerJoin: sandbox.stub().returns({
+              select: sandbox.stub().returns({
+                first: sandbox.stub().returns(participant)
+              })
+            })
+          })
+        })
+      })
+
+      SettlementModel.getAll.returns(Promise.resolve(settlementModelFixtures))
+      const result = await Model.addLimitAndInitialPosition(participant.participantCurrencyId, participant.settlementAccountId, limitPositionObj)
+      assert.pass('completed successfully')
+      assert.ok(knexStub.withArgs('participantLimit').calledOnce, 'knex called with participantLimit once')
+      assert.equal(knexStub.withArgs('participantPosition').callCount, 4, 'knex called with participantPosition 4 times')
+      assert.equal(result, true)
+
+      assert.end()
+    } catch (err) {
+      Logger.error(`addLimitAndInitialPosition failed with error - ${err}`)
+      assert.fail()
+      assert.end()
+    }
+  })
+
+  await facadeTest.test('addLimitAndInitialPosition without settlementModel', async (assert) => {
+    try {
+      const limitPositionObj = {
+        currency: 'USD',
+        limit: {
+          type: 'NET_DEBIT_CAP',
+          value: 10000000
+        },
+        initialPosition: 0
       }
+      sandbox.stub(Db, 'getKnex')
+      const knexStub = sandbox.stub()
+      const trxStub = sandbox.stub()
+      trxStub.commit = sandbox.stub()
+      knexStub.transaction = sandbox.stub().callsArgWith(0, trxStub)
+      Db.getKnex.returns(knexStub)
+
+      const insertStub = sandbox.stub()
+      insertStub.returns([1])
+
+      knexStub.returns({
+        where: sandbox.stub().returns({
+          select: sandbox.stub().returns({
+            first: sandbox.stub().returns({ participantLimitTypeId: 1 })
+          })
+        }),
+        transacting: sandbox.stub().returns({
+          insert: insertStub
+        })
+      })
+      const builderStub = sandbox.stub()
+      Db.participant.query.callsArgWith(0, builderStub)
+      builderStub.where = sandbox.stub()
+
+      builderStub.where.returns({
+        andWhere: sandbox.stub().returns({
+          andWhere: sandbox.stub().returns({
+            innerJoin: sandbox.stub().returns({
+              select: sandbox.stub().returns({
+                first: sandbox.stub().returns(participant)
+              })
+            })
+          })
+        })
+      })
 
+      SettlementModel.getAll.returns(Promise.resolve([]))
       const result = await Model.addLimitAndInitialPosition(participant.participantCurrencyId, participant.settlementAccountId, limitPositionObj)
       assert.pass('completed successfully')
       assert.ok(knexStub.withArgs('participantLimit').calledOnce, 'knex called with participantLimit once')
-      assert.ok(knexStub.withArgs('participantPosition').calledTwice, 'knex called with participantPosition once')
-      assert.deepEqual(result, { participantLimit, participantPosition, settlementPosition })
+      assert.equal(knexStub.withArgs('participantPosition').callCount, 2, 'knex called with participantPosition 2 times')
+      assert.equal(result, true)
 
       assert.end()
     } catch (err) {
@@ -511,7 +660,8 @@ Test('Participant facade', async (facadeTest) => {
           type: 'NET_DEBIT_CAP',
           value: 10000000
         },
-        initialPosition: 0
+        initialPosition: 0,
+        name: participant.name
       }
       sandbox.stub(Db, 'getKnex')
       const knexStub = sandbox.stub()
@@ -539,32 +689,28 @@ Test('Participant facade', async (facadeTest) => {
           })
         })
       })
-      const participantPosition = {
-        participantCurrencyId: 1,
-        value: limitPositionObj.initialPosition,
-        reservedValue: 0,
-        participantPositionId: 1
-      }
-      const settlementPosition = {
-        participantCurrencyId: 2,
-        value: 0,
-        reservedValue: 0,
-        participantPositionId: 1
-      }
-      const participantLimit = {
-        participantCurrencyId: 1,
-        participantLimitTypeId: 1,
-        value: limitPositionObj.limit.value,
-        isActive: 1,
-        createdBy: 'unknown',
-        participantLimitId: 1
-      }
+      const builderStub = sandbox.stub()
+      Db.participant.query.callsArgWith(0, builderStub)
+      builderStub.where = sandbox.stub()
 
+      builderStub.where.returns({
+        andWhere: sandbox.stub().returns({
+          andWhere: sandbox.stub().returns({
+            innerJoin: sandbox.stub().returns({
+              select: sandbox.stub().returns({
+                first: sandbox.stub().returns(participant)
+              })
+            })
+          })
+        })
+      })
+
+      SettlementModel.getAll.returns(Promise.resolve(settlementModelFixtures))
       const result = await Model.addLimitAndInitialPosition(participant.participantCurrencyId, participant.settlementAccountId, limitPositionObj, true)
       assert.pass('completed successfully')
       assert.ok(knexStub.withArgs('participantLimit').calledOnce, 'knex called with participantLimit once')
-      assert.ok(knexStub.withArgs('participantPosition').calledTwice, 'knex called with participantPosition once')
-      assert.deepEqual(result, { participantLimit, participantPosition, settlementPosition })
+      assert.equal(knexStub.withArgs('participantPosition').callCount, 4, 'knex called with participantPosition 4 times')
+      assert.equal(result, true)
 
       assert.end()
     } catch (err) {
@@ -1024,7 +1170,7 @@ Test('Participant facade', async (facadeTest) => {
     }
   })
 
-  await facadeTest.test('getParticipantLimitByParticipantCurrencyLimit', async (assert) => {
+  await facadeTest.test('getParticipantLimitByParticipantCurrencyLimit (cache off)', async (assert) => {
     try {
       const participantLimit = {
         participantId: 1,
@@ -1061,7 +1207,7 @@ Test('Participant facade', async (facadeTest) => {
     }
   })
 
-  await facadeTest.test('getParticipantLimitByParticipantCurrencyLimit should throw error', async (assert) => {
+  await facadeTest.test('getParticipantLimitByParticipantCurrencyLimit (cache off) should throw error', async (assert) => {
     try {
       const builderStub = sandbox.stub()
       Db.participant.query.callsArgWith(0, builderStub)
@@ -1073,7 +1219,6 @@ Test('Participant facade', async (facadeTest) => {
       await Model.getParticipantLimitByParticipantCurrencyLimit(participant.participantId, participant.currency, ledgerAccountTypeId, participantLimitTypeId)
       assert.fail(' should throw')
       assert.end()
-      assert.end()
     } catch (err) {
       Logger.error(`getParticipantLimitByParticipantCurrencyLimit failed with error - ${err}`)
       assert.pass('Error thrown')
@@ -1081,6 +1226,166 @@ Test('Participant facade', async (facadeTest) => {
     }
   })
 
+  await facadeTest.test('getParticipantLimitByParticipantCurrencyLimit (cache on)', async (assert) => {
+    try {
+      /* Setup case for full pass - return of data */
+      Cache.isCacheEnabled.returns(true)
+
+      const participantLimitData = {
+        participantId: 123,
+        currencyId: 456,
+        participantLimitTypeId: 789,
+        value: 1000000
+      }
+      const ledgerAccountTypeId = 1
+      const participantLimitTypeId = 2
+
+      const setupMockData = () => {
+        ParticipantModel.getById.withArgs(participantLimitData.participantId).returns({
+          participantId: participantLimitData.participantId,
+          isActive: true
+        })
+        ParticipantCurrencyModel.findOneByParams.returns({
+          participantCurrencyId: 321,
+          currencyId: participantLimitData.currencyId,
+          isActive: true
+        })
+        ParticipantLimitModel.getByParticipantCurrencyId.withArgs(321).returns({
+          isActive: true,
+          ...participantLimitData
+        })
+      }
+
+      const callGetParticipantLimitByParticipantCurrencyLimit = async () => {
+        return Model.getParticipantLimitByParticipantCurrencyLimit(
+          participantLimitData.participantId,
+          participantLimitData.currency,
+          ledgerAccountTypeId,
+          participantLimitTypeId
+        )
+      }
+
+      /* Check the data is returned correctly for correct setup of data in cache */
+      setupMockData()
+      const result = await callGetParticipantLimitByParticipantCurrencyLimit()
+      assert.deepEqual(result, participantLimitData, 'should return correct data')
+
+      /* Setup case for failure #1: can't find participant by participantId */
+      ParticipantModel.getById.withArgs(participantLimitData.participantId).returns()
+      const result2 = await callGetParticipantLimitByParticipantCurrencyLimit()
+      assert.deepEqual(result2, undefined, 'should return nothing when cannot find by participantId')
+
+      /* Ensure the data is returned correctly for correct setup of data in cache */
+      setupMockData()
+      const result3 = await callGetParticipantLimitByParticipantCurrencyLimit()
+      assert.deepEqual(result3, participantLimitData, 'should return correct data')
+
+      /* Setup case for failure #2: can't find participantCurrency */
+      ParticipantCurrencyModel.findOneByParams.returns()
+      const result4 = await callGetParticipantLimitByParticipantCurrencyLimit()
+      assert.deepEqual(result4, undefined, 'should return nothing when cannot find participantCurrency')
+
+      /* Ensure the data is returned correctly for correct setup of data in cache */
+      setupMockData()
+      const result5 = await callGetParticipantLimitByParticipantCurrencyLimit()
+      assert.deepEqual(result5, participantLimitData, 'should return correct data')
+
+      /* Setup case for failure #3: can't find participantLimit data */
+      ParticipantLimitModel.getByParticipantCurrencyId.withArgs(321).returns()
+      const result6 = await callGetParticipantLimitByParticipantCurrencyLimit()
+      assert.deepEqual(result6, undefined, 'should return nothing when cannot find participantLimit')
+
+      assert.end()
+    } catch (err) {
+      Logger.error(`getParticipantLimitByParticipantCurrencyLimit failed with error - ${err}`)
+      assert.fail()
+      assert.end()
+    }
+  })
+
+  await facadeTest.test('getParticipantLimitByParticipantCurrencyLimit returns undefined when participant not found by participantId (cache on)', async (assert) => {
+    try {
+      Cache.isCacheEnabled.returns(true)
+
+      const participantLimitData = {
+        participantId: 123,
+        currencyId: 456,
+        participantLimitTypeId: 789,
+        value: 1000000
+      }
+      const ledgerAccountTypeId = 1
+      const participantLimitTypeId = 2
+
+      ParticipantModel.getById.withArgs(participantLimitData.participantId).returns()
+
+      const result = await Model.getParticipantLimitByParticipantCurrencyLimit(
+        participantLimitData.participantId,
+        participantLimitData.currency,
+        ledgerAccountTypeId,
+        participantLimitTypeId
+      )
+      assert.deepEqual(result, undefined, 'should return undefined')
+      assert.end()
+    } catch (err) {
+      Logger.error(`getParticipantLimitByParticipantCurrencyLimit failed with error - ${err}`)
+      assert.fail()
+      assert.end()
+    }
+  })
+
+  await facadeTest.test('getParticipantLimitByParticipantCurrencyLimit returns undefined when participantCurrency not found by currencyId (cache on)', async (assert) => {
+    try {
+      Cache.isCacheEnabled.returns(true)
+
+      const participantLimitData = {
+        participantId: 123,
+        currencyId: 456,
+        participantLimitTypeId: 789,
+        value: 1000000
+      }
+      const ledgerAccountTypeId = 1
+      const participantLimitTypeId = 2
+
+      ParticipantModel.getById.withArgs(participantLimitData.participantId).returns({
+        participantId: participantLimitData.participantId,
+        isActive: true
+      })
+      ParticipantCurrencyModel.findOneByParams.returns()
+
+      const result = await Model.getParticipantLimitByParticipantCurrencyLimit(
+        participantLimitData.participantId,
+        participantLimitData.currency,
+        ledgerAccountTypeId,
+        participantLimitTypeId
+      )
+      assert.deepEqual(result, undefined, 'should return undefined')
+      assert.end()
+    } catch (err) {
+      Logger.error(`getParticipantLimitByParticipantCurrencyLimit failed with error - ${err}`)
+      assert.fail()
+      assert.end()
+    }
+  })
+
+  await facadeTest.test('getParticipantLimitByParticipantCurrencyLimit (cache on) should throw error', async (assert) => {
+    try {
+      Cache.isCacheEnabled.returns(true)
+
+      const ledgerAccountTypeId = 1
+      const participantLimitTypeId = 2
+
+      ParticipantModel.getById.withArgs(participant.participantId).throws(new Error())
+      await Model.getParticipantLimitByParticipantCurrencyLimit(participant.participantId, participant.currency, ledgerAccountTypeId, participantLimitTypeId)
+
+      assert.fail('should throw')
+      assert.end()
+    } catch (err) {
+      Logger.error(`getParticipantLimitByParticipantCurrencyLimit failed with error - ${err}`)
+      assert.pass('Did throw')
+      assert.end()
+    }
+  })
+
   await facadeTest.test('addHubAccountAndInitPosition', async (assert) => {
     try {
       const participantPosition = {
@@ -1455,6 +1760,140 @@ Test('Participant facade', async (facadeTest) => {
       test.end()
     }
   })
+  await facadeTest.test('getAllNonHubParticipantsWithCurrencies should', async (test) => {
+    try {
+      sandbox.stub(Db, 'getKnex')
+      const knexStub = sandbox.stub()
+      const trxStub = {
+        get commit () {
+
+        },
+        get rollback () {
+
+        }
+      }
+      const trxSpyCommit = sandbox.spy(trxStub, 'commit', ['get'])
+
+      knexStub.transaction = sandbox.stub().callsArgWith(0, trxStub)
+      Db.getKnex.returns(knexStub)
+      const transactingStub = sandbox.stub()
+      const distinctStub = sandbox.stub()
+      const fromStub = sandbox.stub()
+      const innerJoinStub = sandbox.stub()
+      const whereNotStub = sandbox.stub()
+      const participantsWithCurrencies = [{
+        participantId: 1,
+        currencyId: 'USD'
+      }]
+      transactingStub.resolves(participantsWithCurrencies)
+      whereNotStub.returns({ transacting: transactingStub })
+      innerJoinStub.returns({ whereNot: whereNotStub })
+      fromStub.returns({ innerJoin: innerJoinStub })
+      knexStub.distinct = distinctStub.returns({ from: fromStub })
+
+      const response = await Model.getAllNonHubParticipantsWithCurrencies(trxStub)
+      test.equal(whereNotStub.lastCall.args[0], 'participant.name', 'filter on participants name')
+      test.equal(whereNotStub.lastCall.args[1], 'Hub', 'filter out the Hub')
+      test.equal(transactingStub.lastCall.args[0], trxStub, 'run as transaction')
+      test.equal(trxSpyCommit.get.calledOnce, false, 'not commit the transaction if transaction is passed')
+      test.deepEqual(response, participantsWithCurrencies, 'return participants with currencies')
+      test.end()
+    } catch (err) {
+      Logger.error(`getAllNonHubParticipantsWithCurrencies failed with error - ${err}`)
+      test.fail('Error thrown')
+      test.end()
+    }
+  })
+
+  await facadeTest.test('getAllNonHubParticipantsWithCurrencies should', async (test) => {
+    try {
+      sandbox.stub(Db, 'getKnex')
+      const knexStub = sandbox.stub()
+      const trxStub = {
+        get commit () {
+
+        },
+        get rollback () {
+
+        }
+      }
+      const trxSpyCommit = sandbox.spy(trxStub, 'commit', ['get'])
+
+      knexStub.transaction = sandbox.stub().callsArgWith(0, trxStub)
+      Db.getKnex.returns(knexStub)
+      const transactingStub = sandbox.stub()
+      const distinctStub = sandbox.stub()
+      const fromStub = sandbox.stub()
+      const innerJoinStub = sandbox.stub()
+      const whereNotStub = sandbox.stub()
+      const participantsWithCurrencies = [{
+        participantId: 1,
+        currencyId: 'USD'
+      }]
+      transactingStub.resolves(participantsWithCurrencies)
+      whereNotStub.returns({ transacting: transactingStub })
+      innerJoinStub.returns({ whereNot: whereNotStub })
+      fromStub.returns({ innerJoin: innerJoinStub })
+      knexStub.distinct = distinctStub.returns({ from: fromStub })
+
+      const response = await Model.getAllNonHubParticipantsWithCurrencies()
+      test.equal(whereNotStub.lastCall.args[0], 'participant.name', 'filter on participants name')
+      test.equal(whereNotStub.lastCall.args[1], 'Hub', 'filter out the Hub')
+      test.equal(transactingStub.lastCall.args[0], trxStub, 'run as transaction')
+      test.equal(trxSpyCommit.get.calledOnce, true, 'commit the transaction if no transaction is passed')
+
+      test.deepEqual(response, participantsWithCurrencies, 'return participants with currencies')
+      test.end()
+    } catch (err) {
+      Logger.error(`getAllNonHubParticipantsWithCurrencies failed with error - ${err}`)
+      test.fail('Error thrown')
+      test.end()
+    }
+  })
+
+  await facadeTest.test('getAllNonHubParticipantsWithCurrencies should', async (test) => {
+    let trxStub
+    try {
+      sandbox.stub(Db, 'getKnex')
+      const knexStub = sandbox.stub()
+      trxStub = sandbox.stub()
+      trxStub.commit = sandbox.stub()
+      trxStub.rollback = sandbox.stub()
+      knexStub.transaction = sandbox.stub().callsArgWith(0, trxStub)
+      Db.getKnex.returns(knexStub)
+      const transactingStub = sandbox.stub()
+      const distinctStub = sandbox.stub()
+      const fromStub = sandbox.stub()
+      const innerJoinStub = sandbox.stub()
+      const whereNotStub = sandbox.stub()
+
+      transactingStub.rejects(new Error())
+      whereNotStub.returns({ transacting: transactingStub })
+      innerJoinStub.returns({ whereNot: whereNotStub })
+      fromStub.returns({ innerJoin: innerJoinStub })
+      knexStub.distinct = distinctStub.returns({ from: fromStub })
+      await Model.getAllNonHubParticipantsWithCurrencies()
+      test.fail('have thrown an error')
+      test.end()
+    } catch (err) {
+      test.pass('throw an error')
+      test.equal(trxStub.rollback.callCount, 0, 'not rollback the transaction if transaction is passed')
+      test.end()
+    }
+  })
+
+  await facadeTest.test('getAllNonHubParticipantsWithCurrencies should', async (test) => {
+    try {
+      sandbox.stub(Db, 'getKnex')
+      Db.getKnex.throws(new Error())
+      await Model.getAllNonHubParticipantsWithCurrencies()
+      test.fail('have thrown an error')
+      test.end()
+    } catch (err) {
+      test.pass('throw an error')
+      test.end()
+    }
+  })
 
   await facadeTest.end()
 })

package/test/unit/models/participant/participant.test.js

@@ -68,6 +68,10 @@ Test('Participant model', async (participantTest) => {
       destroy: sandbox.stub()
     }
 
+    Db.from = (table) => {
+      return Db[table]
+    }
+
     t.end()
   })