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

package/test/unit/domain/transactions/index.test.js

@@ -0,0 +1,128 @@
+/*****
+ 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>
+
+ * ModusBox
+ - Lazola Lucas <lazola.lucas@modusbox.com>
+ --------------
+ ******/
+'use strict'
+
+const Test = require('tapes')(require('tape'))
+const Sinon = require('sinon')
+const Db = require('../../../../src/lib/db')
+const IlpPackets = require('../../../../src/models/ilpPackets/ilpPacket')
+
+const TransactionsService = require('../../../../src/domain/transactions/index')
+
+Test('Transactions Service', async (transactionsTest) => {
+  let sandbox
+
+  transactionsTest.beforeEach(t => {
+    sandbox = Sinon.createSandbox()
+
+    Db.ilpPacket = {
+      find: sandbox.stub()
+    }
+    t.end()
+  })
+
+  transactionsTest.afterEach(t => {
+    sandbox.restore()
+    t.end()
+  })
+
+  const ilpPacket = {
+    transferId: '6d3e964e-9a25-4ff5-a365-2cc5af348321',
+    value: 'AYIC-AAAAAAAAeIfHWcucGF5ZWVmc3AubXNpc2RuLjIyNTU2OTk5MTI1ggLOZXlKMGNtRnVjMkZqZEdsdmJrbGtJam9pTlRWa09ESXdObVV0T0RCaU55MDBPR00wTFRrNU5HTXRaREEyTmpRd01XRXdZbU00SWl3aWNYVnZkR1ZKWkNJNklqRmtPVGhpTkdReExXWmpOVFV0TkRaa09DMDROV1EyTFRnNVl6TXdZMkZoWWpRME5pSXNJbkJoZVdWbElqcDdJbkJoY25SNVNXUkpibVp2SWpwN0luQmhjblI1U1dSVWVYQmxJam9pVFZOSlUwUk9JaXdpY0dGeWRIbEpaR1Z1ZEdsbWFXVnlJam9pTWpJMU5UWTVPVGt4TWpVaUxDSm1jM0JKWkNJNkluQmhlV1ZsWm5Od0luMTlMQ0p3WVhsbGNpSTZleUp3WVhKMGVVbGtTVzVtYnlJNmV5SndZWEowZVVsa1ZIbHdaU0k2SWsxVFNWTkVUaUlzSW5CaGNuUjVTV1JsYm5ScFptbGxjaUk2SWpJeU5UQTNNREE0TVRneElpd2labk53U1dRaU9pSndZWGxsY21aemNDSjlMQ0p3WlhKemIyNWhiRWx1Wm04aU9uc2lZMjl0Y0d4bGVFNWhiV1VpT25zaVptbHljM1JPWVcxbElqb2lUV0YwY3lJc0lteGhjM1JPWVcxbElqb2lTR0ZuYldGdUluMHNJbVJoZEdWUFprSnBjblJvSWpvaU1UazRNeTB4TUMweU5TSjlmU3dpWVcxdmRXNTBJanA3SW1OMWNuSmxibU41SWpvaVZWTkVJaXdpWVcxdmRXNTBJam94TWpNMExqSXpmU3dpZEhKaGJuTmhZM1JwYjI1VWVYQmxJanA3SW5OalpXNWhjbWx2SWpvaVZGSkJUbE5HUlZJaUxDSnBibWwwYVdGMGIzSWlPaUpRUVZsRlVpSXNJbWx1YVhScFlYUnZjbFI1Y0dVaU9pSkRUMDVUVlUxRlVpSjlmUQA',
+    createdDate: '2020-05-23T17:31:29.000Z'
+  }
+  const base64Value = 'AYIC-AAAAAAAAeIfHWcucGF5ZWVmc3AubXNpc2RuLjIyNTU2OTk5MTI1ggLOZXlKMGNtRnVjMkZqZEdsdmJrbGtJam9pTlRWa09ESXdObVV0T0RCaU55MDBPR00wTFRrNU5HTXRaREEyTmpRd01XRXdZbU00SWl3aWNYVnZkR1ZKWkNJNklqRmtPVGhpTkdReExXWmpOVFV0TkRaa09DMDROV1EyTFRnNVl6TXdZMkZoWWpRME5pSXNJbkJoZVdWbElqcDdJbkJoY25SNVNXUkpibVp2SWpwN0luQmhjblI1U1dSVWVYQmxJam9pVFZOSlUwUk9JaXdpY0dGeWRIbEpaR1Z1ZEdsbWFXVnlJam9pTWpJMU5UWTVPVGt4TWpVaUxDSm1jM0JKWkNJNkluQmhlV1ZsWm5Od0luMTlMQ0p3WVhsbGNpSTZleUp3WVhKMGVVbGtTVzVtYnlJNmV5SndZWEowZVVsa1ZIbHdaU0k2SWsxVFNWTkVUaUlzSW5CaGNuUjVTV1JsYm5ScFptbGxjaUk2SWpJeU5UQTNNREE0TVRneElpd2labk53U1dRaU9pSndZWGxsY21aemNDSjlMQ0p3WlhKemIyNWhiRWx1Wm04aU9uc2lZMjl0Y0d4bGVFNWhiV1VpT25zaVptbHljM1JPWVcxbElqb2lUV0YwY3lJc0lteGhjM1JPWVcxbElqb2lTR0ZuYldGdUluMHNJbVJoZEdWUFprSnBjblJvSWpvaU1UazRNeTB4TUMweU5TSjlmU3dpWVcxdmRXNTBJanA3SW1OMWNuSmxibU41SWpvaVZWTkVJaXdpWVcxdmRXNTBJam94TWpNMExqSXpmU3dpZEhKaGJuTmhZM1JwYjI1VWVYQmxJanA3SW5OalpXNWhjbWx2SWpvaVZGSkJUbE5HUlZJaUxDSnBibWwwYVdGMGIzSWlPaUpRUVZsRlVpSXNJbWx1YVhScFlYUnZjbFI1Y0dVaU9pSkRUMDVUVlUxRlVpSjlmUQA=='
+  const transactionObject = {
+    transactionId: '55d8206e-80b7-48c4-994c-d066401a0bc8',
+    quoteId: '1d98b4d1-fc55-46d8-85d6-89c30caab446',
+    payee: {
+      partyIdInfo: {
+        partyIdType: 'MSISDN',
+        partyIdentifier: '22556999125',
+        fspId: 'payeefsp'
+      }
+    },
+    payer: {
+      partyIdInfo: {
+        partyIdType: 'MSISDN',
+        partyIdentifier: '22507008181',
+        fspId: 'payerfsp'
+      },
+      personalInfo: {
+        complexName: {
+          firstName: 'Mats',
+          lastName: 'Hagman'
+        },
+        dateOfBirth: '1983-10-25'
+      }
+    },
+    amount: {
+      currency: 'USD',
+      amount: 1234.23
+    },
+    transactionType: {
+      scenario: 'TRANSFER',
+      initiator: 'PAYER',
+      initiatorType: 'CONSUMER'
+    }
+  }
+
+  await transactionsTest.test('get ilpPacket object by transfer id', async (assert) => {
+    try {
+      sandbox.stub(IlpPackets, 'getById').returns(ilpPacket)
+      const expected = await TransactionsService.getById('6d3e964e-9a25-4ff5-a365-2cc5af348321')
+      assert.equal(expected, ilpPacket)
+      assert.end()
+    } catch (err) {
+      assert.assert(err instanceof Error, ` throws ${err} `)
+      assert.end()
+    }
+  })
+
+  await transactionsTest.test('get ilpPacket by transfer id should throw an error', async (assert) => {
+    try {
+      sandbox.stub(IlpPackets, 'getById').throws(new Error())
+      await TransactionsService.getById('6d3e964e-9a25-4ff5-a365-2cc5af348321')
+      assert.fail('Error not thrown')
+      assert.end()
+    } catch (err) {
+      assert.ok(err instanceof Error)
+      assert.end()
+    }
+  })
+
+  await transactionsTest.test('get transaction object by transfer id', async (assert) => {
+    try {
+      const expected = await TransactionsService.getTransactionObject(base64Value)
+      assert.deepEqual(expected, transactionObject)
+      assert.end()
+    } catch (err) {
+      assert.assert(err instanceof Error, ` throws ${err} `)
+      assert.end()
+    }
+  })
+
+  await transactionsTest.end()
+})

