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

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

@@ -30,7 +30,9 @@ const Db = require('../../../../src/lib/db')
 const Logger = require('@mojaloop/central-services-logger')
 const ModelParticipant = require('../../../../src/models/participant/facade')
 const ModelPosition = require('../../../../src/models/position/facade')
+const SettlementModelCached = require('../../../../src/models/settlement/settlementModelCached')
 const Enum = require('@mojaloop/central-services-shared').Enum
+const MainUtil = require('@mojaloop/central-services-shared').Util
 
 Test('Position facade', async (positionFacadeTest) => {
   let sandbox
@@ -47,6 +49,11 @@ Test('Position facade', async (positionFacadeTest) => {
     Db.participantPosition = {
       query: sandbox.stub()
     }
+
+    Db.from = (table) => {
+      return Db[table]
+    }
+
     t.end()
   })
 
@@ -250,17 +257,41 @@ Test('Position facade', async (positionFacadeTest) => {
         thresholdAlarmPercentage: 0.5
       }
 
-      const initialParticipantPosition = {
+      const insufficientParticipantLimit = {
+        participantCurrencyId: 1,
+        participantLimitTypeId: 1,
+        value: 100,
+        isActive: 1,
+        createdBy: 'unknown',
+        participantLimitId: 1,
+        thresholdAlarmPercentage: 0.5
+      }
+
+      const initialParticipantPositions = [{
         participantPositionId: 1,
+        participantCurrencyId: 1,
         value: 1000,
         reservedValue: 0
-      }
+      },
+      {
+        participantPositionId: 2,
+        participantCurrencyId: 2,
+        value: -10000,
+        reservedValue: 0
+      }]
 
-      const exceededParticipantPosition = {
+      const exceededParticipantPositions = [{
         participantPositionId: 1,
+        participantCurrencyId: 1,
         value: 10000,
         reservedValue: 0
-      }
+      },
+      {
+        participantPositionId: 2,
+        participantCurrencyId: 2,
+        value: -1000,
+        reservedValue: 0
+      }]
 
       await prepareChangeParticipantPositionTransaction.test('adjust position of payer when transfer is RESERVED', async test => {
         // const listOfTransferStatesChanged = [transferStateChange, incorrectTransferStateChange]
@@ -286,25 +317,54 @@ Test('Position facade', async (positionFacadeTest) => {
               }),
               where: sandbox.stub().returns({
                 update: sandbox.stub().returns(Promise.resolve()),
-                forUpdate: sandbox.stub().returns({
-                  select: sandbox.stub().returns({
-                    first: sandbox.stub().returns(initialParticipantPosition)
-                  })
-                }),
                 orderBy: sandbox.stub().returns({
                   first: sandbox.stub().resolves(Object.assign({}, transferStateChange))
                 })
+              }),
+              whereIn: sandbox.stub().returns({
+                forUpdate: sandbox.stub().returns({
+                  select: sandbox.stub().returns(initialParticipantPositions)
+                })
               })
             })
           })
 
           sandbox.stub(ModelParticipant, 'getParticipantLimitByParticipantCurrencyLimit').returns(Promise.resolve(participantLimit))
-          sandbox.stub(ModelParticipant, 'getByNameAndCurrency').resolves({
+          const getByNameAndCurrencyStub = sandbox.stub(ModelParticipant, 'getByNameAndCurrency')
+
+          const allSettlementModels = [{
+            settlementModelId: 1,
+            name: 'DEFERREDNET',
+            isActive: 1,
+            settlementGranularityId: 2,
+            settlementInterchangeId: 2,
+            settlementDelayId: 2,
+            currencyId: null,
+            requireLiquidityCheck: 1,
+            ledgerAccountTypeId: 1,
+            autoPositionReset: 1,
+            adjustPosition: 0,
+            settlementAccountTypeId: 2
+          }]
+
+          sandbox.stub(SettlementModelCached, 'getAll').resolves(allSettlementModels)
+
+          getByNameAndCurrencyStub.withArgs('dfsp1', 'USD', 1).resolves({
             participantCurrencyId: 1,
             participantId: 1,
             currencyId: 'USD',
             isActive: 1
           })
+          getByNameAndCurrencyStub.withArgs('dfsp1', 'USD', 2).resolves({
+            participantCurrencyId: 2,
+            participantId: 1,
+            currencyId: 'USD',
+            isActive: 1
+          })
+          sandbox.stub(SettlementModelCached, 'getByLedgerAccountTypeId').resolves({
+            settlementDelayId: Enum.Settlements.SettlementDelay.DEFERRED,
+            settlementAccountTypeId: Enum.Accounts.LedgerAccountType.SETTLEMENT
+          })
           const { preparedMessagesList, limitAlarms } = await ModelPosition.prepareChangeParticipantPositionTransaction([{ value: messageProtocol }])
           test.ok(Array.isArray(preparedMessagesList), 'array of prepared transfers is returned')
           test.ok(Array.isArray(limitAlarms), 'array of limit alarms is returned')
@@ -320,6 +380,87 @@ Test('Position facade', async (positionFacadeTest) => {
         }
       })
 
+      await prepareChangeParticipantPositionTransaction.test('Should throw', 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)
+          knexStub.batchInsert = sandbox.stub()
+          knexStub.batchInsert.returns({
+            transacting: sandbox.stub().resolves([1])
+          })
+
+          Db.getKnex.returns(knexStub)
+          knexStub.returns({
+            transacting: sandbox.stub().returns({
+              forUpdate: sandbox.stub().returns({
+                whereIn: sandbox.stub().returns({
+                  select: sandbox.stub().returns(Promise.resolve())
+                })
+              }),
+              where: sandbox.stub().returns({
+                update: sandbox.stub().returns(Promise.resolve()),
+                orderBy: sandbox.stub().returns({
+                  first: sandbox.stub().resolves(Object.assign({}, transferStateChange))
+                })
+              }),
+              whereIn: sandbox.stub().returns({
+                forUpdate: sandbox.stub().returns({
+                  select: sandbox.stub().returns(initialParticipantPositions)
+                })
+              })
+            })
+          })
+
+          sandbox.stub(ModelParticipant, 'getParticipantLimitByParticipantCurrencyLimit').throws(new Error('Error'))
+          const getByNameAndCurrencyStub = sandbox.stub(ModelParticipant, 'getByNameAndCurrency')
+
+          const allSettlementModels = [{
+            settlementModelId: 1,
+            name: 'DEFERREDNET',
+            isActive: 1,
+            settlementGranularityId: 2,
+            settlementInterchangeId: 2,
+            settlementDelayId: 2,
+            currencyId: null,
+            requireLiquidityCheck: 1,
+            ledgerAccountTypeId: 1,
+            autoPositionReset: 1,
+            adjustPosition: 0,
+            settlementAccountTypeId: 2
+          }]
+
+          sandbox.stub(SettlementModelCached, 'getAll').resolves(allSettlementModels)
+
+          getByNameAndCurrencyStub.withArgs('dfsp1', 'USD', 1).resolves({
+            participantCurrencyId: 1,
+            participantId: 1,
+            currencyId: 'USD',
+            isActive: 1
+          })
+          getByNameAndCurrencyStub.withArgs('dfsp1', 'USD', 2).resolves({
+            participantCurrencyId: 2,
+            participantId: 1,
+            currencyId: 'USD',
+            isActive: 1
+          })
+          sandbox.stub(SettlementModelCached, 'getByLedgerAccountTypeId').resolves({
+            settlementDelayId: Enum.Settlements.SettlementDelay.DEFERRED,
+            settlementAccountTypeId: Enum.Accounts.LedgerAccountType.SETTLEMENT
+          })
+          await ModelPosition.prepareChangeParticipantPositionTransaction([{ value: messageProtocol }])
+          test.fail()
+
+          test.end()
+        } catch (err) {
+          test.pass('completed successfully')
+          test.end()
+        }
+      })
+
       await prepareChangeParticipantPositionTransaction.test('abort transfer if state is not correct ', async test => {
         // const listOfTransferStatesChanged = [transferStateChange, incorrectTransferStateChange]
         try {
@@ -345,26 +486,55 @@ Test('Position facade', async (positionFacadeTest) => {
               }),
               where: sandbox.stub().returns({
                 update: sandbox.stub().returns(Promise.resolve()),
-                forUpdate: sandbox.stub().returns({
-                  select: sandbox.stub().returns({
-                    first: sandbox.stub().returns(initialParticipantPosition)
-                  })
-                }),
                 orderBy: sandbox.stub().returns({
                   first: sandbox.stub().resolves(incorrectTransferStateChange)
                 })
+              }),
+              whereIn: sandbox.stub().returns({
+                forUpdate: sandbox.stub().returns({
+                  select: sandbox.stub().returns(initialParticipantPositions)
+                })
               })
             })
           })
 
           sandbox.stub(ModelParticipant, 'getParticipantLimitByParticipantCurrencyLimit').returns(Promise.resolve(participantLimit))
