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

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

@@ -0,0 +1,171 @@
+/*****
+ 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>
+
+ * Neal Donnan <neal.donnan@modusbox.com>
+ --------------
+ ******/
+
+'use strict'
+
+const Test = require('tapes')(require('tape'))
+const Sinon = require('sinon')
+const SettlementModelUncached = require('../../../../src/models/settlement/settlementModel')
+const Cache = require('../../../../src/lib/cache')
+const Model = require('../../../../src/models/settlement/settlementModelCached')
+
+Test('SettlementModel cached model', async (settlementModelCachedTest) => {
+  let sandbox
+
+  const settlementModelFixtures = [
+    {
+      settlementModelId: 1,
+      name: 'CGS',
+      ledgerAccountTypeId: 1
+    },
+    {
+      settlementModelId: 2,
+      name: 'InterchangeFee',
+      ledgerAccountTypeId: 6
+    }
+  ]
+
+  settlementModelCachedTest.beforeEach(t => {
+    sandbox = Sinon.createSandbox()
+    sandbox.stub(Cache)
+    sandbox.stub(SettlementModelUncached)
+    SettlementModelUncached.getAll.returns(settlementModelFixtures)
+    t.end()
+  })
+
+  settlementModelCachedTest.afterEach(t => {
+    sandbox.restore()
+    t.end()
+  })
+
+  await settlementModelCachedTest.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 settlementModelCachedTest.test('calls drop() for invalidateSettlementModelsCache', 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.invalidateSettlementModelsCache()
+    test.ok(cacheClient.drop.calledOnce)
+
+    test.end()
+  })
+
+  await settlementModelCachedTest.test('getById(), getByName(), getByLedgerAccountTypeId() and getAll() work', async (test) => {
+    let cache = null
+    const cacheClient = {
+      createKey: sandbox.stub().returns({}),
+      get: () => cache,
+      set: (key, x) => {
+        cache = { item: x } // the cache retuns {item: <data>} structure
+      }
+    }
+    Cache.registerCacheClient.returns(cacheClient)
+    await Model.initialize()
+
+    // check getById()
+    const settlementModelById = await Model.getById(1)
+    test.equal(JSON.stringify(settlementModelById), JSON.stringify(settlementModelFixtures[0]), 'getById() works')
+
+    // check getByName()
+    const settlementModelByName = await Model.getByName(settlementModelFixtures[1].name)
+    test.equal(JSON.stringify(settlementModelByName), JSON.stringify(settlementModelFixtures[1]), 'getByName() works')
+
+    // check getByLedgerAccountTypeId()
+    const settlementModelByLedgerAccountTypeId = await Model.getByLedgerAccountTypeId(settlementModelFixtures[1].ledgerAccountTypeId)
+    test.equal(JSON.stringify(settlementModelByLedgerAccountTypeId), JSON.stringify(settlementModelFixtures[1]), 'getByLedgerAccountTypeId() works')
+
+    // check getAll()
+    const participantsAll = await Model.getAll()
+    test.equal(JSON.stringify(participantsAll), JSON.stringify(settlementModelFixtures), 'getAll() works')
+
+    test.end()
+  })
+
+  await settlementModelCachedTest.test('getById(), getByName(), getByLedgerAccountTypeId() and getAll() fail when error thrown', async (test) => {
+    const cacheClient = {
+      createKey: sandbox.stub().returns({}),
+      get: () => null
+    }
+    Cache.registerCacheClient.returns(cacheClient)
+    await Model.initialize()
+    SettlementModelUncached.getAll.throws(new Error())
+
+    // check getById()
+    try {
+      await Model.getById(1)
+      test.fail('Error not thrown')
+    } catch (err) {
+      test.pass('Error thrown')
+    }
+
+    // check getByName()
+    try {
+      await Model.getByName(settlementModelFixtures[1].name)
+      test.fail('Error not thrown')
+    } catch (err) {
+      test.pass('Error thrown')
+    }
+
+    // check getByLedgerAccountTypeId()
+    try {
+      await Model.getByLedgerAccountTypeId(settlementModelFixtures[1].ledgerAccountTypeId)
+      test.fail('Error not thrown')
+    } catch (err) {
+      test.pass('Error thrown')
+    }
+
+    // check getAll()
+    try {
+      await Model.getAll()
+      test.fail('Error not thrown')
+    } catch (err) {
+      test.pass('Error thrown')
+    }
+
+    test.end()
+  })
+
+  await settlementModelCachedTest.end()
+})

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

