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

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

@@ -0,0 +1,197 @@
+/*****
+ 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
+ - Claudio Viola <claudio.viola@modusbox.com>
+ --------------
+ ******/
+'use strict'
+
+const Test = require('tapes')(require('tape'))
+const Sinon = require('sinon')
+const LedgerAccountTypeModel = require('../../../../src/models/ledgerAccountType/ledgerAccountType')
+
+const LedgerAccountTypeService = require('../../../../src/domain/ledgerAccountTypes/index')
+
+Test('LedgerAccountTypeService', async (ledgerAccountTypeServiceTest) => {
+  let sandbox
+
+  ledgerAccountTypeServiceTest.beforeEach(t => {
+    sandbox = Sinon.createSandbox()
+    sandbox.stub(LedgerAccountTypeModel)
+    t.end()
+  })
+
+  ledgerAccountTypeServiceTest.afterEach(t => {
+    sandbox.restore()
+    t.end()
+  })
+
+  await ledgerAccountTypeServiceTest.test('create when everything is ok', async (assert) => {
+    try {
+      const payload = {
+        name: 'INTERCHANGE_FEE_SETTLEMENT',
+        description: 'settlement account type for interchange fees',
+        isActive: true,
+        isSettleable: true,
+        createdDate: '2018-10-11T11:45:00.000Z'
+      }
+      const ledgerAccountTypeId = 127
+      LedgerAccountTypeModel.create.resolves(ledgerAccountTypeId)
+
+      const expected = await LedgerAccountTypeService.create(payload.name, payload.description, payload.isActive, payload.isSettleable)
+      assert.equal(LedgerAccountTypeModel.create.callCount, 1, 'should call the model create function')
+      assert.equal(LedgerAccountTypeModel.create.lastCall.args[0], payload.name, 'should call the model with the right argument: name')
+      assert.equal(LedgerAccountTypeModel.create.lastCall.args[1], payload.description, 'should call the model with the right argument: description')
+      assert.equal(LedgerAccountTypeModel.create.lastCall.args[2], payload.isActive, 'should call the model with the right argument: isActive')
+      assert.equal(LedgerAccountTypeModel.create.lastCall.args[3], payload.isSettleable, 'should call the model with the right argument: isSettleable')
+      assert.equal(expected, true, 'should return true')
+      assert.end()
+    } catch (err) {
+      assert.fail(`Error thrown ${err}`, 'should have not thrown an error')
+      assert.end()
+    }
+  })
+
+  await ledgerAccountTypeServiceTest.test('create when default arguments are not passed', async (assert) => {
+    try {
+      const payload = {
+        name: 'INTERCHANGE_FEE_SETTLEMENT',
+        description: 'settlement account type for interchange fees',
+        isActive: false,
+        isSettleable: false,
+        createdDate: '2018-10-11T11:45:00.000Z'
+      }
+      LedgerAccountTypeModel.create.resolves(payload)
+      const expected = await LedgerAccountTypeService.create(payload.name, payload.description)
+      assert.equal(LedgerAccountTypeModel.create.callCount, 1, 'should call the model create function')
+      assert.equal(LedgerAccountTypeModel.create.lastCall.args[0], payload.name, 'should call the model with the right argument: name')
+      assert.equal(LedgerAccountTypeModel.create.lastCall.args[1], payload.description, 'should call the model with the right argument: description')
+      assert.equal(LedgerAccountTypeModel.create.lastCall.args[2], false, 'should call the model with the right default argument: isActive: false')
+      assert.equal(LedgerAccountTypeModel.create.lastCall.args[3], false, 'should call the model with the right default argument: isSettleable: false')
+      assert.equal(expected, true, 'should return true')
+      assert.end()
+    } catch (err) {
+      assert.fail('Error thrown', 'should have not thrown an error')
+      assert.end()
+    }
+  })
+
+  await ledgerAccountTypeServiceTest.test('create when LedgerAccountTypeModel service fails', async (assert) => {
+    try {
+      const payload = {
+        name: 'INTERCHANGE_FEE_SETTLEMENT',
+        description: 'settlement account type for interchange fees',
+        isActive: true,
+        isSettleable: true
+      }
+      LedgerAccountTypeModel.create.throws(new Error())
+      await LedgerAccountTypeService.create(payload.name, payload.description, payload.isActive, payload.isSettleable)
+      assert.fail('Error not thrown', 'should have thrown an error')
+      assert.end()
+    } catch (err) {
+      assert.equal(LedgerAccountTypeModel.create.callCount, 1, 'should call the model create function')
+      assert.ok(err instanceof Error, 'should throw an error')
+      assert.end()
+    }
+  })
+
+  await ledgerAccountTypeServiceTest.test('getAll should return all ledgerAccountTypes model', async (assert) => {
+    const payload = [
+      {
+        name: 'INTERCHANGE_FEE_SETTLEMENT',
+        description: 'settlement account type for interchange fees',
+        isActive: true,
+        isSettleable: true,
+        createdDate: '2018-10-11T11:45:00.000Z'
+      },
+      {
+        name: 'INTERCHANGE_FEE_2_SETTLEMENT',
+        description: 'settlement account type for interchange fees type 2',
+        isActive: true,
+        isSettleable: true,
+        createdDate: '2018-10-11T12:45:00.000Z'
+      }
+    ]
+
+    try {
+      LedgerAccountTypeModel.getAll.resolves(payload)
+      const result = await LedgerAccountTypeService.getAll()
+      assert.deepEqual(result, payload, 'should return an array of ledger Account types models')
+      assert.equal(LedgerAccountTypeModel.getAll.callCount, 1, 'should call the model getAll function')
+      assert.equal(LedgerAccountTypeModel.getAll.lastCall.args[0], undefined, 'should call the model with getAll function with no parameters')
+      assert.end()
+    } catch (err) {
+      assert.assert(err instanceof Error, ` throws ${err} `)
+      assert.end()
+    }
+  })
+
+  await ledgerAccountTypeServiceTest.test('getAll should throw an error if the LedgerAccountTypeModel service fails', async (assert) => {
+    try {
+      LedgerAccountTypeModel.getAll.rejects(new Error('Error message'))
+      await LedgerAccountTypeService.getAll()
+      assert.fail('Error not thrown', 'should have thrown an error')
+      assert.end()
+    } catch (err) {
+      assert.assert(err instanceof Error, 'should throw an error')
+      assert.ok(err.message, 'Error message', 'should throw the right error message')
+
+      assert.end()
+    }
+  })
+
+  await ledgerAccountTypeServiceTest.test('getByName should return one ledgerAccountTypes if found', async (assert) => {
+    const payload = {
+      name: 'INTERCHANGE_FEE_SETTLEMENT',
+      description: 'settlement account type for interchange fees',
+      isActive: true,
+      isSettleable: true,
+      createdDate: '2018-10-11T11:45:00.000Z'
+    }
+    try {
+      LedgerAccountTypeModel.getLedgerAccountByName.resolves(payload)
+      const result = await LedgerAccountTypeService.getByName(payload.name)
+      assert.deepEqual(result, payload, 'should return one ledger Account type models')
+      assert.equal(LedgerAccountTypeModel.getLedgerAccountByName.callCount, 1, 'should call the model getLedgerAccountByName function')
+      assert.equal(LedgerAccountTypeModel.getLedgerAccountByName.lastCall.args[0], payload.name, 'should call the  model getLedgerAccountByName function with the name parameter')
+      assert.end()
+    } catch (err) {
+      assert.fail(err instanceof Error, ` throws ${err} `)
+      assert.end()
+    }
+  })
+
+  await ledgerAccountTypeServiceTest.test('getByName should throw an error if the LedgerAccountTypeModel service fails', async (assert) => {
+    try {
+      LedgerAccountTypeModel.getLedgerAccountByName.rejects(new Error('Error message'))
+
+      await LedgerAccountTypeService.getByName('settlement')
+      assert.fail('Error not thrown', 'should have thrown an error')
+      assert.end()
+    } catch (err) {
+      assert.assert(err instanceof Error, 'should throw an error')
+      assert.ok(err.message, 'Error message', 'should throw the right error message')
+      assert.end()
+    }
+  })
+
+  await ledgerAccountTypeServiceTest.end()
+})

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

