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

package/test/integration/domain/timeout/index.test.js

@@ -1,18 +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 { createProxyCache } = require('@mojaloop/inter-scheme-proxy-cache-lib')
-const { PAYER_DFSP, PARTY_ID_TYPE, PROXY_NAME } = require('../../constants')
+const { RedisProxyCache } = require('@mojaloop/inter-scheme-proxy-cache-lib/dist/lib/storages/RedisProxyCache')
+const config = require('#src/lib/config')
 const fixtures = require('../../../fixtures')
 const { ProxyApiClient } = require('../../../util')
-const config = require('../../../../src/lib/config')
+const { PAYER_DFSP, PARTY_ID_TYPE, PROXY_NAME } = require('../../constants')
 
 const wait = (sec) => new Promise(resolve => setTimeout(resolve, sec * 1000))
 
 const CRON_TIMEOUT_SEC = 15 // see TIMEXP
 
+jest.setTimeout(60_000)
+
 describe('Timeout Handler', () => {
   const { type, proxyConfig } = config.PROXY_CACHE_CONFIG
   const proxyCache = createProxyCache(type, proxyConfig)
   const proxyClient = new ProxyApiClient()
 
+  const checkKeysExistence = async (keys) => Promise.all(keys.map(key => proxyCache.redisClient.exists(key)))
+
   beforeAll(async () => {
     await proxyCache.connect()
     const redisClient = proxyCache.redisClient
@@ -22,6 +54,11 @@ describe('Timeout Handler', () => {
     }))
   })
 
+  beforeEach(async () => {
+    const history = await proxyClient.deleteHistory()
+    expect(history).toEqual([])
+  })
+
   afterAll(async () => {
     return Promise.all([
       proxyClient.deleteHistory(),
@@ -29,47 +66,65 @@ describe('Timeout Handler', () => {
     ])
   })
 
-  it('test', async () => {
-    let history = await proxyClient.deleteHistory()
-    expect(history).toEqual([])
-
-    // send a couple of keys to redis
-    const partyIds = ['1234567', '7654321']
-    const keys = [
-      `'als:${PAYER_DFSP}:${PARTY_ID_TYPE}:${partyIds[0]}:expiresAt'`,
-      `'als:${PAYER_DFSP}:${PARTY_ID_TYPE}:${partyIds[1]}:expiresAt'`
-    ]
+  it('should pass timeoutInterschemePartiesLookups flow', async () => {
+    const partyIds = [`isp1-${Date.now()}`, `isp2-${Date.now()}`]
     const proxies = [PROXY_NAME]
     const alsReq1 = fixtures.mockAlsRequestDto(PAYER_DFSP, PARTY_ID_TYPE, partyIds[0])
     const alsReq2 = fixtures.mockAlsRequestDto(PAYER_DFSP, PARTY_ID_TYPE, partyIds[1])
+    const keys = [
+      RedisProxyCache.formatAlsCacheExpiryKey(alsReq1),
+      RedisProxyCache.formatAlsCacheExpiryKey(alsReq2)
+    ]
+    // send a couple of keys to redis
     const results = await Promise.all([
       proxyCache.setSendToProxiesList(alsReq1, proxies, CRON_TIMEOUT_SEC),
       proxyCache.setSendToProxiesList(alsReq2, proxies, CRON_TIMEOUT_SEC)
     ])
-    expect(results.includes(false)).toBe(false)
+    expect(results).toEqual([true, true])
+    expect(await checkKeysExistence(keys)).toEqual([1, 1])
 
     // wait for the timeout handler to process the keys
     await wait(CRON_TIMEOUT_SEC * 1.5)
+    const history = await proxyClient.waitForNHistoryCalls(2)
 
     // check that the keys are no longer in redis
-    const exists = await Promise.all(keys.map(key => proxyCache.redisClient.exists(key)))
-    expect(exists.includes(1)).toBe(false)
-
-    // check that the callbacks are sent and received at the FSP
-    // for test resilience, we will retry the history check a few times
-    const retryMaxCount = 20
-    const retryIntervalSec = 2
-    let retryCount = 0
-
-    while (history.length < 2 && retryCount < retryMaxCount) {
-      await wait(retryIntervalSec)
-      history = await proxyClient.getHistory()
-      retryCount++
-    }
+    expect(await checkKeysExistence(keys)).toEqual([0, 0])
+
     expect(history.length).toBe(2)
     const path0 = history.find(h => h.path.includes(partyIds[0])).path
     const path1 = history.find(h => h.path.includes(partyIds[1])).path
     expect(path0).toBe(`/parties/${PARTY_ID_TYPE}/${partyIds[0]}/error`)
     expect(path1).toBe(`/parties/${PARTY_ID_TYPE}/${partyIds[1]}/error`)
-  }, 60_000)
+  })
+
+  it('should pass timeoutProxyGetPartiesLookups flow', async () => {
+    const partyId1 = `pgp1-${Date.now()}`
+    const partyId2 = `pgp2-${Date.now()}`
+    const alsReq1 = fixtures.mockAlsRequestDto(PAYER_DFSP, PARTY_ID_TYPE, partyId1)
+    const alsReq2 = fixtures.mockAlsRequestDto(PAYER_DFSP, PARTY_ID_TYPE, partyId2)
+    const keys = [
+      RedisProxyCache.formatProxyGetPartiesExpiryKey(alsReq1, PROXY_NAME),
+      RedisProxyCache.formatProxyGetPartiesExpiryKey(alsReq2, PROXY_NAME)
+    ]
+    // send a couple of keys to redis
+    const results = await Promise.all([
+      proxyCache.setProxyGetPartiesTimeout(alsReq1, PROXY_NAME, CRON_TIMEOUT_SEC),
+      proxyCache.setProxyGetPartiesTimeout(alsReq2, PROXY_NAME, CRON_TIMEOUT_SEC)
+    ])
+    expect(results).toEqual([true, true])
+    expect(await checkKeysExistence(keys)).toEqual([1, 1])
+
+    // wait for the timeout handler to process the keys
+    await wait(CRON_TIMEOUT_SEC * 1.5)
+    const history = await proxyClient.waitForNHistoryCalls(2)
+
+    // check that the keys are no longer in redis
+    expect(await checkKeysExistence(keys)).toEqual([0, 0])
+
+    expect(history.length).toBe(2)
+    const path1 = history.find(h => h.path.includes(partyId1)).path
+    const path2 = history.find(h => h.path.includes(partyId2)).path
+    expect(path1).toBe(`/parties/${PARTY_ID_TYPE}/${partyId1}/error`)
+    expect(path2).toBe(`/parties/${PARTY_ID_TYPE}/${partyId2}/error`)
+  })
 })

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).toHaveBeenCalledTimes(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)
+  })
+})