-          sandbox.stub(ModelParticipant, 'getByNameAndCurrency').resolves({
+          const getByNameAndCurrencyStub = sandbox.stub(ModelParticipant, 'getByNameAndCurrency')
+          getByNameAndCurrencyStub.withArgs('dfsp1', 'USD', 1).resolves({
             participantCurrencyId: 1,
             participantId: 1,
             currencyId: 'USD',
             isActive: 1
           })
-          const { preparedMessagesList, limitAlarms } = await ModelPosition.prepareChangeParticipantPositionTransaction([{ value: messageProtocol }])
+          getByNameAndCurrencyStub.withArgs('dfsp1', 'USD', 2).resolves({
+            participantCurrencyId: 2,
+            participantId: 1,
+            currencyId: 'USD',
+            isActive: 1
+          })
+          sandbox.stub(SettlementModelCached, 'getByLedgerAccountTypeId').resolves({
+            settlementDelayId: Enum.Settlements.SettlementDelay.DEFERRED,
+            settlementAccountTypeId: Enum.Accounts.LedgerAccountType.SETTLEMENT
+          })
+
+          const allSettlementModels = [{
+            settlementModelId: 1,
+            name: 'DEFERREDNET',
+            isActive: 1,
+            settlementGranularityId: 2,
+            settlementInterchangeId: 2,
+            settlementDelayId: 2,
+            currencyId: null,
+            requireLiquidityCheck: 1,
+            ledgerAccountTypeId: 1,
+            autoPositionReset: 1,
+            adjustPosition: 0,
+            settlementAccountTypeId: 2
+          }]
+
+          sandbox.stub(SettlementModelCached, 'getAll').resolves(allSettlementModels)
+          const messageProtocolCopy = MainUtil.clone(messageProtocol)
+          const { preparedMessagesList, limitAlarms } = await ModelPosition.prepareChangeParticipantPositionTransaction([{ value: messageProtocolCopy }])
           test.ok(Array.isArray(preparedMessagesList), 'array of prepared transfers is returned')
           test.ok(Array.isArray(limitAlarms), 'array of limit alarms is returned')
           test.ok(knexStub.withArgs('participantPosition').calledThrice, 'knex called with participantPosition twice')
@@ -401,7 +571,7 @@ Test('Position facade', async (positionFacadeTest) => {
         }
       })
 
-      await prepareChangeParticipantPositionTransaction.test('abort transfer if net-debit-cap is exceeded ', async test => {
+      await prepareChangeParticipantPositionTransaction.test('abort transfer if settlement balance is not enough ', async test => {
         // const listOfTransferStatesChanged = [transferStateChange, incorrectTransferStateChange]
         try {
           sandbox.stub(Db, 'getKnex')
@@ -426,28 +596,147 @@ Test('Position facade', async (positionFacadeTest) => {
               }),
               where: sandbox.stub().returns({
                 update: sandbox.stub().returns(Promise.resolve()),
-                forUpdate: sandbox.stub().returns({
-                  select: sandbox.stub().returns({
-                    first: sandbox.stub().returns(exceededParticipantPosition)
-                  })
-                }),
                 orderBy: sandbox.stub().returns({
-                  first: sandbox.stub().resolves(transferStateChange)
+                  first: sandbox.stub().resolves(MainUtil.clone(transferStateChange))
+                })
+              }),
+              whereIn: sandbox.stub().returns({
+                forUpdate: sandbox.stub().returns({
+                  select: sandbox.stub().returns(exceededParticipantPositions)
                 })
               })
             })
           })
 
           sandbox.stub(ModelParticipant, 'getParticipantLimitByParticipantCurrencyLimit').returns(Promise.resolve(participantLimit))
-          sandbox.stub(ModelParticipant, 'getByNameAndCurrency').resolves({
+          const getByNameAndCurrencyStub = sandbox.stub(ModelParticipant, 'getByNameAndCurrency')
+          getByNameAndCurrencyStub.withArgs('dfsp1', 'USD', 1).resolves({
             participantCurrencyId: 1,
             participantId: 1,
             currencyId: 'USD',
             isActive: 1
           })
-          const { preparedMessagesList, limitAlarms } = await ModelPosition.prepareChangeParticipantPositionTransaction([{ value: messageProtocol }])
+          getByNameAndCurrencyStub.withArgs('dfsp1', 'USD', 2).resolves({
+            participantCurrencyId: 2,
+            participantId: 1,
+            currencyId: 'USD',
+            isActive: 1
+          })
+          sandbox.stub(SettlementModelCached, 'getByLedgerAccountTypeId').resolves({
+            settlementDelayId: Enum.Settlements.SettlementDelay.DEFERRED,
+            settlementAccountTypeId: Enum.Accounts.LedgerAccountType.SETTLEMENT
+          })
+
+          const allSettlementModels = [{
+            settlementModelId: 1,
+            name: 'DEFERREDNET',
+            isActive: 1,
+            settlementGranularityId: 2,
+            settlementInterchangeId: 2,
+            settlementDelayId: 2,
+            currencyId: null,
+            requireLiquidityCheck: 1,
+            ledgerAccountTypeId: 1,
+            autoPositionReset: 1,
+            adjustPosition: 0,
+            settlementAccountTypeId: 2
+          }]
+
+          sandbox.stub(SettlementModelCached, 'getAll').resolves(allSettlementModels)
+          const messageProtocolCopy = MainUtil.clone(messageProtocol)
+          const { preparedMessagesList, limitAlarms } = await ModelPosition.prepareChangeParticipantPositionTransaction([{ value: messageProtocolCopy }])
+          test.ok(Array.isArray(preparedMessagesList), 'array of prepared transfers is returned')
+          test.ok(Array.isArray(limitAlarms), 'array of limit alarms is returned')
+          test.ok(preparedMessagesList[0].rawMessage.value.content.payload.errorInformation.errorCode === '4001')
+          test.ok(knexStub.withArgs('participantPosition').calledThrice, 'knex called with participantPosition twice')
+          test.ok(knexStub.withArgs('transferStateChange').calledOnce, 'knex called with transferStateChange twice')
+          test.ok(knexStub.withArgs('transfer').calledOnce, 'knex called with transferStateChange twice')
+          test.pass('completed successfully')
+          test.end()
+        } catch (err) {
+          Logger.error(`prepareChangeParticipantPositionTransaction failed with error - ${err}`)
+          test.fail()
+          test.end()
+        }
+      })
+
+      await prepareChangeParticipantPositionTransaction.test('abort transfer if net-debit-cap is exceeded ', async test => {
+        // const listOfTransferStatesChanged = [transferStateChange, incorrectTransferStateChange]
+        try {
+          sandbox.stub(Db, 'getKnex')
+          const knexStub = sandbox.stub()
+          const trxStub = sandbox.stub()
+
+          trxStub.commit = sandbox.stub()
+          knexStub.transaction = sandbox.stub().callsArgWith(0, trxStub)
+
+          knexStub.batchInsert = sandbox.stub()
+          knexStub.batchInsert.returns({
+            transacting: sandbox.stub().resolves([1])
+          })
+
+          Db.getKnex.returns(knexStub)
+          knexStub.returns({
+            transacting: sandbox.stub().returns({
+              forUpdate: sandbox.stub().returns({
+                whereIn: sandbox.stub().returns({
+                  select: sandbox.stub().returns(Promise.resolve())
+                })
+              }),
+              where: sandbox.stub().returns({
+                update: sandbox.stub().returns(Promise.resolve()),
+                orderBy: sandbox.stub().returns({
+                  first: sandbox.stub().resolves(MainUtil.clone(transferStateChange))
+                })
+              }),
+              whereIn: sandbox.stub().returns({
+                forUpdate: sandbox.stub().returns({
+                  select: sandbox.stub().returns(initialParticipantPositions)
+                })
+              })
+            })
+          })
+
+          sandbox.stub(ModelParticipant, 'getParticipantLimitByParticipantCurrencyLimit').returns(Promise.resolve(insufficientParticipantLimit))
+          const getByNameAndCurrencyStub = sandbox.stub(ModelParticipant, 'getByNameAndCurrency')
+          getByNameAndCurrencyStub.withArgs('dfsp1', 'USD', 1).resolves({
+            participantCurrencyId: 1,
+            participantId: 1,
+            currencyId: 'USD',
+            isActive: 1
+          })
+          getByNameAndCurrencyStub.withArgs('dfsp1', 'USD', 2).resolves({
+            participantCurrencyId: 2,
+            participantId: 1,
+            currencyId: 'USD',
+            isActive: 1
+          })
+          sandbox.stub(SettlementModelCached, 'getByLedgerAccountTypeId').resolves({
+            settlementDelayId: Enum.Settlements.SettlementDelay.DEFERRED,
+            settlementAccountTypeId: Enum.Accounts.LedgerAccountType.SETTLEMENT
+          })
+
+          const allSettlementModels = [{
+            settlementModelId: 1,
+            name: 'DEFERREDNET',
+            isActive: 1,
+            settlementGranularityId: 2,
+            settlementInterchangeId: 2,
+            settlementDelayId: 2,
+            currencyId: null,
+            requireLiquidityCheck: 1,
+            ledgerAccountTypeId: 1,
+            autoPositionReset: 1,
+            adjustPosition: 0,
+            settlementAccountTypeId: 2
+          }]
+
+          sandbox.stub(SettlementModelCached, 'getAll').resolves(allSettlementModels)
+          const messageProtocolCopy = MainUtil.clone(messageProtocol)
+          const { preparedMessagesList, limitAlarms } = await ModelPosition.prepareChangeParticipantPositionTransaction([{ value: messageProtocolCopy }])
           test.ok(Array.isArray(preparedMessagesList), 'array of prepared transfers is returned')
           test.ok(Array.isArray(limitAlarms), 'array of limit alarms is returned')
+          test.ok(preparedMessagesList[0].rawMessage.value.content.payload.errorInformation.errorCode === '4200')
           test.ok(knexStub.withArgs('participantPosition').calledThrice, 'knex called with participantPosition twice')
           test.ok(knexStub.withArgs('transferStateChange').calledOnce, 'knex called with transferStateChange twice')
           test.ok(knexStub.withArgs('transfer').calledOnce, 'knex called with transferStateChange twice')
@@ -515,7 +804,7 @@ Test('Position facade', async (positionFacadeTest) => {
             })
           })
 
-          await ModelPosition.changeParticipantPositionTransaction(participantCurrencyId, isIncrease, amount, transferStateChange)
+          await ModelPosition.changeParticipantPositionTransaction(participantCurrencyId, isIncrease, amount, MainUtil.clone(transferStateChange))
           test.pass('completed successfully')
           test.ok(knexStub.withArgs('participantPosition').calledTwice, 'knex called with participantPosition twice')
           test.ok(knexStub.withArgs('transferStateChange').calledTwice, 'knex called with transferStateChange twice')
@@ -556,7 +845,7 @@ Test('Position facade', async (positionFacadeTest) => {
             })
           })
 