@@ -114,6 +114,9 @@ Test('Transfer facade', async (transferFacadeTest) => {
     Db.participant = {
       query: sandbox.stub()
     }
+    Db.from = (table) => {
+      return Db[table]
+    }
     clock = Sinon.useFakeTimers(now.getTime())
     sandbox.stub(ParticipantFacade, 'getByNameAndCurrency')
     t.end()
@@ -961,6 +964,92 @@ Test('Transfer facade', async (transferFacadeTest) => {
         }
       })
 
+      await savePayeeTransferResponse.test('return transfer in RECEIVED_ERROR state', async (test) => {
+        try {
+          action = TransferEventAction.BULK_ABORT
+          const record = [{ settlementWindowId: 1 }]
+          transferStateChangeRecord.transferStateId = Enum.Transfers.TransferInternalState.RECEIVED_ERROR
+          const fspiopError = {
+            errorInformation: {
+              errorCode: 1000,
+              errorDescription: 'descr'
+            }
+          }
+          const payload2 = cloneDeep(fspiopError)
+
+          sandbox.stub(Db, 'getKnex')
+          const trxStub = sandbox.stub()
+          trxStub.commit = sandbox.stub()
+          const knexStub = sandbox.stub()
+          knexStub.transaction = sandbox.stub().callsArgWith(0, trxStub)
+          Db.getKnex.returns(knexStub)
+
+          const builderStub = sandbox.stub()
+          const selectStub = sandbox.stub()
+          const whereStub = sandbox.stub()
+          const orderByStub = sandbox.stub()
+          const firstStub = sandbox.stub()
+
+          builderStub.leftJoin = sandbox.stub()
+          Db.settlementWindow.query.callsArgWith(0, builderStub)
+          Db.settlementWindow.query.returns(record)
+
+          builderStub.leftJoin.returns({
+            select: selectStub.returns({
+              where: whereStub.returns({
+                orderBy: orderByStub.returns({
+                  first: firstStub.returns(record)
+                })
+              })
+            })
+          })
+
+          const insertedTransferStateChange = cloneDeep(transferStateChangeRecord)
+          insertedTransferStateChange.transferStateChangeId = 1
+          const transactingStub = sandbox.stub()
+          const insertStub = sandbox.stub()
+          knexStub.returns({
+            transacting: transactingStub.returns({
+              insert: insertStub,
+              where: whereStub.returns({
+                forUpdate: sandbox.stub().returns({
+                  first: sandbox.stub().returns({
+                    orderBy: sandbox.stub().returns(insertedTransferStateChange)
+                  })
+                })
+              })
+            })
+          })
+
+          const expected = cloneDeep(savePayeeTransferResponseResult)
+          delete expected.transferExtensionRecordsList
+          delete expected.transferFulfilmentRecord
+          expected.transferErrorRecord = {
+            transferId,
+            transferStateChangeId: insertedTransferStateChange.transferStateChangeId,
+            errorCode: fspiopError.errorInformation.errorCode,
+            errorDescription: fspiopError.errorInformation.errorDescription,
+            createdDate: insertedTransferStateChange.createdDate
+          }
+          expected.transferStateChangeRecord.reason = fspiopError.errorInformation.errorDescription
+          expected.transferStateChangeRecord.transferStateChangeId = insertedTransferStateChange.transferStateChangeId
+
+          const response = await TransferFacade.savePayeeTransferResponse(transferId, payload2, action, fspiopError)
+          test.deepEqual(response, expected, 'response matches expected result')
+          test.ok(knexStub.withArgs('transferFulfilment').notCalled, 'knex not called with transferFulfilment')
+          test.ok(knexStub.withArgs('transferExtension').notCalled, 'knex not called with transferExtension')
+          test.ok(knexStub.withArgs('transferStateChange').calledTwice, 'knex called with transferStateChange twice')
+          test.ok(transactingStub.withArgs(trxStub).called, 'knex.transacting called with trx')
+          test.ok(insertStub.withArgs(transferFulfilmentRecord).notCalled, 'insert transferFulfilmentRecord not called')
+          test.ok(insertStub.withArgs(transferStateChangeRecord).notCalled, 'insert transferStateChangeRecord not called')
+          test.end()
+        } catch (err) {
+          Logger.error(`savePayeeTransferResponse failed with error - ${err}`)
+          test.fail()
+          test.end()
+        }
+      })
+
       await savePayeeTransferResponse.test('throw an error and rollback', async (test) => {
         try {
           action = TransferEventAction.ABORT
@@ -2520,5 +2609,31 @@ Test('Transfer facade', async (transferFacadeTest) => {
     }
   })
 
+  await transferFacadeTest.test('recordFundsIn should call transfer prepare, reserve and commit functions', async (test) => {
+    const payload = {}
+    const transactionTimestamp = Time.getUTCString(now)
+    const enums = {}
+    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)
+      sandbox.stub(TransferFacade, 'reconciliationTransferPrepare')
+      sandbox.stub(TransferFacade, 'reconciliationTransferReserve')
+      sandbox.stub(TransferFacade, 'reconciliationTransferCommit')
+
+      await TransferFacade.recordFundsIn(payload, transactionTimestamp, enums)
+      test.ok(TransferFacade.reconciliationTransferPrepare.callsArgWith(0, trxStub))
+      test.ok(TransferFacade.reconciliationTransferReserve.callsArgWith(0, trxStub))
+      test.ok(TransferFacade.reconciliationTransferCommit.callsArgWith(0, trxStub))
+      test.end()
+    } catch (e) {
+      test.fail(`${e} error thrown`)
+      test.end()
+    }
+  })
+
   await transferFacadeTest.end()
 })

