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

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

@@ -27,21 +27,34 @@
 
 'use strict'
 
-const Test = require('tape')
+const Test = require('tapes')(require('tape'))
 const Sinon = require('sinon')
 const Db = require('../../../../src/lib/db')
 const Logger = require('@mojaloop/central-services-logger')
 const Model = require('../../../../src/models/participant/participantCurrency')
 
 Test('Participant Currency model', async (participantCurrencyTest) => {
-  const sandbox = Sinon.createSandbox()
-  Db.participantCurrency = {
-    insert: sandbox.stub(),
-    findOne: sandbox.stub(),
-    find: sandbox.stub(),
-    destroy: sandbox.stub(),
-    update: sandbox.stub()
-  }
+  let sandbox
+
+  participantCurrencyTest.beforeEach(t => {
+    sandbox = Sinon.createSandbox()
+    Db.participantCurrency = {
+      insert: sandbox.stub(),
+      findOne: sandbox.stub(),
+      find: sandbox.stub(),
+      destroy: sandbox.stub(),
+      update: sandbox.stub()
+    }
+    Db.from = (table) => {
+      return Db[table]
+    }
+    t.end()
+  })
+
+  participantCurrencyTest.afterEach(t => {
+    sandbox.restore()
+    t.end()
+  })
 
   await participantCurrencyTest.test('create currency for fake participant', async (assert) => {
     Db.participantCurrency.insert.withArgs({ participantId: 3, currencyId: 'FAKE', createdBy: 'unknown' }).throws(new Error('message'))

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

@@ -190,7 +190,7 @@ Test('ParticipantCurrency cached model', async (participantCurrencyCachedTest) =
     Cache.registerCacheClient.returns(cacheClient)
     await Model.initialize()
 
-    // test same things for 4 different functions
+    // test same things for 3 different functions
     const functionsToTest = ['create', 'update', 'destroyByParticipantId']
     for (const functionToTestIdx in functionsToTest) {
       const functionName = functionsToTest[functionToTestIdx]

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

@@ -34,18 +34,34 @@ const Db = require('../../../../src/lib/db')
 const Logger = require('@mojaloop/central-services-logger')
 const ParticipantCurrencyModel = require('../../../../src/models/participant/participantCurrencyCached')
 const Model = require('../../../../src/models/participant/participantLimit')
+const Enum = require('@mojaloop/central-services-shared').Enum
 
 Test('Participant Limit model', async (participantLimitTest) => {
   let sandbox
 
+  const participantLimit1 = {
+    participantCurrencyId: 1,
+    participantLimitTypeId: Enum.Accounts.ParticipantLimitType.NET_DEBIT_CAP,
+    value: 1000,
+    thresholdAlarmPercentage: 10,
+    startAfterParticipantPositionChangeId: null,
+    isActive: true,
+    createDate: new Date(),
+    createdBy: 'unit-testing'
+  }
+
   participantLimitTest.beforeEach(t => {
     sandbox = Sinon.createSandbox()
     Db.participantLimit = {
       insert: sandbox.stub(),
+      update: sandbox.stub(),
       findOne: sandbox.stub(),
       find: sandbox.stub(),
       destroy: sandbox.stub()
     }
+    Db.from = (table) => {
+      return Db[table]
+    }
     t.end()
   })
 
@@ -54,6 +70,87 @@ Test('Participant Limit model', async (participantLimitTest) => {
     t.end()
   })
 
+  await participantLimitTest.test('insert participant limit', async (assert) => {
+    try {
+      Db.participantLimit.insert.withArgs(participantLimit1).returns(1)
+      const result = await Model.insert(participantLimit1)
+      assert.equal(result, 1, `returns ${result}`)
+      assert.end()
+    } catch (err) {
+      Logger.error(`insert participant limit failed with error - ${err}`)
+      assert.fail()
+      assert.end()
+    }
+  })
+
+  await participantLimitTest.test('insert participant limit should throw an error', async (assert) => {
+    try {
+      Db.participantLimit.insert.withArgs(participantLimit1).throws(new Error('message'))
+      await Model.insert(participantLimit1)
+      assert.fail('Error not thrown!')
+      assert.end()
+    } catch (err) {
+      Logger.error(`insert participant limit failed with error - ${err}`)
+      assert.assert(err instanceof Error, 'instance of Error')
+      assert.pass('Error thrown')
+      assert.end()
+    }
+  })
+
+  await participantLimitTest.test('update participant limit', async (assert) => {
+    try {
+      Db.participantLimit.update.withArgs({ participantCurrencyId: participantLimit1.participantCurrencyId }, { value: participantLimit1.value, isActive: participantLimit1.isActive }).returns(1)
+      const result = await Model.update(participantLimit1)
+      assert.equal(result, 1, `returns ${result}`)
+      assert.end()
+    } catch (err) {
+      Logger.error(`update participant limit failed with error - ${err}`)
+      assert.fail()
+      assert.end()
+    }
+  })
+
+  await participantLimitTest.test('update participant limit should throw an error', async (assert) => {
+    try {
+      Db.participantLimit.update.withArgs({ participantCurrencyId: participantLimit1.participantCurrencyId }, { value: participantLimit1.value, isActive: participantLimit1.isActive }).throws(new Error('message'))
+      await Model.update(participantLimit1)
+      assert.fail('Error not thrown!')
+      assert.end()
+    } catch (err) {
+      Logger.error(`update participant limit failed with error - ${err}`)
+      assert.assert(err instanceof Error, 'instance of Error')
+      assert.pass('Error thrown')
+      assert.end()
+    }
+  })
+
+  await participantLimitTest.test('getAll participants limit', async (assert) => {
+    try {
+      Db.participantLimit.find.withArgs({}).returns(1)
+      const result = await Model.getAll()
+      assert.equal(result, 1, `returns ${result}`)
+      assert.end()
+    } catch (err) {
+      Logger.error(`getAll participant limit failed with error - ${err}`)
+      assert.fail()
+      assert.end()
+    }
+  })
+
+  await participantLimitTest.test('getAll participant limit should throw an error', async (assert) => {
+    try {
+      Db.participantLimit.find.withArgs({}).throws(new Error('message'))
+      await Model.getAll()
+      assert.fail('Error not thrown!')
+      assert.end()
+    } catch (err) {
+      Logger.error(`getAll participant limit failed with error - ${err}`)
+      assert.assert(err instanceof Error, 'instance of Error')
+      assert.pass('Error thrown')
+      assert.end()
+    }
+  })
+
   await participantLimitTest.test('getByParticipantCurrencyId', async (assert) => {
     try {
       Db.participantLimit.findOne.withArgs({ participantCurrencyId: 1, isActive: 1 }).returns({

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

@@ -0,0 +1,232 @@
+/*****
+ License
+ --------------
+ Copyright © 2017 Bill & Melinda Gates Foundation
+ The Mojaloop files are made available by the Bill & Melinda Gates Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Gates Foundation organization for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+ * Gates Foundation
+ - Name Surname <name.surname@gatesfoundation.com>
+
+ * Roman Pietrzak <roman.pietrzak@modusbox.com>
+ --------------
+ ******/
+
+'use strict'
+
+const Test = require('tapes')(require('tape'))
+const Sinon = require('sinon')
+const ParticipantLimitUncached = require('../../../../src/models/participant/participantLimit')
+const Cache = require('../../../../src/lib/cache')
+const Model = require('../../../../src/models/participant/participantLimitCached')
+
+Test('Participant Limit cached model', async (participantLimitCachedTest) => {
+  let sandbox
+
+  const participantLimitFixtures = [
+    {
+      participantLimitId: 1,
+      participantCurrencyId: 3,
+      participantLimitTypeId: 1,
+      value: 1000000,
+      thresholdAlarmPercentage: 10,
+      startAfterParticipantPositionChangeId: null,
+      isActive: 1,
+      createdDate: new Date(),
+      createdBy: 'theCreator'
+    },
+    {
+      participantLimitId: 2,
+      participantCurrencyId: 5,
+      participantLimitTypeId: 1,
+      value: 1000000,
+      thresholdAlarmPercentage: 10,
+      startAfterParticipantPositionChangeId: null,
+      isActive: 1,
+      createdDate: new Date(),
+      createdBy: 'theCreator'
+    },
+    {
+      participantLimitId: 3,
+      participantCurrencyId: 7,
+      participantLimitTypeId: 1,
+      value: 1000000,
+      thresholdAlarmPercentage: 10,
+      startAfterParticipantPositionChangeId: null,
+      isActive: 1,
+      createdDate: new Date(),
+      createdBy: 'theCreator'
+    }
+  ]
+
+  participantLimitCachedTest.beforeEach(t => {
+    sandbox = Sinon.createSandbox()
+    sandbox.stub(Cache)
+    sandbox.stub(ParticipantLimitUncached)
+    ParticipantLimitUncached.getAll.returns(participantLimitFixtures)
+    t.end()
+  })
+
+  participantLimitCachedTest.afterEach(t => {
+    sandbox.restore()
+    t.end()
+  })
+
+  await participantLimitCachedTest.test('initializes cache correctly', async (test) => {
+    const cacheClient = {
+      createKey: sandbox.stub().returns({})
+    }
+    Cache.registerCacheClient.returns(cacheClient)
+
+    // initialize calls registerCacheClient and createKey
+    test.notOk(Cache.registerCacheClient.calledOnce)
+    test.notOk(cacheClient.createKey.calledOnce)
+    await Model.initialize()
+    test.ok(Cache.registerCacheClient.calledOnce)
+    test.ok(cacheClient.createKey.calledOnce)
+
+    test.end()
+  })
+
+  await participantLimitCachedTest.test('calls drop() for invalidateParticipantLimitCache', async (test) => {
+    // initialize
+    const cacheClient = {
+      createKey: sandbox.stub().returns({}),
+      drop: sandbox.stub()
+    }
+    Cache.registerCacheClient.returns(cacheClient)
+    await Model.initialize()
+
+    // check
+    test.notOk(cacheClient.drop.calledOnce)
+    await Model.invalidateParticipantLimitCache()
+    test.ok(cacheClient.drop.calledOnce)
+
+    test.end()
+  })
+
+  await participantLimitCachedTest.test('getByParticipantCurrencyId() works and manages cache correctly', async (test) => {
+    let cache = null
+    let cacheGetCallsCnt = 0
+    let cacheSetCallsCnt = 0
+    const cacheClient = {
+      createKey: sandbox.stub().returns({}),
+      get: () => {
+        cacheGetCallsCnt++
+        return cache
+      },
+      set: (key, x) => {
+        cache = { item: x } // the cache retuns {item: <data>} structure
+        cacheSetCallsCnt++
+      }
+    }
+    Cache.registerCacheClient.returns(cacheClient)
+    await Model.initialize()
+
+    // make sure get/set wasn't called during inits
+    test.equal(cacheGetCallsCnt, 0, 'no cache.get() called')
+    test.equal(cacheSetCallsCnt, 0, 'no cache.set() called')
+
+    // check getById()
+    let participantByParticipantId = await Model.getByParticipantCurrencyId(participantLimitFixtures[1].participantCurrencyId)
+    test.equal(JSON.stringify(participantByParticipantId), JSON.stringify(participantLimitFixtures[1]), 'getByParticipantId(<arg>) works')
+
+    // check that get/set was called once when getByParticipantCurrencyId() for the 1st time
+    test.equal(cacheGetCallsCnt, 1, 'cache.get() called once')
+    test.equal(cacheSetCallsCnt, 1, 'cache.set() called once')
+
+    // check getById()
+    participantByParticipantId = await Model.getByParticipantCurrencyId(participantLimitFixtures[1].participantCurrencyId)
+    test.equal(JSON.stringify(participantByParticipantId), JSON.stringify(participantLimitFixtures[1]), 'getByParticipantId(<arg>) works')
+
+    // check that get called again, but set wasn't
+    test.equal(cacheGetCallsCnt, 2, 'cache.get() called twice')
+    test.equal(cacheSetCallsCnt, 1, 'cache.set() called once')
+
+    test.end()
+  })
+
+  await participantLimitCachedTest.test('insert(), update(), destroyByParticipantCurrencyId() and destroyByParticipantId() call the participant-limit model and cache invalidation', async (test) => {
+    const cacheClient = {
+      createKey: sandbox.stub().returns({}),
+      get: () => null
+    }
+    sandbox.stub(Model, 'invalidateParticipantLimitCache')
+
+    Cache.registerCacheClient.returns(cacheClient)
+    await Model.initialize()
+
+    // test same things for 4 different functions
+    const functionsToTest = ['insert', 'update', 'destroyByParticipantCurrencyId', 'destroyByParticipantId']
+    for (const functionToTestIdx in functionsToTest) {
+      const functionName = functionsToTest[functionToTestIdx]
+
+      // make sure nothing was called before
+      test.ok(Model.invalidateParticipantLimitCache.notCalled, 'invalidateParticipantLimitCache() not yet called')
+      test.ok(ParticipantLimitUncached[functionName].notCalled, `ParticipantLimitUncached.${functionName}() not yet called`)
+
+      // call the function
+      await Model[functionName]({})
+
+      // check invalidateParticipantLimitCache and function under test was called once
+      test.ok(Model.invalidateParticipantLimitCache.calledOnce, 'invalidateParticipantLimitCache() called once')
+      test.ok(ParticipantLimitUncached[functionName].calledOnce, `ParticipantLimitUncached.${functionName}() called once`)
+
+      // cleanup
+      Model.invalidateParticipantLimitCache.resetHistory()
+    }
+
+    test.end()
+  })
+
+  await participantLimitCachedTest.test('insert(), update(), destroyByParticipantCurrencyId() and destroyByParticipantId() fail when error thrown', async (test) => {
+    const cacheClient = {
+      createKey: sandbox.stub().returns({}),
+      get: () => null
+    }
+    sandbox.stub(Model, 'invalidateParticipantLimitCache')
+
+    Cache.registerCacheClient.returns(cacheClient)
+    await Model.initialize()
+
+    // test same things for 4 different functions
+    const functionsToTest = ['insert', 'update', 'destroyByParticipantCurrencyId', 'destroyByParticipantId']
+    for (const functionToTestIdx in functionsToTest) {
+      const functionName = functionsToTest[functionToTestIdx]
+
+      ParticipantLimitUncached[functionName].throws(new Error())
+
+      // make sure nothing was called before
+      test.ok(Model.invalidateParticipantLimitCache.notCalled, 'invalidateParticipantLimitCache() not yet called')
+      test.ok(ParticipantLimitUncached[functionName].notCalled, `ParticipantLimitUncached.${functionName}() not yet called`)
+
+      // call the function
+      try {
+        await Model[functionName]({})
+        test.fail(`Error not thrown for ${functionName}`)
+      } catch (err) {
+        test.pass(`Error thrown for ${functionName}`)
+      }
+
+      // check invalidateParticipantLimitCache and function under test was called once
+      test.ok(Model.invalidateParticipantLimitCache.notCalled, 'invalidateParticipantLimitCache() not called, as the error was thrown')
+
+      // cleanup
+      Model.invalidateParticipantLimitCache.resetHistory()
+    }
+
+    test.end()
+  })
+
+  await participantLimitCachedTest.end()
+})

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

@@ -46,6 +46,9 @@ Test('Participant Position model', async (participantPositionTest) => {
       find: sandbox.stub(),
       destroy: sandbox.stub()
     }
+    Db.from = (table) => {
+      return Db[table]
+    }
     t.end()
   })
 
@@ -154,5 +157,219 @@ Test('Participant Position model', async (participantPositionTest) => {
     }
   })
 
+  await participantPositionTest.test('createParticipantPositionRecords should', async (test) => {
+    try {
+      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 transactingStub = sandbox.stub()
+      const batchInsertStub = sandbox.stub()
+      transactingStub.resolves()
+      knexStub.batchInsert = batchInsertStub.returns({ transacting: transactingStub })
+      const participantPositions = [
+        {
+          participantPositionId: 1,
+          participantCurrencyId: 1,
+          value: 0.000,
+          reservedValue: 0.000
+        },
+        {
+          participantPositionId: 1,
+          participantCurrencyId: 2,
+          value: 0.000,
+          reservedValue: 0.000
+        }
+      ]
+      await Model.createParticipantPositionRecords(participantPositions, trxStub)
+      test.equal(batchInsertStub.callCount, 1, 'call batch insert')
+      test.equal(batchInsertStub.lastCall.args[0], 'participantPosition', 'write to the participantPosition table')
+      test.deepEqual(batchInsertStub.lastCall.args[1], participantPositions, 'all records should be inserted')
+      test.equal(transactingStub.callCount, 1, 'make the database calls as transaction')
+      test.equal(transactingStub.lastCall.args[0], trxStub, 'run as transaction')
+      test.equal(trxStub.commit.callCount, 0, 'not commit the transaction if transaction is passed')
+      test.end()
+    } catch (err) {
+      Logger.error(`createParticipantPositionRecords failed with error - ${err}`)
+      test.fail('Error thrown')
+      test.end()
+    }
+  })
+
+  await participantPositionTest.test('createParticipantPositionRecords 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 batchInsertStub = sandbox.stub()
+      transactingStub.resolves()
+      knexStub.batchInsert = batchInsertStub.returns({ transacting: transactingStub })
+      const participantPositions = [
+        {
+          participantPositionId: 1,
+          participantCurrencyId: 1,
+          value: 0.000,
+          reservedValue: 0.000
+        },
+        {
+          participantPositionId: 1,
+          participantCurrencyId: 2,
+          value: 0.000,
+          reservedValue: 0.000
+        }
+      ]
+      await Model.createParticipantPositionRecords(participantPositions)
+      test.equal(batchInsertStub.callCount, 1, 'call batch insert')
+      test.equal(batchInsertStub.lastCall.args[0], 'participantPosition', 'write to the participantPosition table')
+      test.deepEqual(batchInsertStub.lastCall.args[1], participantPositions, 'all records should be inserted')
+      test.equal(transactingStub.callCount, 1, 'make the database calls as transaction')
+      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.end()
+    } catch (err) {
+      Logger.error(`createParticipantPositionRecords failed with error - ${err}`)
+      test.fail('Error thrown')
+      test.end()
+    }
+  })
+
+  await participantPositionTest.test('createParticipantPositionRecords should', async (test) => {
+    let trxStub
+    let trxSpyRollBack
+
+    try {
+      sandbox.stub(Db, 'getKnex')
+      const knexStub = sandbox.stub()
+      trxStub = {
+        get commit () {
+
+        },
+        get rollback () {
+
+        }
+      }
+      trxSpyRollBack = sandbox.spy(trxStub, 'rollback', ['get'])
+
+      knexStub.transaction = sandbox.stub().callsArgWith(0, trxStub)
+      Db.getKnex.returns(knexStub)
+      const transactingStub = sandbox.stub()
+      const batchInsertStub = sandbox.stub()
+      transactingStub.rejects(new Error())
+      knexStub.batchInsert = batchInsertStub.returns({ transacting: transactingStub })
+
+      const participantPositions = [
+        {
+          participantPositionId: 1,
+          participantCurrencyId: 1,
+          value: 0.000,
+          reservedValue: 0.000
+        },
+        {
+          participantPositionId: 1,
+          participantCurrencyId: 2,
+          value: 0.000,
+          reservedValue: 0.000
+        }
+      ]
+      await Model.createParticipantPositionRecords(participantPositions)
+      test.fail('have thrown an error')
+      test.end()
+    } catch (err) {
+      test.pass('throw an error')
+      test.equal(trxSpyRollBack.get.calledOnce, true, 'rollback the transaction if no transaction is passed')
+      test.end()
+    }
+  })
+
+  await participantPositionTest.test('createParticipantCurrencyRecords should', async (test) => {
+    let trxStub
+    let trxSpyRollBack
+
+    try {
+      sandbox.stub(Db, 'getKnex')
+      const knexStub = sandbox.stub()
+      trxStub = {
+        get commit () {
+
+        },
+        get rollback () {
+
+        }
+      }
+      trxSpyRollBack = sandbox.spy(trxStub, 'rollback', ['get'])
+
+      knexStub.transaction = sandbox.stub().callsArgWith(0, [trxStub, true])
+      Db.getKnex.returns(knexStub)
+      const transactingStub = sandbox.stub()
+      const batchInsertStub = sandbox.stub()
+      transactingStub.rejects(new Error())
+      knexStub.batchInsert = batchInsertStub.returns({ transacting: transactingStub })
+
+      const participantPositions = [
+        {
+          participantPositionId: 1,
+          participantCurrencyId: 1,
+          value: 0.000,
+          reservedValue: 0.000
+        },
+        {
+          participantPositionId: 1,
+          participantCurrencyId: 2,
+          value: 0.000,
+          reservedValue: 0.000
+        }
+      ]
+      await Model.createParticipantPositionRecords(participantPositions)
+      test.fail('have thrown an error')
+      test.end()
+    } catch (err) {
+      test.pass('throw an error')
+      test.equal(trxSpyRollBack.get.calledOnce, false, 'not rollback the transaction if  transaction is passed')
+      test.end()
+    }
+  })
+
+  await participantPositionTest.test('createParticipantCurrencyRecords should', async (test) => {
+    try {
+      const participantPositions = [
+        {
+          participantPositionId: 1,
+          participantCurrencyId: 1,
+          value: 0.000,
+          reservedValue: 0.000
+        },
+        {
+          participantPositionId: 1,
+          participantCurrencyId: 2,
+          value: 0.000,
+          reservedValue: 0.000
+        }
+      ]
+      sandbox.stub(Db, 'getKnex')
+      Db.getKnex.throws(new Error())
+      await Model.createParticipantPositionRecords(participantPositions)
+      test.fail('have thrown an error')
+      test.end()
+    } catch (err) {
+      test.pass('throw an error')
+      test.end()
+    }
+  })
+
   participantPositionTest.end()
 })

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

@@ -42,6 +42,9 @@ Test('Participant Position model', async (participantPositionChangeTest) => {
       destroy: sandbox.stub(),
       query: sandbox.stub()
     }
+    Db.from = (table) => {
+      return Db[table]
+    }
     t.end()
   })