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

package/test/unit/handlers/transfers/validator.test.js

@@ -55,165 +55,165 @@ Test('transfer validator', validatorTest => {
     test.end()
   })
 
-  validatorTest.test('validateByName should', validateByNameTest => {
-    validateByNameTest.test('pass validation for valid payload', async (test) => {
+  validatorTest.test('validatePrepare should', validatePrepareTest => {
+    validatePrepareTest.test('pass validation for valid payload', async (test) => {
       Participant.getByName.returns(Promise.resolve({ isActive: true }))
       Participant.getAccountByNameAndCurrency.returns(Promise.resolve({ currencyIsActive: true }))
       CryptoConditions.validateCondition.returns(true)
 
-      const { validationPassed } = await Validator.validateByName(payload, headers)
+      const { validationPassed } = await Validator.validatePrepare(payload, headers)
       test.equal(validationPassed, true)
       test.end()
     })
 
-    validateByNameTest.test('fail validation for no payload', async (test) => {
-      const { validationPassed, reasons } = await Validator.validateByName(null)
+    validatePrepareTest.test('fail validation for no payload', async (test) => {
+      const { validationPassed, reasons } = await Validator.validatePrepare(null)
       test.equal(validationPassed, false)
       test.deepEqual(reasons, ['Transfer must be provided'])
       test.end()
     })
 
-    validateByNameTest.test('fail validation when FSPIOP-Source doesnt match Payer', async (test) => {
+    validatePrepareTest.test('fail validation when FSPIOP-Source doesnt match Payer', async (test) => {
       const headersModified = { 'fspiop-source': 'dfsp2' }
-      const { validationPassed, reasons } = await Validator.validateByName(payload, headersModified)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headersModified)
       test.equal(validationPassed, false)
       test.deepEqual(reasons, ['FSPIOP-Source header should match Payer'])
       test.end()
     })
 
-    validateByNameTest.test('fail validation for invalid condition', async (test) => {
+    validatePrepareTest.test('fail validation for invalid condition', async (test) => {
       Participant.getByName.returns(Promise.resolve({ isActive: true }))
       Participant.getAccountByNameAndCurrency.returns(Promise.resolve({ currencyIsActive: true }))
       CryptoConditions.validateCondition.throws(new Error())
 
-      const { validationPassed, reasons } = await Validator.validateByName(payload, headers)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
       test.equal(validationPassed, false)
       test.deepEqual(reasons, ['Condition validation failed'])
       test.end()
     })
 
-    validateByNameTest.test('fail validation for no condition', async (test) => {
+    validatePrepareTest.test('fail validation for no condition', async (test) => {
       Participant.getByName.returns(Promise.resolve({ isActive: true }))
       Participant.getAccountByNameAndCurrency.returns(Promise.resolve({ currencyIsActive: true }))
       payload.condition = null
 
-      const { validationPassed, reasons } = await Validator.validateByName(payload, headers)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
       test.equal(validationPassed, false)
       test.deepEqual(reasons, ['Condition is required for a conditional transfer'])
       test.end()
     })
 
-    validateByNameTest.test('Fail validation for invalid expiration date', async (test) => {
+    validatePrepareTest.test('Fail validation for invalid expiration date', async (test) => {
       Participant.getByName.returns(Promise.resolve({ isActive: true }))
       Participant.getAccountByNameAndCurrency.returns(Promise.resolve({ currencyIsActive: true }))
       CryptoConditions.validateCondition.returns(true)
       payload.expiration = '1971-11-24T08:38:08.699-04:00'
 
-      const { validationPassed, reasons } = await Validator.validateByName(payload, headers)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
       test.equal(validationPassed, false)
       test.deepEqual(reasons, ['Expiration date 1971-11-24T12:38:08.699Z is already in the past'])
       test.end()
     })
 
-    validateByNameTest.test('fail validation for no expiration date', async (test) => {
+    validatePrepareTest.test('fail validation for no expiration date', async (test) => {
       Participant.getByName.returns(Promise.resolve({ isActive: true }))
       Participant.getAccountByNameAndCurrency.returns(Promise.resolve({ currencyIsActive: true }))
       CryptoConditions.validateCondition.returns(true)
       payload.expiration = null
 
-      const { validationPassed, reasons } = await Validator.validateByName(payload, headers)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
       test.equal(validationPassed, false)
       test.deepEqual(reasons, ['Expiration is required for conditional transfer'])
       test.end()
     })
 
-    validateByNameTest.test('fail validation for invalid participant', async (test) => {
+    validatePrepareTest.test('fail validation for invalid participant', async (test) => {
       Participant.getByName.withArgs('dfsp1').returns(Promise.resolve({ isActive: true }))
       Participant.getByName.withArgs('dfsp2').returns(Promise.resolve(null))
       Participant.getAccountByNameAndCurrency.returns(Promise.resolve({ currencyIsActive: true }))
       CryptoConditions.validateCondition.returns(true)
 
-      const { validationPassed, reasons } = await Validator.validateByName(payload, headers)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
       test.equal(validationPassed, false)
       test.deepEqual(reasons, ['Participant dfsp2 not found'])
       test.end()
     })
 
-    validateByNameTest.test('fail validation for inactive participant', async (test) => {
+    validatePrepareTest.test('fail validation for inactive participant', async (test) => {
       Participant.getByName.withArgs('dfsp1').returns(Promise.resolve({ isActive: true }))
       Participant.getByName.withArgs('dfsp2').returns(Promise.resolve({ isActive: false }))
       Participant.getAccountByNameAndCurrency.returns(Promise.resolve({ currencyIsActive: true }))
       CryptoConditions.validateCondition.returns(true)
 
-      const { validationPassed, reasons } = await Validator.validateByName(payload, headers)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
       test.equal(validationPassed, false)
       test.deepEqual(reasons, ['Participant dfsp2 is inactive'])
       test.end()
     })
 
-    validateByNameTest.test('fail validation for invalid account', async (test) => {
+    validatePrepareTest.test('fail validation for invalid account', async (test) => {
       Participant.getByName.withArgs('dfsp1').returns(Promise.resolve({ isActive: true }))
       Participant.getByName.withArgs('dfsp2').returns(Promise.resolve({ isActive: true }))
       Participant.getAccountByNameAndCurrency.withArgs('dfsp1', 'USD', Enum.Accounts.LedgerAccountType.POSITION).returns(Promise.resolve({ currencyIsActive: true }))
       Participant.getAccountByNameAndCurrency.withArgs('dfsp2', 'USD', Enum.Accounts.LedgerAccountType.POSITION).returns(Promise.resolve(null))
       CryptoConditions.validateCondition.returns(true)
 
-      const { validationPassed, reasons } = await Validator.validateByName(payload, headers)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
       test.equal(validationPassed, false)
       test.deepEqual(reasons, ['Participant dfsp2 USD account not found'])
       test.end()
     })
 
-    validateByNameTest.test('fail validation for inactive account', async (test) => {
+    validatePrepareTest.test('fail validation for inactive account', async (test) => {
       Participant.getByName.withArgs('dfsp1').returns(Promise.resolve({ isActive: true }))
       Participant.getByName.withArgs('dfsp2').returns(Promise.resolve({ isActive: true }))
       Participant.getAccountByNameAndCurrency.withArgs('dfsp1', 'USD', Enum.Accounts.LedgerAccountType.POSITION).returns(Promise.resolve({ currencyIsActive: true }))
       Participant.getAccountByNameAndCurrency.withArgs('dfsp2', 'USD', Enum.Accounts.LedgerAccountType.POSITION).returns(Promise.resolve({ currencyIsActive: false }))
       CryptoConditions.validateCondition.returns(true)
 
-      const { validationPassed, reasons } = await Validator.validateByName(payload, headers)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
       test.equal(validationPassed, false)
       test.deepEqual(reasons, ['Participant dfsp2 USD account is inactive'])
       test.end()
     })
 
-    validateByNameTest.test('pass validation for valid payload', async (test) => {
+    validatePrepareTest.test('pass validation for valid payload', async (test) => {
       Participant.getByName.returns(Promise.resolve({ isActive: true }))
       Participant.getAccountByNameAndCurrency.returns(Promise.resolve({ currencyIsActive: true }))
       CryptoConditions.validateCondition.returns(true)
       payload.amount.amount = '123.12345'
 
-      const { validationPassed, reasons } = await Validator.validateByName(payload, headers)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
       test.equal(validationPassed, false)
       test.deepEqual(reasons, ['Amount 123.12345 exceeds allowed scale of 4'])
       test.end()
     })
 
-    validateByNameTest.test('fail validation for same payer and payee', async (test) => {
+    validatePrepareTest.test('fail validation for same payer and payee', async (test) => {
       Participant.getByName.returns(Promise.resolve({ isActive: true }))
       Participant.getAccountByNameAndCurrency.returns(Promise.resolve({ currencyIsActive: true }))
       CryptoConditions.validateCondition.returns(true)
       payload.payeeFsp = payload.payerFsp
 
-      const { validationPassed, reasons } = await Validator.validateByName(payload, headers)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
       test.equal(validationPassed, false)
-      test.deepEqual(reasons, ['Payer and Payee should be different'])
+      test.deepEqual(reasons, ['Payer FSP and Payee FSP should be different, unless on-us tranfers are allowed by the Scheme'])
       test.end()
     })
 
-    validateByNameTest.test('pass validation for valid payload', async (test) => {
+    validatePrepareTest.test('pass validation for valid payload', async (test) => {
       Participant.getByName.returns(Promise.resolve({ isActive: true }))
       Participant.getAccountByNameAndCurrency.returns(Promise.resolve({ currencyIsActive: true }))
       CryptoConditions.validateCondition.returns(true)
       payload.amount.amount = '123456789012345.6789'
 
-      const { validationPassed, reasons } = await Validator.validateByName(payload, headers)
+      const { validationPassed, reasons } = await Validator.validatePrepare(payload, headers)
       test.equal(validationPassed, false)
       test.deepEqual(reasons, ['Amount 123456789012345.6789 exceeds allowed precision of 18'])
       test.end()
     })
 
-    validateByNameTest.end()
+    validatePrepareTest.end()
   })
 
   validatorTest.test('validateById should', validateByIdTest => {

package/test/unit/lib/cache.test.js

@@ -8,21 +8,11 @@ const Enums = require('../../../src/lib/enum')
 
 Test('Cache test', async (cacheTest) => {
   let sandbox
-  let allEnumsValue
-
-  const templateValueForEnum = (enumId) => {
-    return { testEnumKey: `testEnum of ${enumId}` }
-  }
 
   cacheTest.beforeEach(t => {
     sandbox = Sinon.createSandbox()
     sandbox.stub(Enums)
     sandbox.stub(Config.CACHE_CONFIG, 'CACHE_ENABLED')
-    allEnumsValue = {}
-    for (const enumId of Enums.enumsIds) {
-      Enums[enumId].returns(Promise.resolve(templateValueForEnum(enumId)))
-      allEnumsValue[enumId] = templateValueForEnum(enumId)
-    }
     Cache.registerCacheClient({
       id: 'testCacheClient',
       preloadCache: async () => sandbox.stub()
@@ -60,60 +50,6 @@ Test('Cache test', async (cacheTest) => {
     initTest.end()
   })
 
-  await cacheTest.test('Caching enums:', async (enumTest) => {
-    await enumTest.test('should pre-fetch all enums info at start', async (test) => {
-      // Check that Enums haven't been called
-      for (const enumId of Enums.enumsIds) {
-        test.notOk(Enums[enumId].calledOnce, `enum ${enumId} wasn't called before initCache`)
-      }
-
-      // This should pre-fetch all enums
-      await Cache.initCache()
-
-      // Check that Enums have been called
-      for (const enumId of Enums.enumsIds) {
-        test.ok(Enums[enumId].calledOnce, `enum ${enumId} was called once during initCache`)
-      }
-      await Cache.destroyCache()
-      test.end()
-    })
-
-    await enumTest.test('should call enums only once and then should return cached data (should not call enums again)', async (test) => {
-      // This should pre-fetch all enums
-      await Cache.initCache()
-
-      // Check that Enums have been called once
-      for (const enumId of Enums.enumsIds) {
-        test.ok(Enums[enumId].calledOnce, `enum ${enumId} was called once`)
-      }
-
-      // Get Enum info from cache and verify values
-      for (const enumId of Enums.enumsIds) {
-        const returnedValue = await Cache.getEnums(enumId)
-        test.deepEqual(templateValueForEnum(enumId), returnedValue, `value for enum ${enumId} is correct`)
-      }
-
-      // Check again that Enums have been called once (so cache worked)
-      for (const enumId of Enums.enumsIds) {
-        test.ok(Enums[enumId].calledOnce, `enum ${enumId} was still called just once`)
-      }
-
-      // Let's check the "all" summary-enum also works well on cached values
-      const returnedAllEnumsValue = await Cache.getEnums('all')
-      test.deepEqual(returnedAllEnumsValue, allEnumsValue, 'the "all" enum type works well')
-
-      // Check again that Enums have been called once (so cache worked)
-      for (const enumId of Enums.enumsIds) {
-        test.ok(Enums[enumId].calledOnce, `enum ${enumId} was still called just once`)
-      }
-
-      await Cache.destroyCache()
-      test.end()
-    })
-
-    enumTest.end()
-  })
-
   await cacheTest.test('Cache client', async (cacheClientTest) => {
     await cacheClientTest.test('preload should be called once during Cache.initCache()', async (test) => {
       let preloadCacheCalledCnt = 0

package/test/unit/lib/cachingOfEnums.test.js

@@ -0,0 +1,121 @@
+/*****
+ Test that integrated enumsCached.js and cache.js work together as expected.
+
+ 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 EnumUncached = require('../../../src/lib/enum')
+const Config = require('../../../src/lib/config')
+const Cache = require('../../../src/lib/cache')
+const Model = require('../../../src/lib/enumCached')
+
+Test('Enums with caching', async (enumCachedTest) => {
+  let sandbox
+  let allEnumsValue
+
+  const templateValueForEnum = (enumId) => {
+    return { testEnumKey: `testEnum of ${enumId}` }
+  }
+
+  enumCachedTest.beforeEach(t => {
+    sandbox = Sinon.createSandbox()
+    sandbox.stub(EnumUncached)
+    sandbox.stub(Config.CACHE_CONFIG, 'CACHE_ENABLED')
+    Config.CACHE_CONFIG.CACHE_ENABLED = true
+    allEnumsValue = {}
+    for (const enumId of EnumUncached.enumsIds) {
+      EnumUncached[enumId].returns(Promise.resolve(templateValueForEnum(enumId)))
+      allEnumsValue[enumId] = templateValueForEnum(enumId)
+    }
+    t.end()
+  })
+
+  enumCachedTest.afterEach(t => {
+    sandbox.restore()
+    t.end()
+  })
+
+  await enumCachedTest.test('Cache should pre-fetch all enums info at start', async (test) => {
+    // Check that Enums haven't been called
+    for (const enumId of EnumUncached.enumsIds) {
+      test.notOk(EnumUncached[enumId].calledOnce, `enum ${enumId} wasn't called before initCache`)
+    }
+
+    // This should pre-fetch all enums
+    await Model.initialize()
+    await Cache.initCache()
+
+    // Check that Enums have been called
+    for (const enumId of EnumUncached.enumsIds) {
+      test.ok(EnumUncached[enumId].calledOnce, `enum ${enumId} was called once during initCache`)
+    }
+    await Cache.destroyCache()
+    await Cache.dropClients()
+    test.end()
+  })
+
+  await enumCachedTest.test('should call enums only once and then should return cached data (should not call enums again)', async (test) => {
+    // Check that Enums haven't been called
+    for (const enumId of EnumUncached.enumsIds) {
+      test.notOk(EnumUncached[enumId].calledOnce, `enum ${enumId} wasn't called before initCache`)
+    }
+
+    // This should pre-fetch all enums
+    await Model.initialize()
+    await Cache.initCache()
+
+    // Check that Enums have been called once
+    for (const enumId of EnumUncached.enumsIds) {
+      test.ok(EnumUncached[enumId].calledOnce, `enum ${enumId} was called once`)
+    }
+
+    // Get Enum info from cache and verify values
+    for (const enumId of EnumUncached.enumsIds) {
+      const returnedValue = await Model.getEnums(enumId)
+      test.deepEqual(templateValueForEnum(enumId), returnedValue, `value for enum ${enumId} is correct`)
+    }
+
+    // Check again that Enums have been called once (so cache worked)
+    for (const enumId of EnumUncached.enumsIds) {
+      test.ok(EnumUncached[enumId].calledOnce, `enum ${enumId} was still called just once`)
+    }
+
+    // Let's check the "all" summary-enum also works well on cached values
+    const returnedAllEnumsValue = await Model.getEnums('all')
+    test.deepEqual(returnedAllEnumsValue, allEnumsValue, 'the "all" enum type works well')
+
+    // Check again that Enums have been called once (so cache worked)
+    for (const enumId of EnumUncached.enumsIds) {
+      test.ok(EnumUncached[enumId].calledOnce, `enum ${enumId} was still called just once`)
+    }
+    await Cache.destroyCache()
+    await Cache.dropClients()
+    test.end()
+  })
+
+  await enumCachedTest.end()
+})

package/test/unit/lib/config.test.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const Test = require('tape')
+const Proxyquire = require('proxyquire')
+const Defaults = require('../../../config/default.json')
+
+Test('Config should', configTest => {
+  configTest.test('enable API_DOC_ENDPOINTS_ENABLED', async function (test) {
+    const DefaultsStub = { ...Defaults }
+    DefaultsStub.API_DOC_ENDPOINTS_ENABLED = true
+
+    const Config = Proxyquire('../../../src/lib/config', {
+      '../../config/default.json': DefaultsStub
+    })
+
+    test.ok(Config.API_DOC_ENDPOINTS_ENABLED === true)
+    test.end()
+  })
+
+  configTest.test('disable API_DOC_ENDPOINTS_ENABLED', async function (test) {
+    console.log(Defaults)
+    const DefaultsStub = { ...Defaults }
+    DefaultsStub.API_DOC_ENDPOINTS_ENABLED = false
+
+    const Config = Proxyquire('../../../src/lib/config', {
+      '../../config/default.json': DefaultsStub
+    })
+
+    test.ok(Config.API_DOC_ENDPOINTS_ENABLED === false)
+    test.end()
+  })
+
+  configTest.end()
+})

package/test/unit/lib/enum.test.js

@@ -163,6 +163,7 @@ Test('Enum test', async (enumTest) => {
 
   enumTest.beforeEach(t => {
     sandbox = Sinon.createSandbox()
+
     Db.endpointType = {
       find: sandbox.stub()
     }
@@ -191,6 +192,10 @@ Test('Enum test', async (enumTest) => {
       find: sandbox.stub()
     }
 
+    Db.from = (table) => {
+      return Db[table]
+    }
+
     t.end()
   })
 
@@ -202,7 +207,7 @@ Test('Enum test', async (enumTest) => {
   await enumTest.test('endpointType should', async (endpointTypeTest) => {
     await endpointTypeTest.test('return the endpoints', async (test) => {
       try {
-        Db.endpointType.find.returns(Promise.resolve(allEnums.endpointType))
+        Db.from('endpointType').find.returns(Promise.resolve(allEnums.endpointType))
         const result = await Model.endpointType()
         test.deepEqual(result, allEnumExpected.endpointType, 'Results match')
         test.end()

package/test/unit/lib/enumCached.test.js

@@ -0,0 +1,82 @@
+/*****
+ 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 EnumUncached = require('../../../src/lib/enum')
+const Cache = require('../../../src/lib/cache')
+const Model = require('../../../src/lib/enumCached')
+
+Test('Enums cached model', async (enumCachedTest) => {
+  let sandbox
+
+  enumCachedTest.beforeEach(t => {
+    sandbox = Sinon.createSandbox()
+    sandbox.stub(Cache)
+    sandbox.stub(EnumUncached)
+    t.end()
+  })
+
+  enumCachedTest.afterEach(t => {
+    sandbox.restore()
+    t.end()
+  })
+
+  await enumCachedTest.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 enumCachedTest.test('calls drop() for invalidateEnumCache', 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.invalidateEnumCache()
+    test.ok(cacheClient.drop.calledOnce)
+
+    test.end()
+  })
+
+  await enumCachedTest.end()
+})

package/test/unit/lib/healthCheck/subServiceHealth.test.js

@@ -36,6 +36,7 @@ const { statusEnum, serviceName } = require('@mojaloop/central-services-shared')
 
 const MigrationLockModel = require('../../../../src/models/misc/migrationLock')
 const Consumer = require('@mojaloop/central-services-stream').Util.Consumer
+const Logger = require('@mojaloop/central-services-logger')
 
 const {
   getSubServiceHealthBroker,
@@ -49,6 +50,7 @@ Test('SubServiceHealth test', subServiceHealthTest => {
     sandbox = Sinon.createSandbox()
     sandbox.stub(Consumer, 'getListOfTopics')
     sandbox.stub(Consumer, 'isConnected')
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
 
     t.end()
   })

package/test/unit/lib/requestLogger.test.js

@@ -39,6 +39,8 @@ Test('logger', loggerTest => {
     sandbox = Sinon.createSandbox()
     sandbox.stub(Logger, 'info')
     sandbox.stub(Logger, 'debug')
+    sandbox.stub(Logger, 'isInfoEnabled').value(true)
+    sandbox.stub(Logger, 'isDebugEnabled').value(true)
     sandbox.stub(Util, 'inspect')
 
     test.end()
@@ -54,18 +56,18 @@ Test('logger', loggerTest => {
       const request = {
         headers: { traceid: '123456' },
         method: 'post',
-        url: { path: '/participants' },
+        path: '/participants',
         query: { token: '1234' },
-        body: 'this is the body'
+        payload: 'this is the body'
       }
       RequestLogger.logRequest(request)
       test.ok(Logger.debug.calledThrice)
       const args = Logger.debug.firstCall.args
       const args2 = Logger.debug.secondCall.args
       const args3 = Logger.debug.thirdCall.args
-      test.equal(args[0], `L1p-Trace-Id=${request.headers.traceid} - Method: ${request.method} Path: ${request.url.path} Query: ${JSON.stringify(request.query)}`)
-      test.equal(args2[0], `L1p-Trace-Id=${request.headers.traceid} - Headers: ${JSON.stringify(request.headers)}`)
-      test.equal(args3[0], `L1p-Trace-Id=${request.headers.traceid} - Body: ${request.body}`)
+      test.equal(args[0], `L1p-Trace-Id=${request.headers.traceid} - Method: ${request.method}, Path: ${request.path}, Query: ${JSON.stringify(request.query)}`)
+      test.equal(args2[0], `L1p-Trace-Id=${request.headers.traceid} - Headers: ${JSON.stringify(request.headers, null, 2)}`)
+      test.equal(args3[0], `L1p-Trace-Id=${request.headers.traceid} - Body: ${JSON.stringify(request.payload, null, 2)}`)
       test.end()
     })
 
@@ -73,7 +75,7 @@ Test('logger', loggerTest => {
       const request = {
         headers: { traceid: '123456' },
         method: 'post',
-        url: { path: '/participants' },
+        path: '/participants',
         query: { token: '1234' }
       }
       RequestLogger.logRequest(request)
@@ -88,11 +90,11 @@ Test('logger', loggerTest => {
     responseTest.test('send info message to the serviceslogger', test => {
       const request = {
         headers: { traceid: '123456' },
-        response: { source: 'this is the response', statusCode: '200' }
+        response: { message: 'this is the response', statusCode: '200', stack: 'test' }
       }
       RequestLogger.logResponse(request)
       const args = Logger.debug.firstCall.args
-      test.equal(args[0], `L1p-Trace-Id=${request.headers.traceid} - Response: ${JSON.stringify(request.response.source)} Status: ${request.response.statusCode}`)
+      test.equal(args[0], `L1p-Trace-Id=${request.headers.traceid} - Response: ${JSON.stringify(request.response, null, 2)}, Status: ${request.response.statusCode}, Stack: ${request.response.stack}`)
       test.end()
     })
 
@@ -108,12 +110,12 @@ Test('logger', loggerTest => {
     responseTest.test('use util.inspect if JSON.stringify throws', test => {
       const request = {
         headers: { traceid: '123456' },
-        response: { source: { body: 'this is the response' }, statusCode: '200' }
+        response: { body: 'this is the response', statusCode: '200' }
       }
-      request.response.source.circular = request.response
+      request.response.circular = request.response
       RequestLogger.logResponse(request)
       const args = Util.inspect.firstCall.args
-      test.equal(args[0], request.response.source)
+      test.equal(args[0], request.response)
       test.end()
     })
     responseTest.end()
@@ -122,7 +124,7 @@ Test('logger', loggerTest => {
   loggerTest.test('websocket should', requestTest => {
     requestTest.test('send info message to the serviceslogger', test => {
       const request = {
-        body: 'this is the body'
+        payload: 'this is the body'
       }
       RequestLogger.logWebsocket(request)
       const args = Logger.info.firstCall.args