package/test/unit/models/transfer/ilpPacket.test.js

@@ -28,7 +28,7 @@
 
 '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')
@@ -43,16 +43,33 @@ Test('ilpPacket model', async (ilpTest) => {
   ]
   const ilpPacket = ilpPacketTestValues[0]
 
-  const sandbox = Sinon.createSandbox()
-  Db.ilpPacket = {
-    select: sandbox.stub(),
-    insert: sandbox.stub(),
-    update: sandbox.stub(),
-    findOne: sandbox.stub(),
-    find: sandbox.stub(),
-    query: sandbox.stub(),
-    destroy: sandbox.stub()
-  }
+  let sandbox
+
+  ilpTest.beforeEach(t => {
+    sandbox = Sinon.createSandbox()
+
+    Db.ilpPacket = {
+      select: sandbox.stub(),
+      insert: sandbox.stub(),
+      update: sandbox.stub(),
+      findOne: sandbox.stub(),
+      find: sandbox.stub(),
+      query: sandbox.stub(),
+      destroy: sandbox.stub()
+    }
+
+    Db.from = (table) => {
+      return Db[table]
+    }
+
+    t.end()
+  })
+
+  ilpTest.afterEach(t => {
+    sandbox.restore()
+
+    t.end()
+  })
 
   await ilpTest.test('create false ilpPacket', async (assert) => {
     const falseIlp = { transferId: '1', value: undefined }

package/test/unit/models/transfer/transfer.test.js

@@ -24,7 +24,7 @@
 
 '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')
@@ -42,16 +42,25 @@ Test('Transfer model', async (transfer) => {
     createdDate: new Date()
   }
 
-  await transfer.test('setup', async (assert) => {
+  transfer.beforeEach(beforeTest => {
     sandbox = Sinon.createSandbox()
+    sandbox.stub(Logger, 'isErrorEnabled').value(true)
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
     Db.transfer = {
       insert: sandbox.stub(),
       findOne: sandbox.stub(),
       destroy: sandbox.stub(),
       truncate: sandbox.stub()
     }
-    assert.pass('setup OK')
-    assert.end()
+    Db.from = (table) => {
+      return Db[table]
+    }
+    beforeTest.end()
+  })
+
+  transfer.afterEach(afterTest => {
+    sandbox.restore()
+    afterTest.end()
   })
 
   await transfer.test('getById should', async (assert) => {

package/test/unit/models/transfer/transferDuplicateCheck.test.js

@@ -39,10 +39,14 @@ Test('TransferDuplicateCheck model', async (TransferDuplicateCheckTest) => {
   }
   TransferDuplicateCheckTest.beforeEach(test => {
     sandbox = Sinon.createSandbox()
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
     Db.transferDuplicateCheck = {
       findOne: sandbox.stub(),
       insert: sandbox.stub()
     }
+    Db.from = (table) => {
+      return Db[table]
+    }
     test.end()
   })
 

package/test/unit/models/transfer/transferError.test.js

@@ -49,12 +49,16 @@ Test('TransferError model', async (TransferErrorTest) => {
 
   TransferErrorTest.beforeEach(test => {
     sandbox = Sinon.createSandbox()
+    sandbox.stub(Logger, 'isErrorEnabled').value(true)
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
     Db.transferError = {
       insert: sandbox.stub(),
       find: sandbox.stub(),
       query: sandbox.stub()
     }
-
+    Db.from = (table) => {
+      return Db[table]
+    }
     test.end()
   })
 

package/test/unit/models/transfer/transferErrorDuplicateCheck.test.js

@@ -40,10 +40,14 @@ Test('TransferErrorDuplicateCheck model', async (TransferErrorDuplicateCheckTest
   }]
   TransferErrorDuplicateCheckTest.beforeEach(test => {
     sandbox = Sinon.createSandbox()
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
     Db.transferErrorDuplicateCheck = {
       findOne: sandbox.stub(),
       insert: sandbox.stub()
     }
+    Db.from = (table) => {
+      return Db[table]
+    }
     test.end()
   })
 

package/test/unit/models/transfer/transferExtension.test.js

@@ -27,7 +27,7 @@
 
 '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')
@@ -49,14 +49,31 @@ Test('Extension model', async (extensionModelTest) => {
     }
   ]
 
-  const sandbox = Sinon.createSandbox()
-  Db.transferExtension = {
-    insert: sandbox.stub(),
-    update: sandbox.stub(),
-    findOne: sandbox.stub(),
-    find: sandbox.stub(),
-    destroy: sandbox.stub()
-  }
+  let sandbox
+
+  extensionModelTest.beforeEach(t => {
+    sandbox = Sinon.createSandbox()
+
+    Db.transferExtension = {
+      insert: sandbox.stub(),
+      update: sandbox.stub(),
+      findOne: sandbox.stub(),
+      find: sandbox.stub(),
+      destroy: sandbox.stub()
+    }
+
+    Db.from = (table) => {
+      return Db[table]
+    }
+
+    t.end()
+  })
+
+  extensionModelTest.afterEach(t => {
+    sandbox.restore()
+
+    t.end()
+  })
 
   await extensionModelTest.test('create false extension', async (assert) => {
     Db.transferExtension.insert.withArgs({

package/test/unit/models/transfer/transferFulfilment.test.js

@@ -25,7 +25,7 @@
 
 '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')
@@ -43,14 +43,23 @@ Test('TransferFulfilment model', async (transferFulfilment) => {
     createdDate: new Date()
   }
 
-  await transferFulfilment.test('setup', async (assert) => {
+  transferFulfilment.beforeEach(beforeTest => {
     sandbox = Sinon.createSandbox()
+    sandbox.stub(Logger, 'isErrorEnabled').value(true)
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
     Db.transferFulfilment = {
       insert: sandbox.stub(),
       find: sandbox.stub()
     }
-    assert.pass('setup OK')
-    assert.end()
+    Db.from = (table) => {
+      return Db[table]
+    }
+    beforeTest.end()
+  })
+
+  transferFulfilment.afterEach(afterTest => {
+    sandbox.restore()
+    afterTest.end()
   })
 
   await transferFulfilment.test('getByTransferId test', async (assert) => {
@@ -108,5 +117,5 @@ Test('TransferFulfilment model', async (transferFulfilment) => {
     }
   })
 
-  await transferFulfilment.end()
+  transferFulfilment.end()
 })

package/test/unit/models/transfer/transferFulfilmentDuplicateCheck.test.js

@@ -39,10 +39,14 @@ Test('TransferFulfilmentDuplicateCheck model', async (TransferFulfilmentDuplicat
   }]
   TransferFulfilmentDuplicateCheckTest.beforeEach(test => {
     sandbox = Sinon.createSandbox()
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
     Db.transferFulfilmentDuplicateCheck = {
       findOne: sandbox.stub(),
       insert: sandbox.stub()
     }
+    Db.from = (table) => {
+      return Db[table]
+    }
     test.end()
   })
 

package/test/unit/models/transfer/transferParticipant.test.js

@@ -24,7 +24,7 @@
 
 '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')
@@ -43,13 +43,22 @@ Test('TransferParticipant model', async (transferParticipant) => {
     expirationDate: new Date()
   }
 
-  await transferParticipant.test('setup', async (assert) => {
+  transferParticipant.beforeEach(beforeTest => {
     sandbox = Sinon.createSandbox()
+    sandbox.stub(Logger, 'isErrorEnabled').value(true)
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
     Db.transferParticipant = {
       insert: sandbox.stub()
     }
-    assert.pass('setup OK')
-    assert.end()
+    Db.from = (table) => {
+      return Db[table]
+    }
+    beforeTest.end()
+  })
+
+  transferParticipant.afterEach(afterTest => {
+    sandbox.restore()
+    afterTest.end()
   })
 
   await transferParticipant.test('saveTransferParticipant test', async (assert) => {
@@ -80,5 +89,5 @@ Test('TransferParticipant model', async (transferParticipant) => {
     }
   })
 
-  await transferParticipant.end()
+  transferParticipant.end()
 })

package/test/unit/models/transfer/transferStateChange.test.js

@@ -54,6 +54,9 @@ Test('TransferStateChange model', async (transferStateChangeModel) => {
       truncate: sandbox.stub(),
       query: sandbox.stub()
     }
+    Db.from = (table) => {
+      return Db[table]
+    }
     t.end()
   })
 

package/test/unit/models/transfer/transferTimeout.test.js

@@ -28,6 +28,7 @@
 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/transfer/transferTimeout')
 
 Test('Transfer Timeout', async (transferTimeoutTest) => {
@@ -35,9 +36,14 @@ Test('Transfer Timeout', async (transferTimeoutTest) => {
 
   transferTimeoutTest.beforeEach(t => {
     sandbox = Sinon.createSandbox()
+    sandbox.stub(Logger, 'isErrorEnabled').value(true)
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
     Db.transferTimeout = {
       query: sandbox.stub()
     }
+    Db.from = (table) => {
+      return Db[table]
+    }
     t.end()
   })
 

package/test/unit/seeds/amountType.test.js

@@ -19,6 +19,7 @@
  - Name Surname <name.surname@gatesfoundation.com>
 
  * Georgi Georgiev <georgi.georgiev@modusbox.com>
+ * Shashikant Hirugade <shashikant.hirugade@modusbox.com>
  --------------
  ******/
 
@@ -46,7 +47,11 @@ Test('AmountType', async (amountTypeSeedTest) => {
   await amountTypeSeedTest.test('seed should', async (test) => {
     const knexStub = sandbox.stub()
     knexStub.returns({
-      insert: sandbox.stub().returns(true)
+      insert: sandbox.stub().returns({
+        onConflict: sandbox.stub().returns({
+          ignore: sandbox.stub().returns(true)
+        })
+      })
     })
 
     try {
@@ -61,27 +66,6 @@ Test('AmountType', async (amountTypeSeedTest) => {
     }
   })
 
-  await amountTypeSeedTest.test('seed should', async (test) => {
-    function DuplicateEntryError (message) {
-      this.name = 'DuplicateEntryError'
-      this.message = message || ''
-      this.code = 'ER_DUP_ENTRY'
-    }
-    DuplicateEntryError.prototype = Error.prototype
-
-    const knexStub = sandbox.stub()
-    knexStub.throws(new DuplicateEntryError())
-    try {
-      const result = await Model.seed(knexStub)
-      test.equal(result, -1001, 'Duplicate error intercepted and ignored')
-      test.end()
-    } catch (err) {
-      Logger.error(`amountType seed failed with error - ${err}`)
-      test.fail()
-      test.end()
-    }
-  })
-
   await amountTypeSeedTest.test('seed should', async (test) => {
     const knexStub = sandbox.stub()
     knexStub.returns({