account-lookup-service 17.7.0 → 17.8.0-snapshot.6

package/test/unit/domain/parties/parties.test.js

@@ -56,7 +56,7 @@ const fixtures = require('../../../fixtures')
 const { type: proxyCacheType, proxyConfig: proxyCacheConfig } = Config.PROXY_CACHE_CONFIG
 
 const { encodePayload } = Util.StreamingProtocol
-const { RestMethods } = Enum.Http
+const { RestMethods, Headers } = Enum.Http
 
 Logger.isDebugEnabled = jest.fn(() => true)
 Logger.isErrorEnabled = jest.fn(() => true)
@@ -192,24 +192,26 @@ describe('Parties Tests', () => {
       expect(cached).toBe(proxy)
     })
 
-    it('should send error callback if destination is not in the scheme, and not in proxyCache', async () => {
+    it('should cleanup oracle and trigger discovery flow, if destination is not in scheme and no dfsp-to-proxy mapping', async () => {
+      Config.PROXY_CACHE_CONFIG.enabled = true
       participant.validateParticipant = sandbox.stub()
         .onFirstCall().resolves({}) // source
         .onSecondCall().resolves(null) // destination
       participant.sendRequest = sandbox.stub().resolves()
       participant.sendErrorToParticipant = sandbox.stub().resolves()
       sandbox.stub(oracle, 'oracleRequest')
+      const proxy = 'some-proxy'
+      Util.proxies.getAllProxiesNames = sandbox.stub().resolves([proxy])
       const headers = fixtures.partiesCallHeadersDto()
 
       await partiesDomain.getPartiesByTypeAndID(headers, Helper.getByTypeIdRequest.params, Helper.getByTypeIdRequest.method, Helper.getByTypeIdRequest.query, Helper.mockSpan(), null, proxyCache)
 
-      expect(participant.sendRequest.callCount).toBe(0)
-      expect(oracle.oracleRequest.callCount).toBe(0)
-      expect(participant.sendErrorToParticipant.callCount).toBe(1)
-
-      const { errorInformation } = participant.sendErrorToParticipant.getCall(0).args[2]
-      expect(errorInformation.errorCode).toBe('3200')
-      expect(errorInformation.errorDescription).toContain(ERROR_MESSAGES.partyDestinationFspNotFound)
+      expect(oracle.oracleRequest.lastCall.args[1]).toBe(RestMethods.DELETE)
+      expect(participant.sendErrorToParticipant.callCount).toBe(0)
+      expect(participant.sendRequest.callCount).toBe(1)
+      // eslint-disable-next-line no-unused-vars
+      const [_, sendTo] = participant.sendRequest.lastCall.args
+      expect(sendTo).toBe(proxy)
     })
 
     it('should send request to proxy, if destination is not in the scheme, but has proxyMapping', async () => {
@@ -470,7 +472,7 @@ describe('Parties Tests', () => {
       expect(firstCallArgs[2]).toBe(expectedCallbackEnpointType)
     })
 
-    it('should send request to proxy if oracle returns dfsp NOT from the scheme', async () => {
+    it('should send errorCallback if oracle returns external dfsp, and source is external', async () => {
       Config.PROXY_CACHE_CONFIG.enabled = true
       const proxyName = `proxy-${Date.now()}`
       const fspId = `dfspNotFromScheme-${Date.now()}`
@@ -479,7 +481,7 @@ describe('Parties Tests', () => {
       })
       sandbox.stub(oracle, 'oracleRequest').resolves(oracleResponse)
       participant.validateParticipant = sandbox.stub()
-        .onFirstCall().resolves({}) // source
+        .onFirstCall().resolves(null) // source
         .onSecondCall().resolves(null) // oracle dfsp
       participant.sendRequest = sandbox.stub().resolves()
       participant.sendErrorToParticipant = sandbox.stub().resolves()
@@ -487,15 +489,20 @@ describe('Parties Tests', () => {
       const isAdded = await proxyCache.addDfspIdToProxyMapping(fspId, proxyName)
       expect(isAdded).toBe(true)
 
-      const headers = fixtures.partiesCallHeadersDto({ destination: '' })
+      const source = `fromDfsp-${Date.now()}`
+      const headers = fixtures.partiesCallHeadersDto({ destination: '', source, proxy: 'proxy' })
       const { params, method, query } = Helper.getByTypeIdRequest
 
       await partiesDomain.getPartiesByTypeAndID(headers, params, method, query, null, null, proxyCache)
 
-      expect(participant.sendErrorToParticipant.callCount).toBe(0)
-      expect(participant.sendRequest.callCount).toBe(1)
-      const calledProxy = participant.sendRequest.getCall(0).args[1]
-      expect(calledProxy).toBe(proxyName)
+      expect(participant.sendRequest.callCount).toBe(0)
+      expect(participant.sendErrorToParticipant.callCount).toBe(1)
+      // eslint-disable-next-line no-unused-vars
+      const [sentTo, _, payload, sentHeaders] = participant.sendErrorToParticipant.lastCall.args
+      expect(sentTo).toBe(source)
+      expect(payload.errorInformation.errorCode).toBe('3200')
+      expect(sentHeaders[Headers.FSPIOP.SOURCE]).toBe(Config.HUB_NAME)
+      expect(sentHeaders[Headers.FSPIOP.DESTINATION]).toBe(headers[Headers.FSPIOP.SOURCE])
     })
 
     it('handles error when `oracleRequest` returns no result', async () => {
@@ -554,13 +561,14 @@ describe('Parties Tests', () => {
       participant.sendRequest = sandbox.stub().rejects(new Error('Some network issue'))
       participant.sendErrorToParticipant = sandbox.stub().resolves()
       const headers = fixtures.partiesCallHeadersDto({ destination: '' })
+      const params = fixtures.partiesParamsDto()
 
-      await partiesDomain.getPartiesByTypeAndID(headers, Helper.getByTypeIdRequest.params, Helper.getByTypeIdRequest.method, Helper.getByTypeIdRequest.query, Helper.mockSpan(), null, proxyCache)
+      await partiesDomain.getPartiesByTypeAndID(headers, params, Helper.getByTypeIdRequest.method, Helper.getByTypeIdRequest.query, Helper.mockSpan(), null, proxyCache)
 
       expect(participant.sendRequest.callCount).toBe(proxyNames.length)
       expect(participant.sendErrorToParticipant.callCount).toBe(1)
 
-      const { errorInformation } = participant.sendErrorToParticipant.getCall(0).args[2]
+      const { errorInformation } = participant.sendErrorToParticipant.lastCall.args[2]
       expect(errorInformation.errorCode).toBe('3200')
       expect(errorInformation.errorDescription).toContain(ERROR_MESSAGES.proxyConnectionError)
     })

package/test/unit/domain/parties/partiesUtils.test.js

@@ -0,0 +1,51 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop 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
+ Mojaloop 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>.
+ * Mojaloop Foundation
+ - Name Surname <name.surname@mojaloop.io>
+
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+ --------------
+ **********/
+
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const partiesUtils = require('#src/domain/parties/partiesUtils')
+const config = require('#src/lib/config')
+const { API_TYPES } = require('#src/constants')
+const fixtures = require('#test/fixtures/index')
+
+describe('partiesUtils Tests -->', () => {
+  describe('makePutPartiesErrorPayload Tests', () => {
+    const error = ErrorHandler.Factory.reformatFSPIOPError(new Error('Test Error'))
+    const ERR_CODE = '2001'
+    const headers = fixtures.partiesCallHeadersDto()
+    const params = fixtures.partiesParamsDto()
+
+    test('should make putParties error payload in FSPIOP format', async () => {
+      const fspiopConfig = { ...config, API_TYPE: API_TYPES.fspiop }
+      const payload = await partiesUtils.makePutPartiesErrorPayload(fspiopConfig, error, headers, params)
+      expect(payload.errorInformation.errorCode).toBe(ERR_CODE)
+    })
+
+    test('should make putParties error payload in ISO20022 format', async () => {
+      const fspiopConfig = { ...config, API_TYPE: API_TYPES.iso20022 }
+      const payload = await partiesUtils.makePutPartiesErrorPayload(fspiopConfig, error, headers, params)
+      expect(payload.Rpt.Rsn.Cd).toBe(ERR_CODE)
+    })
+  })
+})

package/test/unit/domain/parties/services/BasePartiesService.test.js

@@ -0,0 +1,71 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop 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
+ Mojaloop Foundation 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>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const { createMockDeps, participantMock } = require('./deps')
+// ↑ should be first require to mock external deps ↑
+const BasePartiesService = require('#src/domain/parties/services/BasePartiesService')
+const config = require('#src/lib/config')
+const { API_TYPES } = require('#src/constants')
+const fixtures = require('#test/fixtures/index')
+
+describe('BasePartiesService Tests -->', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should send error party callback in ISO20022 format', async () => {
+    const deps = {
+      ...createMockDeps(),
+      config: { ...config, API_TYPE: API_TYPES.iso20022 }
+    }
+    const source = 'sourceFsp'
+    const headers = fixtures.partiesCallHeadersDto({ source })
+    const params = fixtures.partiesParamsDto()
+    const service = new BasePartiesService(deps, { headers, params })
+
+    await service.handleError(new Error('test error'))
+    expect(participantMock.sendErrorToParticipant.mock.calls.length).toBe(1)
+    // eslint-disable-next-line no-unused-vars
+    const [sentTo, _, payload] = participantMock.sendErrorToParticipant.mock.lastCall
+    expect(sentTo).toBe(source)
+    expect(payload.Rpt.Rsn.Cd).toBe('2001')
+    expect(payload.Rpt.OrgnlId).toBe(`${params.Type}/${params.ID}`)
+    expect(payload.Assgnmt.Assgnr.Agt.FinInstnId.Othr.Id).toBe(source)
+  })
+
+  test('should remove proxy getParties timeout cache key', async () => {
+    const deps = createMockDeps()
+    const proxy = 'proxyAB'
+    const headers = fixtures.partiesCallHeadersDto({ proxy })
+    const params = fixtures.partiesParamsDto()
+    const alsReq = {}
+    const service = new BasePartiesService(deps, { headers, params })
+
+    await service.removeProxyGetPartiesTimeoutCache(alsReq)
+    expect(deps.proxyCache.removeProxyGetPartiesTimeout).toHaveBeenCalledWith(alsReq, proxy)
+  })
+})

package/test/unit/domain/parties/services/GetPartiesService.test.js

@@ -0,0 +1,224 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop 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
+ Mojaloop Foundation 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>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const { createMockDeps, createProxyCacheMock, oracleMock, participantMock } = require('./deps')
+// ↑ should be first require to mock external deps ↑
+const { GetPartiesService } = require('#src/domain/parties/services/index')
+const fixtures = require('#test/fixtures/index')
+
+const { RestMethods, Headers } = GetPartiesService.enums()
+
+describe('GetPartiesService Tests -->', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe('forwardRequestToDestination method', () => {
+    test('should delete party info from oracle, if no destination DFSP in proxy mapping', async () => {
+      participantMock.validateParticipant = jest.fn().mockResolvedValueOnce(null)
+      const proxyCache = createProxyCacheMock({
+        lookupProxyByDfspId: jest.fn().mockResolvedValueOnce(null)
+      })
+      const deps = createMockDeps({ proxyCache })
+
+      const destination = 'dfsp'
+      const headers = fixtures.partiesCallHeadersDto({ destination, proxy: 'proxy' })
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+      service.triggerInterSchemeDiscoveryFlow = jest.fn()
+
+      await service.forwardRequestToDestination()
+
+      expect(oracleMock.oracleRequest.mock.calls.length).toBe(1)
+      const [sentHeaders, method, sentParams] = oracleMock.oracleRequest.mock.lastCall
+      expect(method).toBe(RestMethods.DELETE)
+      expect(sentHeaders).toEqual(headers)
+      expect(sentParams).toEqual(params)
+
+      expect(service.triggerInterSchemeDiscoveryFlow.mock.calls.length).toBe(1)
+      expect(service.triggerInterSchemeDiscoveryFlow.mock.lastCall[0]).toEqual({
+        ...headers,
+        [Headers.FSPIOP.DESTINATION]: undefined
+      })
+    })
+  })
+
+  describe('processOraclePartyList for external participants', () => {
+    const EXTERNAL_DFSP_ID = 'externalFsp'
+    const PROXY_ID = 'externalProxy'
+    let deps
+    let proxyCache
+
+    beforeEach(async () => {
+      oracleMock.oracleRequest = jest.fn().mockResolvedValueOnce(
+        fixtures.oracleRequestResponseDto({ partyList: [{ fspId: EXTERNAL_DFSP_ID }] })
+      )
+      participantMock.validateParticipant = jest.fn()
+        .mockResolvedValueOnce(null) // source
+        .mockResolvedValueOnce({}) // proxy
+
+      proxyCache = createProxyCacheMock({
+        addDfspIdToProxyMapping: jest.fn().mockResolvedValueOnce(true),
+        lookupProxyByDfspId: jest.fn().mockResolvedValueOnce(PROXY_ID)
+      })
+      deps = createMockDeps({ proxyCache })
+    })
+
+    test('should cleanup oracle and trigger interScheme discovery, if no proxyMapping for external dfsp', async () => {
+      proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValueOnce(null)
+      const headers = fixtures.partiesCallHeadersDto({
+        destination: '', proxy: 'proxyA'
+      })
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+      service.triggerInterSchemeDiscoveryFlow = jest.fn()
+
+      await service.handleRequest()
+      expect(oracleMock.oracleRequest).toHaveBeenCalledTimes(2) // GET + DELETE
+      expect(oracleMock.oracleRequest.mock.lastCall[1]).toBe(RestMethods.DELETE)
+      expect(service.triggerInterSchemeDiscoveryFlow).toHaveBeenCalledWith(headers)
+    })
+
+    test('should trigger interScheme discovery flow, if source is external', async () => {
+      const headers = fixtures.partiesCallHeadersDto({
+        destination: '', proxy: 'proxyA'
+      })
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+      service.triggerInterSchemeDiscoveryFlow = jest.fn()
+
+      await service.handleRequest()
+      expect(service.triggerInterSchemeDiscoveryFlow).toHaveBeenCalledWith(headers)
+    })
+
+    test('should forward request, if source is in scheme (no proxy header)', async () => {
+      participantMock.validateParticipant = jest.fn(async (fsp) => (fsp === EXTERNAL_DFSP_ID ? null : {}))
+      const headers = fixtures.partiesCallHeadersDto({
+        destination: '', proxy: ''
+      })
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+
+      await service.handleRequest()
+      expect(participantMock.sendRequest.mock.calls.length).toBe(1)
+      const [sentHeaders, sendTo] = participantMock.sendRequest.mock.lastCall
+      expect(sendTo).toEqual(PROXY_ID)
+      expect(sentHeaders[Headers.FSPIOP.DESTINATION]).toBe(EXTERNAL_DFSP_ID)
+    })
+
+    test('should trigger inter-scheme discovery flow, if source is NOT in scheme', async () => {
+      const source = 'test-zm-dfsp'
+      const proxyZm = 'proxy-zm'
+      participantMock.validateParticipant = jest.fn(
+        async (fsp) => ([EXTERNAL_DFSP_ID, source].includes(fsp) ? null : {})
+      )
+      deps.proxies.getAllProxiesNames = jest.fn().mockResolvedValueOnce([PROXY_ID, proxyZm])
+      const headers = fixtures.partiesCallHeadersDto({
+        source, destination: '', proxy: proxyZm
+      })
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+
+      await service.handleRequest()
+      expect(participantMock.sendRequest).toHaveBeenCalledTimes(1)
+      const [sentHeaders, sendTo] = participantMock.sendRequest.mock.lastCall
+      expect(sendTo).toEqual(PROXY_ID)
+      expect(sentHeaders[Headers.FSPIOP.DESTINATION]).toBeUndefined()
+    })
+  })
+
+  describe('setProxyGetPartiesTimeout Tests', () => {
+    test('should set getParties timeout for local source and external destination', async () => {
+      participantMock.validateParticipant = jest.fn()
+        .mockResolvedValueOnce({}) // source
+        .mockResolvedValueOnce(null) // destination
+      const proxyId = 'proxy-destination'
+      const proxyCache = createProxyCacheMock({
+        lookupProxyByDfspId: jest.fn().mockResolvedValueOnce(proxyId)
+      })
+      const deps = createMockDeps({ proxyCache })
+      const headers = fixtures.partiesCallHeadersDto()
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+
+      await service.handleRequest()
+      expect(proxyCache.setProxyGetPartiesTimeout).toHaveBeenCalledTimes(1)
+      expect(proxyCache.setProxyGetPartiesTimeout.mock.lastCall[1]).toBe(proxyId)
+      expect(participantMock.sendRequest).toHaveBeenCalledTimes(1)
+    })
+
+    test('should NOT set getParties timeout if source is external', async () => {
+      participantMock.validateParticipant = jest.fn()
+        .mockResolvedValueOnce(null) // source
+        .mockResolvedValueOnce({}) // proxy-src
+      const proxyCache = createProxyCacheMock({
+        lookupProxyByDfspId: jest.fn().mockResolvedValue('proxy-desc')
+      })
+      const deps = createMockDeps({ proxyCache })
+      const headers = fixtures.partiesCallHeadersDto({ proxy: 'proxy-src' })
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+
+      await service.handleRequest()
+      expect(proxyCache.setProxyGetPartiesTimeout).not.toHaveBeenCalled()
+      expect(participantMock.sendRequest).toHaveBeenCalledTimes(1)
+    })
+
+    test('should NOT set getParties timeout if destination is local', async () => {
+      participantMock.validateParticipant = jest.fn().mockResolvedValue({})
+      const proxyCache = createProxyCacheMock()
+      const deps = createMockDeps({ proxyCache })
+      const headers = fixtures.partiesCallHeadersDto()
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+
+      await service.handleRequest()
+      expect(proxyCache.setProxyGetPartiesTimeout).not.toHaveBeenCalled()
+      expect(participantMock.sendRequest).toHaveBeenCalledTimes(1)
+    })
+
+    test('should set getParties timeout if oracle returns external participant', async () => {
+      participantMock.validateParticipant = jest.fn()
+        .mockResolvedValueOnce({}) // source
+        .mockResolvedValueOnce(null) // externalDfsp
+      oracleMock.oracleRequest = jest.fn(async () => fixtures.oracleRequestResponseDto({
+        partyList: [{ fspId: 'externalDfsp' }]
+      }))
+      const proxyCache = createProxyCacheMock({
+        lookupProxyByDfspId: jest.fn().mockResolvedValue('proxyExternal')
+      })
+      const deps = createMockDeps({ proxyCache })
+      const headers = fixtures.partiesCallHeadersDto({ destination: '' })
+      const params = fixtures.partiesParamsDto()
+      const service = new GetPartiesService(deps, { headers, params })
+
+      await service.handleRequest()
+      expect(proxyCache.setProxyGetPartiesTimeout).toHaveBeenCalledTimes(1)
+      expect(participantMock.sendRequest).toHaveBeenCalledTimes(1)
+    })
+  })
+})

package/test/unit/domain/parties/services/PutPartiesErrorService.test.js

@@ -0,0 +1,50 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop 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
+ Mojaloop Foundation 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>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const { createMockDeps, oracleMock } = require('./deps')
+// ↑ should be first require to mock external deps ↑
+const { PutPartiesErrorService } = require('#src/domain/parties/services/index')
+const fixtures = require('#test/fixtures/index')
+
+const { RestMethods } = PutPartiesErrorService.enums()
+
+describe('PutPartiesErrorService Tests -->', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should cleanup oracle and trigger discovery flow for party from external dfsp', async () => {
+    const headers = fixtures.partiesCallHeadersDto({ proxy: 'proxyA' })
+    const params = fixtures.partiesParamsDto()
+    const service = new PutPartiesErrorService(createMockDeps(), { headers, params })
+
+    const needDiscovery = await service.handleRequest()
+    expect(needDiscovery).toBe(true)
+    expect(oracleMock.oracleRequest.mock.calls.length).toBe(1)
+    expect(oracleMock.oracleRequest.mock.lastCall[1]).toBe(RestMethods.DELETE)
+  })
+})

package/test/unit/domain/parties/services/TimeoutPartiesService.test.js

@@ -0,0 +1,72 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop 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
+ Mojaloop Foundation 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>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+const { createMockDeps, createProxyCacheMock, participantMock } = require('./deps')
+// ↑ should be first require to mock external deps ↑
+const { TimeoutPartiesService } = require('#src/domain/parties/services/index')
+const { API_TYPES } = require('#src/constants')
+const fixtures = require('#test/fixtures/index')
+
+describe('TimeoutPartiesService Tests -->', () => {
+  const { config } = createMockDeps()
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should send error callback to external participant through proxy', async () => {
+    participantMock.validateParticipant = jest.fn().mockResolvedValue(null)
+    const proxy = 'proxyAB'
+    const proxyCache = createProxyCacheMock({
+      lookupProxyByDfspId: jest.fn().mockResolvedValue(proxy)
+    })
+    const deps = createMockDeps({ proxyCache })
+    const cacheKey = fixtures.expiredCacheKeyDto()
+    const service = TimeoutPartiesService.createInstance(deps, cacheKey, 'test')
+
+    await service.handleExpiredKey()
+    expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+    expect(participantMock.sendErrorToParticipant.mock.lastCall[0]).toBe(proxy)
+  })
+
+  test('should send error callback in ISO20022 format', async () => {
+    participantMock.validateParticipant = jest.fn().mockResolvedValue({})
+    const deps = {
+      ...createMockDeps(),
+      config: { ...config, API_TYPE: API_TYPES.iso20022 }
+    }
+    const sourceId = 'sourceFsp'
+    const cacheKey = fixtures.expiredCacheKeyDto({ sourceId })
+    const service = TimeoutPartiesService.createInstance(deps, cacheKey, 'test')
+
+    await service.handleExpiredKey()
+    expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+    const { Assgnr, Assgne } = participantMock.sendErrorToParticipant.mock.lastCall[2].Assgnmt
+    expect(Assgnr.Agt.FinInstnId.Othr.Id).toBe(config.HUB_NAME)
+    expect(Assgne.Agt.FinInstnId.Othr.Id).toBe(sourceId)
+  })
+})

package/test/unit/domain/parties/services/deps.js

@@ -0,0 +1,49 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop 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
+ Mojaloop Foundation 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>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+
+jest.mock('#src/models/oracle/facade')
+jest.mock('#src/models/participantEndpoint/facade')
+
+const oracleMock = require('#src/models/oracle/facade')
+const participantMock = require('#src/models/participantEndpoint/facade')
+const { createDeps } = require('#src/domain/parties/deps')
+const { logger } = require('#src/lib/index')
+const { createProxyCacheMock } = require('#test/util/mockDeps')
+
+/** @returns {PartiesDeps} */
+const createMockDeps = ({
+  proxyCache = createProxyCacheMock(),
+  log = logger.child({ test: true }),
+  cache
+} = {}) => createDeps({ cache, proxyCache, log })
+
+module.exports = {
+  createMockDeps,
+  createProxyCacheMock,
+  oracleMock,
+  participantMock
+}