-          await ModelPosition.changeParticipantPositionTransaction(participantCurrencyId, isIncrease, amount, transferStateChange)
+          await ModelPosition.changeParticipantPositionTransaction(participantCurrencyId, isIncrease, amount, MainUtil.clone(transferStateChange))
           test.pass('completed successfully')
           test.ok(knexStub.withArgs('participantPosition').calledTwice, 'knex called with participantPosition twice')
           test.ok(knexStub.withArgs('transferStateChange').calledTwice, 'knex called with transferStateChange twice')
@@ -580,7 +869,7 @@ Test('Position facade', async (positionFacadeTest) => {
 
           knexStub.throws(new Error())
 
-          await ModelPosition.changeParticipantPositionTransaction(participantCurrencyId, isIncrease, amount, transferStateChange)
+          await ModelPosition.changeParticipantPositionTransaction(participantCurrencyId, isIncrease, amount, MainUtil.clone(transferStateChange))
           test.fail('Error not thrown!')
           test.end()
         } catch (err) {

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

@@ -24,13 +24,14 @@
 
 '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/position/participantPosition')
 
 Test('Participant Limit model', async (participantPositionTest) => {
+  let sandbox
   const participantPosition1 = {
     participantCurrencyId: 1,
     value: 100,
@@ -38,12 +39,26 @@ Test('Participant Limit model', async (participantPositionTest) => {
     changedDate: new Date()
   }
 
-  const sandbox = Sinon.createSandbox()
-  Db.participantPosition = {
-    insert: sandbox.stub(),
-    update: sandbox.stub(),
-    findOne: sandbox.stub()
-  }
+  participantPositionTest.beforeEach(t => {
+    sandbox = Sinon.createSandbox()
+    Db.participantPosition = {
+      insert: sandbox.stub(),
+      update: sandbox.stub(),
+      findOne: sandbox.stub()
+    }
+
+    Db.from = (table) => {
+      return Db[table]
+    }
+
+    t.end()
+  })
+
+  participantPositionTest.afterEach(t => {
+    sandbox.restore()
+
+    t.end()
+  })
 
   await participantPositionTest.test('insert participant position', async (assert) => {
     try {

package/test/unit/models/settlement/settlementModel.test.js

@@ -34,7 +34,6 @@ const SettlementModelModel = require('../../../../src/models/settlement/settleme
 Test('Settlement model', async (settlementTest) => {
   const settlementModelId = 1
   const settlementModel = [
-
     {
       settlementModelId: 106,
       name: 'DEFERRED_NET',
@@ -48,7 +47,24 @@ Test('Settlement model', async (settlementTest) => {
     }
   ]
 
-  const sandbox = Sinon.createSandbox()
+  let sandbox
+
+  settlementTest.beforeEach(t => {
+    sandbox = Sinon.createSandbox()
+
+    Db.from = (table) => {
+      return Db[table]
+    }
+
+    t.end()
+  })
+
+  settlementTest.afterEach(t => {
+    sandbox.restore()
+
+    t.end()
+  })
+
   await settlementTest.test('create settlement model', async (assert) => {
     Db.settlementModel = {
       insert: sandbox.stub().returns(true),
@@ -80,41 +96,6 @@ Test('Settlement model', async (settlementTest) => {
     assert.end()
   })
 
-  await settlementTest.test('get settlement model', async (assert) => {
-    try {
-      Db.settlementModel.find.withArgs({ name: 'test' }).returns([
-        {
-          settlementModelId: 106,
-          name: 'testingSevennnnN91',
-          isActive: 1,
-          settlementGranularityId: 1,
-          settlementInterchangeId: 1,
-          settlementDelayId: 2,
-          currencyId: null,
-          requireLiquidityCheck: 1,
-          ledgerAccountTypeId: 6
-        }])
-      const expected = {
-        settlementModelId: 106,
-        name: 'testingSevennnnN91',
-        isActive: 1,
-        settlementGranularityId: 1,
-        settlementInterchangeId: 1,
-        settlementDelayId: 2,
-        currencyId: null,
-        requireLiquidityCheck: 1,
-        ledgerAccountTypeId: 6
-      }
-      const result = await SettlementModelModel.getByName('test')
-      assert.equal(JSON.stringify(result), JSON.stringify(expected))
-      assert.end()
-    } catch (err) {
-      Logger.error(`get settlement model by name failed with error - ${err}`)
-      assert.fail()
-      assert.end()
-    }
-  })
-
   await settlementTest.test('get with empty name', async (assert) => {
     Db.settlementModel.find.withArgs({ name: '' }).throws(new Error())
     try {