package/test/unit/domain/transfer/index.test.js

@@ -108,6 +108,7 @@ Test('Transfer Service', transferIndexTest => {
     sandbox.stub(TransferDuplicateCheckModel)
     sandbox.stub(TransferFulfilmentDuplicateCheckModel)
     sandbox.stub(TransferErrorDuplicateCheckModel)
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
     t.end()
   })
 

package/test/unit/domain/transfer/transform.test.js

@@ -29,6 +29,7 @@ const Sinon = require('sinon')
 const Uuid = require('uuid4')
 const TransformService = require('../../../../src/domain/transfer/transform')
 const Util = require('@mojaloop/central-services-shared').Util
+const Logger = require('@mojaloop/central-services-logger')
 
 Test('Transform Service', transformTest => {
   let sandbox
@@ -36,6 +37,7 @@ Test('Transform Service', transformTest => {
   transformTest.beforeEach(t => {
     sandbox = Sinon.createSandbox()
     // sandbox.stub(TransferObjectTransform)
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
     t.end()
   })
 

package/test/unit/handlers/admin/handler.test.js

@@ -42,6 +42,7 @@ const transfer = {
   }
 }
 
+const currentDate = new Date()
 const transferRecordOutPrepare = {
   transferId: 'b51ec534-ee48-4575-b6a9-ead2955b8999',
   payerFsp: 'dfsp1',
@@ -54,7 +55,7 @@ const transferRecordOutPrepare = {
   },
   ilpPacket: 'AYIBgQAAAAAAAASwNGxldmVsb25lLmRmc3AxLm1lci45T2RTOF81MDdqUUZERmZlakgyOVc4bXFmNEpLMHlGTFGCAUBQU0svMS4wCk5vbmNlOiB1SXlweUYzY3pYSXBFdzVVc05TYWh3CkVuY3J5cHRpb246IG5vbmUKUGF5bWVudC1JZDogMTMyMzZhM2ItOGZhOC00MTYzLTg0NDctNGMzZWQzZGE5OGE3CgpDb250ZW50LUxlbmd0aDogMTM1CkNvbnRlbnQtVHlwZTogYXBwbGljYXRpb24vanNvbgpTZW5kZXItSWRlbnRpZmllcjogOTI4MDYzOTEKCiJ7XCJmZWVcIjowLFwidHJhbnNmZXJDb2RlXCI6XCJpbnZvaWNlXCIsXCJkZWJpdE5hbWVcIjpcImFsaWNlIGNvb3BlclwiLFwiY3JlZGl0TmFtZVwiOlwibWVyIGNoYW50XCIsXCJkZWJpdElkZW50aWZpZXJcIjpcIjkyODA2MzkxXCJ9IgA',
   condition: 'YlK5TZyhflbXaDRPtR5zhCu8FrbgvrQwwmzuH0iQ0AI',
-  expirationDate: '2020-05-24T08:38:08.699-04:00',
+  expirationDate: new Date(currentDate.setDate(currentDate.getDate() + 1)),
   extensionList: {
     extension: [
       {
@@ -310,6 +311,7 @@ Test('Admin handler', adminHandlerTest => {
     sandbox.stub(TransferService, 'reconciliationTransferReserve')
     sandbox.stub(TransferService, 'reconciliationTransferCommit')
     sandbox.stub(TransferService, 'reconciliationTransferAbort')
+    sandbox.stub(TransferService, 'recordFundsIn')
     sandbox.stub(TransferService, 'getTransferStateChange')
     sandbox.stub(TransferService, 'getTransferState')
     sandbox.stub(TransferService, 'getTransferById')
@@ -373,9 +375,7 @@ Test('Admin handler', adminHandlerTest => {
 
         const result = await AdminHandler.transfer(null, Object.assign({}, messages[0]))
         Logger.info(result)
-        test.ok(TransferService.reconciliationTransferPrepare.callsArgWith(0, trxStub))
-        test.ok(TransferService.reconciliationTransferReserve.callsArgWith(0, trxStub))
-        test.ok(TransferService.reconciliationTransferCommit.callsArgWith(0, trxStub))
+        test.ok(TransferService.recordFundsIn.callsArgWith(0, trxStub))
         test.equal(result, true)
         test.end()
       } catch (e) {
@@ -416,7 +416,7 @@ Test('Admin handler', adminHandlerTest => {
           hasDuplicateId: false,
           hasDuplicateHash: false
         }))
-        TransferService.reconciliationTransferPrepare.callsArgWith(0, trxStub).throws(new Error())
+        TransferService.recordFundsIn.callsArgWith(0, trxStub).throws(new Error())
         await AdminHandler.transfer(null, Object.assign({}, messages[0]))
         test.fail('Error is not thrown!')
         test.end()

package/test/unit/handlers/bulk/get/handler.test.js

@@ -0,0 +1,401 @@
+/*****
+ 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>
+
+ * Steven Oderayi <steven.oderayi@modusbox.com>
+ --------------
+ ******/
+'use strict'
+
+const Uuid = require('uuid4')
+const Sinon = require('sinon')
+const Proxyquire = require('proxyquire')
+const Test = require('tapes')(require('tape'))
+const EventSdk = require('@mojaloop/event-sdk')
+const Kafka = require('@mojaloop/central-services-shared').Util.Kafka
+const MainUtil = require('@mojaloop/central-services-shared').Util
+const KafkaConsumer = require('@mojaloop/central-services-stream').Kafka.Consumer
+const Consumer = require('@mojaloop/central-services-stream').Util.Consumer
+const Enum = require('@mojaloop/central-services-shared').Enum
+const Comparators = require('@mojaloop/central-services-shared').Util.Comparators
+const Validator = require('../../../../../src/handlers/bulk/shared/validator')
+const BulkTransferService = require('../../../../../src/domain/bulkTransfer')
+const BulkTransferModel = require('../../../../../src/models/bulkTransfer/bulkTransfer')
+const ilp = require('../../../../../src/models/transfer/ilpPacket')
+// const TransferState = Enum.Transfers.TransferState
+// const TransferInternalState = Enum.Transfers.TransferInternalState
+
+const bulkTransfer = {
+  bulkTransferId: 'fake-bulk-transfer-id',
+  bulkQuoteId: 'fake-bulk-quote-id',
+  payerFsp: 'dfsp1',
+  payeeFsp: 'dfsp2',
+  expiration: '2016-05-24T08:38:08.699-04:00',
+  individualTransfers: [
+    {
+      transferId: 'b51ec534-ee48-4575-b6a9-ead2955b8999',
+      transferAmount: {
+        currency: 'USD',
+        amount: '433.88'
+      },
+      ilpPacket: 'AYIBgQAAAAAAAASwNGxldmVsb25lLmRmc3AxLm1lci45T2RTOF81MDdqUUZERmZlakgyOVc4bXFmNEpLMHlGTFGCAUBQU0svMS4wCk5vbmNlOiB1SXlweUYzY3pYSXBFdzVVc05TYWh3CkVuY3J5cHRpb246IG5vbmUKUGF5bWVudC1JZDogMTMyMzZhM2ItOGZhOC00MTYzLTg0NDctNGMzZWQzZGE5OGE3CgpDb250ZW50LUxlbmd0aDogMTM1CkNvbnRlbnQtVHlwZTogYXBwbGljYXRpb24vanNvbgpTZW5kZXItSWRlbnRpZmllcjogOTI4MDYzOTEKCiJ7XCJmZWVcIjowLFwidHJhbnNmZXJDb2RlXCI6XCJpbnZvaWNlXCIsXCJkZWJpdE5hbWVcIjpcImFsaWNlIGNvb3BlclwiLFwiY3JlZGl0TmFtZVwiOlwibWVyIGNoYW50XCIsXCJkZWJpdElkZW50aWZpZXJcIjpcIjkyODA2MzkxXCJ9IgA',
+      condition: 'YlK5TZyhflbXaDRPtR5zhCu8FrbgvrQwwmzuH0iQ0AI'
+    }
+  ],
+  extensionList: {
+    extension: [
+      {
+        key: 'key1',
+        value: 'value1'
+      },
+      {
+        key: 'key2',
+        value: 'value2'
+      }
+    ]
+  }
+}
+
+const bulkTransferReturn = {
+  bulkTransferId: bulkTransfer.bulkTransferId,
+  bulkTransferStateId: 'COMPLETED',
+  completedTimestamp: new Date().toISOString(),
+  payerFsp: 'payerfsp',
+  payeeFsp: 'payeefsp',
+  bulkQuoteId: bulkTransfer.bulkQuoteId,
+  expirationDate: new Date().toISOString()
+}
+
+const messageProtocol = {
+  id: Uuid(),
+  from: bulkTransfer.payerFsp,
+  to: bulkTransfer.payeeFsp,
+  type: 'application/json',
+  content: {
+    headers: {
+      'fspiop-source': bulkTransfer.payeeFsp,
+      'fspiop-destination': 'source'
+    },
+    uriParams: { id: bulkTransfer.bulkTransferId }
+  },
+  metadata: {
+    event: {
+      id: Uuid(),
+      type: Enum.Events.Event.Type.BULK,
+      action: Enum.Events.Event.Action.GET,
+      createdAt: new Date(),
+      state: {
+        status: 'success',
+        code: 0
+      }
+    }
+  },
+  pp: ''
+}
+
+const topicName = 'topic-test'
+
+const messages = [
+  {
+    topic: topicName,
+    value: messageProtocol
+  }
+]
+
+const config = {
+  options: {
+    mode: 2,
+    batchSize: 1,
+    pollFrequency: 10,
+    recursiveTimeout: 100,
+    messageCharset: 'utf8',
+    messageAsJSON: true,
+    sync: true,
+    consumeTimeout: 1000
+  },
+  rdkafkaConf: {
+    'client.id': 'kafka-test',
+    debug: 'all',
+    'group.id': 'central-ledger-kafka',
+    'metadata.broker.list': 'localhost:9092',
+    'enable.auto.commit': false
+  }
+}
+
+const command = () => { }
+
+let SpanStub
+let allBulkTransferHandlers
+
+Test('Bulk Transfer GET handler', getHandlerTest => {
+  let sandbox
+
+  getHandlerTest.beforeEach(test => {
+    sandbox = Sinon.createSandbox()
+    SpanStub = {
+      audit: sandbox.stub().callsFake(),
+      error: sandbox.stub().callsFake(),
+      finish: sandbox.stub().callsFake(),
+      debug: sandbox.stub().callsFake(),
+      info: sandbox.stub().callsFake(),
+      getChild: sandbox.stub().returns(SpanStub),
+      setTags: sandbox.stub().callsFake()
+    }
+
+    const TracerStub = {
+      extractContextFromMessage: sandbox.stub().callsFake(() => {
+        return {}
+      }),
+      createChildSpanFromContext: sandbox.stub().callsFake(() => {
+        return SpanStub
+      })
+    }
+
+    const EventSdkStub = {
+      Tracer: TracerStub
+    }
+
+    allBulkTransferHandlers = Proxyquire('../../../../../src/handlers/bulk/get/handler', {
+      '@mojaloop/event-sdk': EventSdkStub
+    })
+
+    sandbox.stub(KafkaConsumer.prototype, 'constructor').returns(Promise.resolve())
+    sandbox.stub(KafkaConsumer.prototype, 'connect').returns(Promise.resolve())
+    sandbox.stub(KafkaConsumer.prototype, 'consume').returns(Promise.resolve())
+    sandbox.stub(KafkaConsumer.prototype, 'commitMessageSync').returns(Promise.resolve())
+    sandbox.stub(Comparators)
+    sandbox.stub(Validator)
+    sandbox.stub(BulkTransferService)
+    sandbox.stub(BulkTransferModel)
+    sandbox.stub(Consumer, 'getConsumer').returns({
+      commitMessageSync: async function () {
+        return true
+      }
+    })
+    sandbox.stub(Consumer, 'isConsumerAutoCommitEnabled').returns(false)
+    sandbox.stub(ilp)
+    sandbox.stub(Kafka)
+    sandbox.stub(MainUtil.StreamingProtocol)
+    Kafka.produceGeneralMessage.returns(Promise.resolve())
+    test.end()
+  })
+
+  getHandlerTest.afterEach(test => {
+    sandbox.restore()
+    test.end()
+  })
+
+  getHandlerTest.test('registerGetBulkTransferHandler should', registerHandlerTest => {
+    registerHandlerTest.test('returns true when registering the GET bulk transfer handler', async (test) => {
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformAccountToTopicName.returns(topicName)
+      Kafka.proceed.returns(true)
+      Kafka.getKafkaConfig.returns(config)
+      const result = await allBulkTransferHandlers.registerGetBulkTransferHandler()
+      test.equal(result, true)
+      test.end()
+    })
+
+    registerHandlerTest.test('return an error when registering GET bulk transfer handler.', async (test) => {
+      try {
+        await Consumer.createHandler(topicName, config, command)
+        Kafka.transformGeneralTopicName.returns(topicName)
+        Kafka.getKafkaConfig.throws(new Error())
+        await allBulkTransferHandlers.registerGetBulkTransferHandler()
+        test.fail('Error not thrown')
+        test.end()
+      } catch (e) {
+        test.pass('Error thrown')
+        test.end()
+      }
+    })
+    registerHandlerTest.end()
+  })
+
+  getHandlerTest.test('get bulk transfer by id should', getBulkTransferTest => {
+    getBulkTransferTest.test('return true on a single message', async (test) => {
+      const localMessages = MainUtil.clone(messages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformAccountToTopicName.returns(topicName)
+      Kafka.proceed.returns(true)
+      Kafka.getKafkaConfig.returns(config)
+      const result = await allBulkTransferHandlers.getBulkTransfer(null, localMessages[0])
+      test.equal(result, true)
+      test.end()
+    })
+
+    getBulkTransferTest.test('return true on an array of messages', async (test) => {
+      const localMessages = MainUtil.clone(messages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformAccountToTopicName.returns(topicName)
+      Kafka.proceed.returns(true)
+      Kafka.getKafkaConfig.returns(config)
+      Consumer.isConsumerAutoCommitEnabled.returns(true)
+      const result = await allBulkTransferHandlers.getBulkTransfer(null, localMessages)
+      test.equal(result, true)
+      test.end()
+    })
+
+    getBulkTransferTest.test('return an error when an error is passed in', async (test) => {
+      try {
+        const localMessages = MainUtil.clone(messages)
+        await Consumer.createHandler(topicName, config, command)
+        Kafka.transformGeneralTopicName.returns(topicName)
+        Kafka.getKafkaConfig.returns(config)
+        await allBulkTransferHandlers.getBulkTransfer(true, localMessages)
+        test.fail('Error not thrown')
+        test.end()
+      } catch (e) {
+        test.pass('Error thrown')
+        test.end()
+      }
+    })
+
+    getBulkTransferTest.test('return an error when the Kafka topic is invalid', async (test) => {
+      const localMessages = MainUtil.clone(messages)
+      await Consumer.createHandler(topicName, config, command)
+      Consumer.getConsumer.throws(new Error())
+      Kafka.getKafkaConfig.returns(config)
+      const result = await allBulkTransferHandlers.getBulkTransfer(null, localMessages)
+      test.equal(result, true)
+      test.end()
+    })
+
+    getBulkTransferTest.test('return an error when the bulk transfer by id is not found', async (test) => {
+      const localMessages = MainUtil.clone(messages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformAccountToTopicName.returns(topicName)
+      Kafka.proceed.returns(true)
+      Kafka.getKafkaConfig.returns(config)
+      Validator.validateParticipantByName.returns({ isValid: true })
+      BulkTransferService.getParticipantsById.withArgs(bulkTransfer.bulkTransferId).returns({ payeeFsp: bulkTransfer.payeeFsp, payerFsp: bulkTransfer.payerFsp })
+      BulkTransferModel.getById.returns(null)
+      const result = await allBulkTransferHandlers.getBulkTransfer(null, localMessages)
+      test.equal(result, true)
+      test.end()
+    })
+
+    getBulkTransferTest.test('return an error when the bulk transfer by id is not found - autocommit enabled', async (test) => {
+      const localMessages = MainUtil.clone(messages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformAccountToTopicName.returns(topicName)
+      Kafka.proceed.returns(true)
+      Kafka.getKafkaConfig.returns(config)
+      Validator.validateParticipantByName.returns({ isValid: true })
+      BulkTransferService.getParticipantsById.withArgs(bulkTransfer.bulkTransferId).returns({ payeeFsp: bulkTransfer.payeeFsp, payerFsp: bulkTransfer.payerFsp })
+      BulkTransferModel.getById.returns(null)
+      Consumer.isConsumerAutoCommitEnabled.returns(true)
+      const result = await allBulkTransferHandlers.getBulkTransfer(null, localMessages)
+      test.equal(result, true)
+      test.end()
+    })
+
+    getBulkTransferTest.test('return an error when the requester is not involved in the bulk transfer', async (test) => {
+      const localMessages = MainUtil.clone(messages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformAccountToTopicName.returns(topicName)
+      Kafka.proceed.returns(true)
+      Kafka.getKafkaConfig.returns(config)
+      Validator.validateParticipantByName.returns({ isValid: true })
+      Validator.validateParticipantBulkTransferId.returns(false)
+      BulkTransferService.getParticipantsById.withArgs(bulkTransfer.bulkTransferId).returns({ payeeFsp: bulkTransfer.payeeFsp, payerFsp: bulkTransfer.payerFsp })
+      BulkTransferModel.getById.returns({})
+      Consumer.isConsumerAutoCommitEnabled.returns(true)
+      localMessages[0].value.from = 'invalidfsp'
+      const result = await allBulkTransferHandlers.getBulkTransfer(null, localMessages)
+      test.equal(result, true)
+      test.end()
+    })
+
+    getBulkTransferTest.test('return an error when the requester is not involved in the bulk transfer - autocommit disabled', async (test) => {
+      const localMessages = MainUtil.clone(messages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformAccountToTopicName.returns(topicName)
+      Kafka.proceed.returns(true)
+      Kafka.getKafkaConfig.returns(config)
+      Validator.validateParticipantByName.returns({ isValid: true })
+      Validator.validateParticipantBulkTransferId.returns(false)
+      BulkTransferService.getParticipantsById.withArgs(bulkTransfer.bulkTransferId).returns({ payeeFsp: bulkTransfer.payeeFsp, payerFsp: bulkTransfer.payerFsp })
+      BulkTransferModel.getById.returns({})
+      Consumer.isConsumerAutoCommitEnabled.returns(false)
+      localMessages[0].value.from = 'invalidfsp'
+      const result = await allBulkTransferHandlers.getBulkTransfer(null, localMessages)
+      test.equal(result, true)
+      test.end()
+    })
+
+    getBulkTransferTest.test('return an error when the bulk transfer by id is found - autocommit enabled', async (test) => {
+      const localMessages = MainUtil.clone(messages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformAccountToTopicName.returns(topicName)
+      Kafka.proceed.returns(true)
+      Kafka.getKafkaConfig.returns(config)
+      Validator.validateParticipantByName.returns({ isValid: true })
+      BulkTransferService.getParticipantsById.withArgs(bulkTransfer.bulkTransferId).returns({ payeeFsp: bulkTransfer.payeeFsp, payerFsp: bulkTransfer.payerFsp })
+      BulkTransferModel.getById.withArgs(bulkTransfer.bulkTransferId).returns(Promise.resolve(bulkTransferReturn))
+      Consumer.isConsumerAutoCommitEnabled.returns(true)
+      const result = await allBulkTransferHandlers.getBulkTransfer(null, localMessages)
+      test.equal(result, true)
+      test.end()
+    })
+
+    getBulkTransferTest.test('log an error when general message cannot be produced', async (test) => {
+      const localMessages = MainUtil.clone(messages)
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.proceed.throws(new Error())
+      Validator.validateParticipantByName.returns({ isValid: true })
+      BulkTransferService.getParticipantsById.withArgs(bulkTransfer.bulkTransferId).returns({ payeeFsp: bulkTransfer.payeeFsp, payerFsp: bulkTransfer.payerFsp })
+      const bulkTransferResult = MainUtil.clone(bulkTransferReturn)
+      bulkTransferResult.bulkTransferStateId = Enum.Transfers.BulkProcessingState.PROCESSING
+      bulkTransferResult.extensionList = []
+      BulkTransferModel.getById.withArgs(bulkTransfer.bulkTransferId).returns(Promise.resolve(bulkTransferResult))
+      const bulkTransferResult2 = {
+        ...bulkTransferResult,
+        bulkTransferState: 'COMPLETED',
+        payerBulkTransfer: {
+          bulkTransferState: 'COMPLETED',
+          individualTransferResults: []
+        },
+        payeeBulkTransfer: {
+          bulkTransferState: 'COMPLETED',
+          individualTransferResults: []
+        }
+      }
+      BulkTransferService.getBulkTransferById.withArgs(bulkTransfer.bulkTransferId).returns(Promise.resolve(bulkTransferResult2))
+
+      try {
+        await allBulkTransferHandlers.getBulkTransfer(null, localMessages)
+        const expectedState = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, '2001', 'Internal server error')
+        test.ok(SpanStub.finish.calledWith('', expectedState))
+        test.end()
+      } catch (e) {
+        test.fail('Error thrown')
+        test.end()
+      }
+    })
+
+    getBulkTransferTest.end()
+  })
+
+  getHandlerTest.end()
+})

package/test/unit/handlers/index.test.js

@@ -6,15 +6,21 @@ const Config = require('../../../src/lib/config')
 const Proxyquire = require('proxyquire')
 const Plugin = require('../../../src/handlers/api/plugin')
 const MetricsPlugin = require('../../../src/api/metrics/plugin')
+const Logger = require('@mojaloop/central-services-logger')
 
 Test('cli', async (cliTest) => {
+  let sandbox
+
   cliTest.beforeEach(test => {
+    sandbox = Sinon.createSandbox()
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
     console.log('start')
     test.end()
   })
 
   cliTest.afterEach(test => {
     console.log('end')
+    sandbox.restore()
     test.end()
   })
 

package/test/unit/handlers/positions/handler.test.js

@@ -6,6 +6,7 @@ const Kafka = require('@mojaloop/central-services-shared').Util.Kafka
 const Validator = require('../../../../src/handlers/transfers/validator')
 const TransferService = require('../../../../src/domain/transfer')
 const PositionService = require('../../../../src/domain/position')
+const SettlementModelCached = require('../../../../src/models/settlement/settlementModelCached')
 const MainUtil = require('@mojaloop/central-services-shared').Util
 const Consumer = require('@mojaloop/central-services-stream').Util.Consumer
 const KafkaConsumer = Consumer.Consumer
@@ -177,6 +178,7 @@ Test('Position handler', transferHandlerTest => {
     sandbox.stub(TransferService)
     sandbox.stub(PositionService)
     sandbox.stub(TransferStateChange)
+    sandbox.stub(SettlementModelCached)
     Kafka.transformAccountToTopicName.returns(topicName)
     Kafka.produceGeneralMessage.resolves()
     test.end()
@@ -793,6 +795,30 @@ Test('Position handler', transferHandlerTest => {
       test.end()
     })
 
+    positionsTest.test('update transferStateChange for BULK_ABORT action', async (test) => {
+      const isReversal = true
+      const transferStateChange = {
+        transferId: transferInfo.transferId,
+        transferStateId: TransferState.ABORTED_ERROR
+      }
+
+      await Consumer.createHandler(topicName, config, command)
+      Kafka.transformGeneralTopicName.returns(topicName)
+      Kafka.getKafkaConfig.returns(config)
+
+      const m = Object.assign({}, MainUtil.clone(messages[1]))
+      TransferService.getTransferInfoToChangePosition.withArgs(m.value.content.uriParams.id, Enum.Accounts.TransferParticipantRoleType.PAYER_DFSP, Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE).returns(transferInfo)
+      TransferStateChange.saveTransferStateChange.resolves(true)
+      PositionService.changeParticipantPosition.withArgs(transferInfo.participantCurrencyId, isReversal, transferInfo.amount, transferStateChange).resolves(true)
+      m.value.metadata.event.action = transferEventAction.BULK_ABORT
+      Kafka.proceed.returns(true)
+
+      const result = await allTransferHandlers.positions(null, m)
+      Logger.info(result)
+      test.equal(result, true)
+      test.end()
+    })
+
     positionsTest.test('Throw error when invalid action is received', async (test) => {
       try {
         await Consumer.createHandler(topicName, config, command)