@@ -40,6 +40,7 @@ const ParticipantPositionChangeModel = require('../../../../src/models/participa
 const LedgerAccountTypeFacade = require('../../../../src/models/participant/facade')
 const Kafka = require('@mojaloop/central-services-shared').Util.Kafka
 const LedgerAccountTypeModel = require('../../../../src/models/ledgerAccountType/ledgerAccountType')
+const EnumCached = require('../../../../src/lib/enumCached')
 
 const Service = require('../../../../src/domain/participant/index')
 
@@ -69,7 +70,7 @@ Test('Participant service', async (participantTest) => {
       currency: 'USD',
       isActive: 1,
       createdDate: new Date(),
-      currencyList: 'USD'
+      currencyList: ['USD']
     },
     {
       participantId: 1,
@@ -77,7 +78,7 @@ Test('Participant service', async (participantTest) => {
       currency: 'EUR',
       isActive: 1,
       createdDate: new Date(),
-      currencyList: 'EUR'
+      currencyList: ['EUR']
     }
   ]
   const participantCurrencyResult = [
@@ -138,6 +139,7 @@ Test('Participant service', async (participantTest) => {
     sandbox.stub(ParticipantCurrencyModel, 'getById')
     sandbox.stub(ParticipantCurrencyModel, 'destroyByParticipantId')
     sandbox.stub(ParticipantCurrencyModel, 'findOneByParams')
+    sandbox.stub(ParticipantCurrencyModel, 'hubAccountExists')
 
     sandbox.stub(ParticipantFacade, 'getEndpoint')
     sandbox.stub(ParticipantFacade, 'getAllEndpoints')
@@ -150,6 +152,7 @@ Test('Participant service', async (participantTest) => {
     sandbox.stub(ParticipantFacade, 'getAllAccountsByNameAndCurrency')
     sandbox.stub(ParticipantFacade, 'addHubAccountAndInitPosition')
     sandbox.stub(ParticipantFacade, 'getLimitsForAllParticipants')
+    sandbox.stub(ParticipantFacade, 'getAllNonHubParticipantsWithCurrencies')
 
     sandbox.stub(ParticipantLimitModel, 'getByParticipantCurrencyId')
     sandbox.stub(ParticipantLimitModel, 'destroyByParticipantCurrencyId')
@@ -157,6 +160,7 @@ Test('Participant service', async (participantTest) => {
     sandbox.stub(ParticipantPositionModel, 'getByParticipantCurrencyId')
     sandbox.stub(ParticipantPositionModel, 'destroyByParticipantCurrencyId')
     sandbox.stub(ParticipantPositionModel, 'destroyByParticipantId')
+    sandbox.stub(ParticipantPositionModel, 'createParticipantPositionRecords')
 
     sandbox.stub(ParticipantPositionChangeModel, 'getByParticipantPositionId')
 
@@ -166,6 +170,9 @@ Test('Participant service', async (participantTest) => {
     sandbox.stub(LedgerAccountTypeModel, 'getLedgerAccountByName')
 
     sandbox.stub(Kafka, 'produceGeneralMessage')
+    sandbox.stub(EnumCached)
+    EnumCached.getEnums.returns(Promise.resolve({ POSITION: 1, SETTLEMENT: 2, HUB_RECONCILIATION: 3, HUB_MULTILATERAL_SETTLEMENT: 4, HUB_FEE: 5 }))
+
     Db.participant = {
       insert: sandbox.stub(),
       update: sandbox.stub(),
@@ -181,6 +188,10 @@ Test('Participant service', async (participantTest) => {
       destroy: sandbox.stub()
     }
 
+    Db.from = (table) => {
+      return Db[table]
+    }
+
     participantFixtures.forEach((participant, index) => {
       participantMap.set(index + 1, participantResult[index])
       Db.participant.insert.withArgs({ participant }).returns(index)
@@ -641,6 +652,7 @@ Test('Participant service', async (participantTest) => {
       const settlementAccount = {
         participantCurrencyId: 2
       }
+      payload.name = participant.name
       ParticipantFacade.getByNameAndCurrency.withArgs(participant.name, payload.currency, 1).returns(participant)
       ParticipantFacade.getByNameAndCurrency.withArgs(participant.name, payload.currency, 2).returns(settlementAccount)
       ParticipantLimitModel.getByParticipantCurrencyId.withArgs(participant.participantCurrencyId).returns(null)
@@ -687,6 +699,7 @@ Test('Participant service', async (participantTest) => {
       const settlementAccount = {
         participantCurrencyId: 2
       }
+      limitPositionObj.name = participant.name
       ParticipantFacade.getByNameAndCurrency.withArgs(participant.name, payload.currency, 1).returns(participant)
       ParticipantFacade.getByNameAndCurrency.withArgs(participant.name, payload.currency, 2).returns(settlementAccount)
       ParticipantLimitModel.getByParticipantCurrencyId.withArgs(participant.participantCurrencyId).returns(null)
@@ -2073,5 +2086,105 @@ Test('Participant service', async (participantTest) => {
     }
   })
 
+  await participantTest.test('validateHubAccounts should', async (assert) => {
+    try {
+      const currency = 'USD'
+      ParticipantCurrencyModel.hubAccountExists.withArgs(currency, 3).resolves(true)
+      ParticipantCurrencyModel.hubAccountExists.withArgs(currency, 4).resolves(true)
+      const result = await Service.validateHubAccounts(currency)
+      assert.equal(result, true, 'return true')
+      assert.end()
+    } catch (err) {
+      Logger.error(`validateHubAccounts failed with error - ${err}`)
+      assert.fail()
+      assert.end()
+    }
+  })
+
+  await participantTest.test('validateHubAccounts should throw error when hub reconciliation account does not exist', async (assert) => {
+    try {
+      const currency = 'USD'
+      ParticipantCurrencyModel.hubAccountExists.withArgs(currency, 3).resolves(false)
+      ParticipantCurrencyModel.hubAccountExists.withArgs(currency, 4).resolves(true)
+      await Service.validateHubAccounts(currency)
+      assert.fail('should throw')
+      assert.end()
+    } catch (err) {
+      Logger.error(`validateHubAccounts failed with error - ${err}`)
+      assert.equal(err.message, 'Hub reconciliation account for the specified currency does not exist', 'throws Hub reconciliation account for the specified currency does not exist')
+      assert.end()
+    }
+  })
+
+  await participantTest.test('validateHubAccounts should throw error when hub settlement account does not exist', async (assert) => {
+    try {
+      const currency = 'USD'
+      ParticipantCurrencyModel.hubAccountExists.withArgs(currency, 3).resolves(true)
+      ParticipantCurrencyModel.hubAccountExists.withArgs(currency, 4).resolves(false)
+      await Service.validateHubAccounts(currency)
+      assert.fail('should throw')
+      assert.end()
+    } catch (err) {
+      Logger.error(`validateHubAccounts failed with error - ${err}`)
+      assert.equal(err.message, 'Hub multilateral net settlement account for the specified currency does not exist', 'throws Hub multilateral net settlement account for the specified currency does not exist')
+      assert.end()
+    }
+  })
+
+  await participantTest.test('createAssociatedParticipantAccounts should create ParticipantPositionRecords records', async (assert) => {
+    try {
+      const currency = 'AUD'
+      const ledgerAccountTypeId = 127
+      const existingParticipantWithCurrencies = [
+        {
+          participantCurrencyId: 2,
+          participantId: '2',
+          currencyId: 'USD'
+        }
+      ]
+
+      ParticipantFacade.getAllNonHubParticipantsWithCurrencies.resolves(existingParticipantWithCurrencies)
+
+      ParticipantCurrencyModel.getByParticipantId.resolves(['EUR', 'USD'])
+      ParticipantCurrencyModel.create.resolves(1)
+      ParticipantModelCached.getById.withArgs('1').resolves(participantResult[1])
+      ParticipantModelCached.getById.withArgs('2').resolves(participantResult[0])
+      ParticipantPositionModel.createParticipantPositionRecords.resolves(true)
+      await Service.createAssociatedParticipantAccounts(currency, ledgerAccountTypeId)
+      assert.equal(ParticipantFacade.getAllNonHubParticipantsWithCurrencies.callCount, 1, 'should retrieve non HUB Participants with currencies')
+      assert.deepEqual(ParticipantCurrencyModel.create.callCount, 1, 'should call the create partipant currency record function')
+      assert.equal(ParticipantCurrencyModel.create.lastCall.args[1], 'AUD', 'should call the create partipant currency records function with currency AUD')
+      assert.equal(ParticipantCurrencyModel.create.lastCall.args[2], 127, 'should call the create partipant currency records function with ledgerAccountTypeId')
+
+      assert.equal(ParticipantPositionModel.createParticipantPositionRecords.callCount, 1, 'should call the model create function')
+      const expectedParticipantPositionArg = [
+        { participantCurrencyId: 1, value: 0, reservedValue: 0 }
+      ]
+      assert.deepEqual(ParticipantPositionModel.createParticipantPositionRecords.lastCall.args[0], expectedParticipantPositionArg, 'should call the create partipant position records function with the right arguments')
+
+      assert.end()
+    } catch (err) {
+      console.log(err)
+      assert.fail(err instanceof Error, ` throws ${err} `)
+      assert.end()
+    }
+  })
+
+  await participantTest.test('createAssociatedParticipantAccounts should throw an error if the LedgerAccountTypeModel service fails', async (assert) => {
+    try {
+      ParticipantFacade.getAllNonHubParticipantsWithCurrencies.rejects(new Error('Error message'))
+      const ledgerAccountTypeId = 127
+      const currency = 'AUD'
+
+      await Service.createAssociatedParticipantAccounts(currency, ledgerAccountTypeId)
+      assert.fail('Error not thrown', 'should have thrown an error')
+      assert.end()
+    } catch (err) {
+      assert.assert(err instanceof Error, 'should throw an error')
+      assert.ok(err.message, 'Error message', 'should throw the right error message')
+      assert.end()
+    }
+  })
+
   await participantTest.end()
 })

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

@@ -33,6 +33,7 @@ const LedgerAccountTypeModel = require('../../../../src/models/ledgerAccountType
 const Logger = require('@mojaloop/central-services-logger')
 
 const SettlementService = require('../../../../src/domain/settlement/index')
+const ParticipantService = require('../../../../src/domain/participant')
 
 Test('SettlementModel SettlementService', async (settlementModelTest) => {
   let sandbox
@@ -40,6 +41,8 @@ Test('SettlementModel SettlementService', async (settlementModelTest) => {
   settlementModelTest.beforeEach(t => {
     sandbox = Sinon.createSandbox()
     sandbox.stub(LedgerAccountTypeModel, 'getLedgerAccountByName')
+    sandbox.stub(ParticipantService, 'createAssociatedParticipantAccounts')
+    sandbox.stub(ParticipantService, 'validateHubAccounts')
 
     Db.settlementModel = {
       insert: sandbox.stub(),
@@ -71,15 +74,204 @@ Test('SettlementModel SettlementService', async (settlementModelTest) => {
     }
   ]
 
-  await settlementModelTest.test('create settlement model', async (assert) => {
+  //
+  await settlementModelTest.test('create should fail if ledger account type does not exists', async function (test) {
     try {
+      const payload = {
+        name: 'DEFERRED_NET',
+        settlementGranularity: 'NET',
+        settlementInterchange: 'MULTILATERAL',
+        settlementDelay: 'DEFERRED',
+        settlementCurrency: 'USD',
+        requireLiquidityCheck: true,
+        type: 'POSITION',
+        autoPositionReset: true
+      }
       sandbox.stub(SettlementModel, 'create')
-      const expected = await SettlementService.createSettlementModel('IMMEDIATE_GROSS', true, 1, 1, 1, 'USD', true, 'POSITION', true)
-      assert.equal(expected, true)
-      assert.end()
+      ParticipantService.validateHubAccounts.resolves(true)
+
+      await SettlementService.createSettlementModel(payload, {})
+      test.fail('should have thrown an error')
+      test.end()
     } catch (err) {
-      assert.assert(err instanceof Error, ` throws ${err} `)
-      assert.end()
+      console.log(err)
+      test.ok(err instanceof Error, 'should throw an error')
+      test.equal(err.message, 'Ledger account type was not found', 'throws Ledger account type was not found')
+      test.end()
+    }
+  })
+  await settlementModelTest.test('create should fail if settlement account type does not exists', async function (test) {
+    try {
+      const payload = {
+        name: 'DEFERRED_NET',
+        settlementGranularity: 'NET',
+        settlementInterchange: 'MULTILATERAL',
+        settlementDelay: 'DEFERRED',
+        settlementCurrency: 'USD',
+        requireLiquidityCheck: true,
+        type: 'POSITION',
+        autoPositionReset: true,
+        ledgerAccountType: 'SETTLEMENT',
+        settlementAccountType: 'POSITION'
+      }
+      sandbox.stub(SettlementModel, 'create')
+      LedgerAccountTypeModel.getLedgerAccountByName.resolves(true)
+      LedgerAccountTypeModel.getLedgerAccountByName.withArgs(payload.settlementAccountType).returns(Promise.resolve(false))
+
+      await SettlementService.createSettlementModel(payload, {})
+      test.fail('should have thrown an error')
+      test.end()
+    } catch (err) {
+      test.ok(err instanceof Error, 'should throw an error')
+      test.equal(err.message, 'Settlement account type was not found', 'throws Settlement account type was not found')
+      test.end()
+    }
+  })
+
+  await settlementModelTest.test('create should fail if definition is not supported', async function (test) {
+    try {
+      const payload = {
+        name: 'DEFERRED_NET',
+        settlementGranularity: 'GROSS',
+        settlementInterchange: 'MULTILATERAL',
+        settlementDelay: 'DEFERRED',
+        settlementCurrency: 'USD',
+        requireLiquidityCheck: true,
+        type: 'POSITION',
+        autoPositionReset: true
+      }
+      sandbox.stub(SettlementModel, 'create')
+      LedgerAccountTypeModel.getLedgerAccountByName.resolves(false)
+
+      await SettlementService.createSettlementModel(payload, {})
+      test.fail('should have thrown an error')
+      test.end()
+    } catch (err) {
+      test.ok(err instanceof Error, 'should throw an error')
+      test.equal(err.message, 'Invalid settlement model definition - delay-granularity-interchange combination is not supported', 'throws definition not supported error')
+      test.end()
+    }
+  })
+
+  await settlementModelTest.test('create should not create a settlementModel if it already exists', async function (test) {
+    try {
+      const payload = {
+        name: 'DEFERRED_NET',
+        settlementGranularity: 'NET',
+        settlementInterchange: 'MULTILATERAL',
+        settlementDelay: 'DEFERRED',
+        settlementCurrency: 'USD',
+        requireLiquidityCheck: true,
+        type: 'POSITION',
+        autoPositionReset: true,
+        ledgerAccountType: 'SETTLEMENT',
+        settlementAccountType: 'POSITION'
+      }
+      sandbox.stub(SettlementModel, 'create')
+      LedgerAccountTypeModel.getLedgerAccountByName.resolves({ ledgerAccountTypeId: 1 })
+      LedgerAccountTypeModel.getLedgerAccountByName.resolves({ ledgerAccountTypeId: 2 })
+      sandbox.stub(SettlementModel, 'getByName').returns(true)
+
+      const expected = await SettlementService.createSettlementModel(payload, {})
+      test.equal(expected, true, 'should return true')
+      test.end()
+    } catch (err) {
+      test.ok(err instanceof Error, 'should throw an error')
+      test.equal(err.message, 'Settlement Model already exists', 'throws Settlement Model already exists')
+      test.end()
+    }
+  })
+
+  await settlementModelTest.test('create should create a settlementModel if it does not exists', async function (test) {
+    try {
+      const payload = {
+        name: 'DEFERRED_NET',
+        settlementGranularity: 'NET',
+        settlementInterchange: 'MULTILATERAL',
+        settlementDelay: 'DEFERRED',
+        settlementCurrency: 'USD',
+        requireLiquidityCheck: true,
+        type: 'POSITION',
+        autoPositionReset: true,
+        ledgerAccountType: 'SETTLEMENT',
+        settlementAccountType: 'POSITION'
+      }
+      const existingModels = [{
+        name: 'DEFERRED_NET_EXISTING',
+        settlementGranularity: 'NET',
+        settlementInterchange: 'MULTILATERAL',
+        settlementDelay: 'DEFERRED',
+        settlementCurrency: 'USD',
+        requireLiquidityCheck: true,
+        type: 'POSITION',
+        autoPositionReset: true,
+        ledgerAccountType: 'SETTLEMENT',
+        settlementAccountType: 'POSITION'
+      }]
+      sandbox.stub(SettlementModel, 'create')
+      LedgerAccountTypeModel.getLedgerAccountByName.resolves({ ledgerAccountTypeId: 1 })
+      LedgerAccountTypeModel.getLedgerAccountByName.resolves({ ledgerAccountTypeId: 2 })
+      sandbox.stub(SettlementModel, 'getAll').returns(existingModels)
+      sandbox.stub(SettlementModel, 'getByName').returns(null)
+
+      await ParticipantService.createAssociatedParticipantAccounts.resolves(true)
+      await ParticipantService.createAssociatedParticipantAccounts.resolves(true)
+
+      const expected = await SettlementService.createSettlementModel(payload, {})
+      test.equal(expected, true, 'should return true')
+      test.end()
+    } catch (err) {
+      test.ok(err instanceof Error, 'should throw an error')
+      test.equal(err.message, 'Settlement account type was not found', 'throws Settlement account type was not found')
+      test.end()
+    }
+  })
+
+  await settlementModelTest.test('create should create a settlementModel with currency if it does not exists', async function (test) {
+    try {
+      const payload = {
+        name: 'DEFERRED_NET',
+        settlementGranularity: 'NET',
+        settlementInterchange: 'MULTILATERAL',
+        settlementDelay: 'DEFERRED',
+        settlementCurrency: 'USD',
+        requireLiquidityCheck: true,
+        type: 'POSITION',
+        autoPositionReset: true,
+        ledgerAccountType: 'SETTLEMENT',
+        settlementAccountType: 'POSITION',
+        currency: 'USD'
+      }
+      const existingModels = [{
+        name: 'DEFERRED_NET_EXISTING',
+        settlementGranularity: 'NET',
+        settlementInterchange: 'MULTILATERAL',
+        settlementDelay: 'DEFERRED',
+        settlementCurrency: 'USD',
+        requireLiquidityCheck: true,
+        type: 'POSITION',
+        autoPositionReset: true,
+        ledgerAccountType: 'SETTLEMENT',
+        settlementAccountType: 'POSITION'
+      }]
+      sandbox.stub(SettlementModel, 'create')
+      ParticipantService.validateHubAccounts.resolves(true)
+
+      LedgerAccountTypeModel.getLedgerAccountByName.resolves({ ledgerAccountTypeId: 1 })
+      LedgerAccountTypeModel.getLedgerAccountByName.resolves({ ledgerAccountTypeId: 2 })
+      sandbox.stub(SettlementModel, 'getAll').returns(existingModels)
+      sandbox.stub(SettlementModel, 'getByName').returns(null)
+
+      await ParticipantService.createAssociatedParticipantAccounts.resolves(true)
+      await ParticipantService.createAssociatedParticipantAccounts.resolves(true)
+
+      const expected = await SettlementService.createSettlementModel(payload, {})
+      test.equal(expected, true, 'should return true')
+      test.end()
+    } catch (err) {
+      test.ok(err instanceof Error, 'should throw an error')
+      test.equal(err.message, 'Settlement account type was not found', 'throws Settlement account type was not found')
+      test.end()
     }
   })
 
@@ -94,6 +286,7 @@ Test('SettlementModel SettlementService', async (settlementModelTest) => {
       assert.end()
     }
   })
+
   await settlementModelTest.test('getLedgerAccountType by name name should return ledgerAccountType', async (assert) => {
     const name = {
       currency: 'AFA',
@@ -141,29 +334,6 @@ Test('SettlementModel SettlementService', async (settlementModelTest) => {
       assert.end()
     }
   })
-  await settlementModelTest.test('get settlement model by name', async (assert) => {
-    try {
-      sandbox.stub(SettlementModel, 'getByName').returns(settlementModel)
-      const expected = await SettlementService.getByName('test')
-      assert.equal(expected, settlementModel)
-      assert.end()
-    } catch (err) {
-      assert.assert(err instanceof Error, ` throws ${err} `)
-      assert.end()
-    }
-  })
-
-  await settlementModelTest.test('get settlement model by name should throw an error', async (assert) => {
-    try {
-      sandbox.stub(SettlementModel, 'getByName').throws(new Error())
-      await SettlementService.getByName('test')
-      assert.fail('Error not thrown')
-      assert.end()
-    } catch (err) {
-      assert.ok(err instanceof Error)
-      assert.end()
-    }
-  })
 
   await settlementModelTest.test('getAll', async (assert) => {
     try {