account-lookup-service 17.12.3 → 17.12.5-snapshot.1

package/src/domain/parties/services/BasePartiesService.js

@@ -107,9 +107,13 @@ class BasePartiesService {
     try {
       log.error('error in processing parties request: ', error)
       const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(error)
+
       const callbackHeaders = BasePartiesService.createErrorCallbackHeaders(this.inputs.headers, params)
       const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(this.deps.config, fspiopError, callbackHeaders, params)
 
+      this.state.destination = callbackHeaders[Headers.FSPIOP.DESTINATION]
+      await this.identifyDestinationForCallback()
+
       await this.sendErrorCallback({
         errorInfo,
         headers: callbackHeaders,
@@ -127,7 +131,7 @@ class BasePartiesService {
   async validateParticipant (participantId) {
     try {
       this.stepInProgress('validateParticipant')
-      return this.deps.participant.validateParticipant(participantId)
+      return await this.deps.participant.validateParticipant(participantId)
     } catch (err) {
       this.log.warn(`error in validateParticipant ${participantId}: `, err)
       return null
@@ -157,7 +161,7 @@ class BasePartiesService {
 
   async sendErrorCallback ({ errorInfo, headers, params }) {
     this.stepInProgress('sendErrorCallback')
-    const sendTo = this.state.requester || headers[Headers.FSPIOP.DESTINATION] /* || this.state.source */
+    const sendTo = this.state.requester || headers[Headers.FSPIOP.DESTINATION]
     const endpointType = this.deps.partiesUtils.errorPartyCbType(params.SubId)
 
     await this.deps.participant.sendErrorToParticipant(
@@ -168,7 +172,9 @@ class BasePartiesService {
 
   async sendDeleteOracleRequest (headers, params) {
     this.stepInProgress('sendDeleteOracleRequest')
-    return this.deps.oracle.oracleRequest(headers, RestMethods.DELETE, params, null, null, this.deps.cache)
+    const result = await this.deps.oracle.oracleRequest(headers, RestMethods.DELETE, params, null, null, this.deps.cache)
+    this.log.verbose('sendDeleteOracleRequest is done', { params })
+    return result
   }
 
   async removeProxyGetPartiesTimeoutCache (alsReq) {

package/src/domain/parties/services/PutPartiesErrorService.js

@@ -42,7 +42,7 @@ class PutPartiesErrorService extends BasePartiesService {
         }
       } else {
         const schemeParticipant = await this.validateParticipant(this.state.destination)
-        if (schemeParticipant) {
+        if (!schemeParticipant) {
           this.log.info('Need to cleanup oracle and forward SERVICE_CURRENTLY_UNAVAILABLE error')
           await this.cleanupOracle()
           await this.removeProxyGetPartiesTimeoutCache(alsReq)
@@ -86,6 +86,7 @@ class PutPartiesErrorService extends BasePartiesService {
     const callbackHeaders = BasePartiesService.createErrorCallbackHeaders(headers, params, this.state.destination)
     const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(this.deps.config, error, callbackHeaders, params)
 
+    await this.identifyDestinationForCallback()
     await super.sendErrorCallback({
       errorInfo,
       headers: callbackHeaders,

package/src/lib/config.js

@@ -175,7 +175,8 @@ const config = {
   FEATURE_ENABLE_EXTENDED_PARTY_ID_TYPE: RC.FEATURE_ENABLE_EXTENDED_PARTY_ID_TYPE || false,
   PROTOCOL_VERSIONS: getProtocolVersions(DEFAULT_PROTOCOL_VERSION, RC.PROTOCOL_VERSIONS),
   PROXY_CACHE_CONFIG: RC.PROXY_CACHE,
-  DELETE_PARTICIPANT_VALIDATION_ENABLED: RC.DELETE_PARTICIPANT_VALIDATION_ENABLED || false
+  DELETE_PARTICIPANT_VALIDATION_ENABLED: RC.DELETE_PARTICIPANT_VALIDATION_ENABLED || false,
+  HTTP_REQUEST_TIMEOUT_MS: RC.HTTP_REQUEST_TIMEOUT_MS ?? 20_000
 }
 
 if (config.JWS_SIGN) {

package/src/models/oracle/facade.js

@@ -43,7 +43,10 @@ const { Headers, RestMethods, ReturnCodes } = Enums.Http
 const sendHttpRequest = ({ method, ...restArgs }) => request.sendRequest({
   ...restArgs,
   method: method.toUpperCase(),
-  hubNameRegex
+  hubNameRegex,
+  axiosRequestOptionsOverride: {
+    timeout: Config.HTTP_REQUEST_TIMEOUT_MS
+  }
 })
 
 /**

package/src/models/participantEndpoint/facade.js

@@ -37,6 +37,9 @@ const { logger } = require('../../lib')
 const { hubNameRegex } = require('../../lib/util').hubNameConfig
 
 const uriRegex = /(?:^.*)(\/(participants|parties|quotes|transfers)(\/.*)*)$/
+const axiosRequestOptionsOverride = {
+  timeout: Config.HTTP_REQUEST_TIMEOUT_MS
+}
 
 /**
  * @module src/models/participantEndpoint/facade
@@ -115,7 +118,8 @@ exports.sendRequest = async (headers, requestedParticipant, endpointType, method
       span,
       protocolVersions,
       hubNameRegex,
-      apiType: Config.API_TYPE
+      apiType: Config.API_TYPE,
+      axiosRequestOptionsOverride
     }
     logger.debug('participant - sendRequest params:', { params })
     params.jwsSigner = defineJwsSigner(Config, headers, requestedEndpoint)
@@ -252,7 +256,8 @@ exports.sendErrorToParticipant = async (participantName, endpointType, errorInfo
       hubNameRegex,
       span,
       protocolVersions,
-      apiType: Config.API_TYPE
+      apiType: Config.API_TYPE,
+      axiosRequestOptionsOverride
     }
     logger.debug('participant - sendErrorToParticipant params: ', { params })
     params.jwsSigner = defineJwsSigner(Config, clonedHeaders, requesterErrorEndpoint)

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

@@ -240,7 +240,9 @@ describe('Parties Tests', () => {
     it('handles error when sourceDfsp cannot be found (no fspiop-proxy in headers)', async () => {
       expect.hasAssertions()
       // Arrange
-      participant.validateParticipant = sandbox.stub().resolves(null)
+      participant.validateParticipant = sandbox.stub()
+        .resolves(null)
+        .onSecondCall().resolves({})
       participant.sendErrorToParticipant = sandbox.stub().resolves(null)
       const loggerStub = sandbox.stub(logger.mlLogger, 'error')
 
@@ -258,7 +260,11 @@ describe('Parties Tests', () => {
 
     it('should send error callback, if proxy-header is present, but no proxy in the scheme', async () => {
       Config.PROXY_CACHE_CONFIG.enabled = true
-      participant.validateParticipant = sandbox.stub().resolves(null)
+      participant.validateParticipant = sandbox.stub()
+        .resolves(null) // source
+        .onSecondCall().resolves(null) // proxy
+        .onThirdCall().resolves({}) // destination of callback
+      // !! Need to review the whole test: coz it's not clear where to send callback if no proxy and external source
       participant.sendErrorToParticipant = sandbox.stub().resolves()
       participant.sendRequest = sandbox.stub().resolves()
       const proxy = `proxy-${Date.now()}`
@@ -483,6 +489,7 @@ describe('Parties Tests', () => {
       participant.validateParticipant = sandbox.stub()
         .onFirstCall().resolves(null) // source
         .onSecondCall().resolves(null) // oracle dfsp
+        .onThirdCall().resolves({})
       participant.sendRequest = sandbox.stub().resolves()
       participant.sendErrorToParticipant = sandbox.stub().resolves()
 
@@ -631,6 +638,9 @@ describe('Parties Tests', () => {
       // Arrange
       const loggerStub = sandbox.stub(logger.constructor.prototype, 'error')
       participant.sendErrorToParticipant = sandbox.stub().resolves()
+      participant.validateParticipant = sandbox.stub()
+        .resolves(null)
+        .onSecondCall().resolves({})
 
       const payload = JSON.stringify({ testPayload: true })
       const dataUri = encodePayload(payload, 'application/json')
@@ -755,7 +765,7 @@ describe('Parties Tests', () => {
       await partiesDomain.putPartiesByTypeAndID(Helper.putByTypeIdRequest.headers, Helper.putByTypeIdRequest.params, 'put', payload, dataUri, null, proxyCache)
 
       // Assert
-      expect(participant.validateParticipant.callCount).toBe(2)
+      expect(participant.validateParticipant.callCount).toBe(3)
       expect(participant.sendErrorToParticipant.callCount).toBe(1)
       participant.validateParticipant.reset()
       participant.sendErrorToParticipant.reset()
@@ -784,7 +794,7 @@ describe('Parties Tests', () => {
       await partiesDomain.putPartiesByTypeAndID(Helper.putByTypeIdRequest.headers, params, 'put', payload, dataUri, null, proxyCache)
 
       // Assert
-      expect(participant.validateParticipant.callCount).toBe(2)
+      expect(participant.validateParticipant.callCount).toBe(3)
       expect(participant.sendErrorToParticipant.callCount).toBe(1)
       const firstCallArgs = participant.sendErrorToParticipant.getCall(0).args
       expect(firstCallArgs[1]).toBe(expectedErrorCallbackEnpointType)
@@ -850,7 +860,9 @@ describe('Parties Tests', () => {
     it('sends error to the participant when there is no destination participant', async () => {
       expect.hasAssertions()
       // Arrange
-      participant.validateParticipant = sandbox.stub().resolves(null)
+      participant.validateParticipant = sandbox.stub()
+        .resolves(null)
+        .onSecondCall().resolves({})
       participant.sendErrorToParticipant = sandbox.stub().throws(new Error('Unknown error'))
       const payload = JSON.stringify({ errorPayload: true })
       const dataUri = encodePayload(payload, 'application/json')
@@ -884,14 +896,16 @@ describe('Parties Tests', () => {
       // Assert
       expect(participant.sendErrorToParticipant.callCount).toBe(1)
       const sendErrorCallArgs = participant.sendErrorToParticipant.getCall(0).args
-      expect(sendErrorCallArgs[0]).toStrictEqual(headers['fspiop-destination'])
+      expect(sendErrorCallArgs[0]).toStrictEqual(headers['fspiop-source'])
     })
 
     it('handles error when `validateParticipant()` fails', async () => {
       expect.hasAssertions()
       // Arrange)
       const loggerStub = sandbox.stub(logger.constructor.prototype, 'error')
-      participant.validateParticipant = sandbox.stub().throws(new Error('Validation fails'))
+      participant.validateParticipant = sandbox.stub()
+        .onFirstCall().throws(new Error('Validation fails'))
+        .onSecondCall().resolves({})
       participant.sendErrorToParticipant = sandbox.stub().resolves({})
       const payload = JSON.stringify({ errorPayload: true })
       const expectedCallbackEnpointType = Enum.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_PUT_ERROR
@@ -911,7 +925,9 @@ describe('Parties Tests', () => {
       // Arrange
 
       const loggerStub = sandbox.stub(logger.constructor.prototype, 'error')
-      participant.validateParticipant = sandbox.stub().throws(new Error('Validation fails'))
+      participant.validateParticipant = sandbox.stub()
+        .throws(new Error('Validation fails'))
+        .onSecondCall().resolves({})
       participant.sendErrorToParticipant = sandbox.stub().resolves({})
       const payload = JSON.stringify({ errorPayload: true })
       const params = { ...Helper.putByTypeIdRequest.params, SubId: 'SubId' }
@@ -935,9 +951,10 @@ describe('Parties Tests', () => {
       const proxy = `proxy-${Date.now()}`
       const headers = fixtures.partiesCallHeadersDto({ destination, proxy })
       const { params } = Helper.putByTypeIdRequest
-      participant.validateParticipant = sandbox.stub().resolves({})
+      participant.validateParticipant = sandbox.stub().resolves(null) // external participant
       participant.sendRequest = sandbox.stub().resolves()
       participant.sendErrorToParticipant = sandbox.stub().resolves()
+      proxyCache.lookupProxyByDfspId = sandbox.stub().resolves(proxy)
       oracleEndpointCached.getOracleEndpointByType = sandbox.stub().resolves([
         { value: 'http://oracle.endpoint' }
       ])
@@ -950,8 +967,9 @@ describe('Parties Tests', () => {
       expect(participant.sendRequest.callCount).toBe(0)
       expect(participant.sendErrorToParticipant.callCount).toBe(1)
       // eslint-disable-next-line no-unused-vars
-      const [sentTo, _, data] = participant.sendErrorToParticipant.lastCall.args
-      expect(sentTo).toBe(destination)
+      const [sentTo, _, data, cbHeaders] = participant.sendErrorToParticipant.lastCall.args
+      expect(sentTo).toBe(proxy)
+      expect(cbHeaders[Headers.FSPIOP.DESTINATION]).toBe(destination)
       expect(data.errorInformation.errorCode).toBe('2003')
     })
   })

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

@@ -38,6 +38,7 @@ describe('BasePartiesService Tests -->', () => {
   })
 
   test('should send error party callback in ISO20022 format', async () => {
+    participantMock.validateParticipant = jest.fn().mockResolvedValue({})
     const deps = {
       ...createMockDeps(),
       config: { ...config, API_TYPE: API_TYPES.iso20022 }

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

@@ -30,7 +30,7 @@ const { createMockDeps, oracleMock, participantMock } = require('./deps')
 const { PutPartiesErrorService } = require('#src/domain/parties/services/index')
 const fixtures = require('#test/fixtures/index')
 
-const { RestMethods } = PutPartiesErrorService.enums()
+const { RestMethods, Headers } = PutPartiesErrorService.enums()
 
 describe('PutPartiesErrorService Tests -->', () => {
   beforeEach(() => {
@@ -38,33 +38,34 @@ describe('PutPartiesErrorService Tests -->', () => {
   })
 
   test('should cleanup oracle and forward SERVICE_CURRENTLY_UNAVAILABLE error for party from external dfsp', async () => {
-    participantMock.validateParticipant = jest.fn().mockResolvedValue({})
-    const destination = 'destFsp'
+    participantMock.validateParticipant = jest.fn().mockRejectedValue(new Error('No participant found')) // external participant
+    const destination = 'externalDfsp'
+    const proxyDest = 'proxyDest'
+    const deps = createMockDeps()
+    deps.proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValue(proxyDest)
+
     const headers = fixtures.partiesCallHeadersDto({ destination, proxy: 'proxyA' })
     const params = fixtures.partiesParamsDto()
     const dataUri = fixtures.dataUriDto()
-    const service = new PutPartiesErrorService(createMockDeps(), { headers, params, dataUri })
+    const service = new PutPartiesErrorService(deps, { headers, params, dataUri })
 
     await service.handleRequest()
     expect(oracleMock.oracleRequest).toHaveBeenCalledTimes(1)
     expect(oracleMock.oracleRequest.mock.lastCall[1]).toBe(RestMethods.DELETE)
     expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
     // eslint-disable-next-line no-unused-vars
-    const [sentTo, _, payload] = participantMock.sendErrorToParticipant.mock.lastCall
-    expect(sentTo).toBe(destination)
+    const [sentTo, _, payload, cbHeaders] = participantMock.sendErrorToParticipant.mock.lastCall
+    expect(sentTo).toBe(proxyDest)
+    expect(cbHeaders[Headers.FSPIOP.DESTINATION]).toBe(destination)
     expect(payload.errorInformation.errorCode).toBe('2003')
   })
 
-  test('should NOT cleanup oracle if destination is external', async () => {
-    const destination = 'externalDfsp'
-    const proxyDest = 'proxyDest'
+  test('should NOT cleanup oracle if destination is local', async () => {
+    const destination = 'localDfsp'
     const deps = createMockDeps()
-    deps.participant.validateParticipant = jest.fn().mockResolvedValue(null)
-    deps.proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValue(proxyDest)
+    deps.participant.validateParticipant = jest.fn().mockResolvedValue({})
 
-    const headers = fixtures.partiesCallHeadersDto({
-      destination, proxy: 'proxyA'
-    })
+    const headers = fixtures.partiesCallHeadersDto({ destination })
     const params = fixtures.partiesParamsDto()
     const dataUri = fixtures.dataUriDto()
     const service = new PutPartiesErrorService(deps, { headers, params, dataUri })
@@ -72,6 +73,6 @@ describe('PutPartiesErrorService Tests -->', () => {
     await service.handleRequest()
     expect(oracleMock.oracleRequest).not.toHaveBeenCalled()
     expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
-    expect(participantMock.sendErrorToParticipant.mock.lastCall[0]).toBe(proxyDest)
+    expect(participantMock.sendErrorToParticipant.mock.lastCall[0]).toBe(destination)
   })
 })

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

@@ -0,0 +1,117 @@
+/*****
+ 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 { PutPartiesService } = require('#src/domain/parties/services/index')
+const config = require('#src/lib/config')
+const fixtures = require('#test/fixtures/index')
+
+const { Headers } = PutPartiesService.enums()
+
+describe('PutPartiesService Tests -->', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should send error callback to source in case of error on forwarding request to destination (buffer scheme)', async () => {
+    const errMessage = 'Test Http Error'
+    participantMock.sendRequest = jest.fn().mockRejectedValue(new Error(errMessage))
+    participantMock.validateParticipant = jest.fn().mockResolvedValue({})
+    const source = 'mwk-dfsp'
+    const destination = 'zmk-dfsp'
+    const headers = fixtures.partiesCallHeadersDto({ source, destination, proxy: '' })
+    const params = fixtures.partiesParamsDto()
+    const dataUri = fixtures.dataUriDto()
+    const service = new PutPartiesService(createMockDeps(), { headers, params, dataUri })
+
+    await service.handleRequest()
+      .catch(err => service.handleError(err))
+
+    expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+    // eslint-disable-next-line no-unused-vars
+    const [sentTo, _, payload, cbHeaders] = participantMock.sendErrorToParticipant.mock.lastCall
+    expect(sentTo).toBe(source)
+    expect(payload.errorInformation.errorCode).toBe('2001')
+    expect(payload.errorInformation.errorDescription.endsWith(errMessage)).toBe(true)
+    expect(cbHeaders[Headers.FSPIOP.SOURCE]).toBe(config.HUB_NAME)
+    expect(cbHeaders[Headers.FSPIOP.DESTINATION]).toBe(source)
+  })
+
+  test('should send error callback to source proxy in case of error on forwarding request to destination proxy (region scheme)', async () => {
+    const errMessage = 'Test Http Error'
+    participantMock.sendRequest = jest.fn().mockRejectedValue(new Error(errMessage))
+    participantMock.validateParticipant = jest.fn().mockResolvedValue(null)
+
+    const source = 'zmk-dfsp'
+    const proxy = 'proxy-zmk'
+    const destination = 'mwk-dfsp'
+    const proxyDest = 'proxy-mwk'
+
+    const deps = createMockDeps()
+    deps.proxyCache.lookupProxyByDfspId = jest.fn(async (dfsp) => {
+      if (dfsp === source) return proxy
+      if (dfsp === destination) return proxyDest
+      return null
+    })
+
+    const headers = fixtures.partiesCallHeadersDto({ source, destination, proxy })
+    const params = fixtures.partiesParamsDto()
+    const dataUri = fixtures.dataUriDto()
+    const service = new PutPartiesService(deps, { headers, params, dataUri })
+
+    await service.handleRequest()
+      .catch(err => service.handleError(err))
+
+    expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+    // eslint-disable-next-line no-unused-vars
+    const [sentTo, _, payload, cbHeaders] = participantMock.sendErrorToParticipant.mock.lastCall
+    expect(sentTo).toBe(proxy)
+    expect(payload.errorInformation.errorCode).toBe('2001')
+    expect(payload.errorInformation.errorDescription.endsWith(errMessage)).toBe(true)
+    expect(cbHeaders[Headers.FSPIOP.SOURCE]).toBe(config.HUB_NAME)
+    expect(cbHeaders[Headers.FSPIOP.DESTINATION]).toBe(source)
+  })
+
+  test('should just log error in case handleError failed', async () => {
+    const headers = fixtures.partiesCallHeadersDto()
+    const params = fixtures.partiesParamsDto()
+    const dataUri = fixtures.dataUriDto()
+    const service = new PutPartiesService(createMockDeps(), { headers, params, dataUri })
+
+    service.handleRequest = jest.fn().mockRejectedValue(new Error('handleRequest failed'))
+    service.identifyDestinationForCallback = jest.fn()
+    service.sendErrorCallback = jest.fn().mockRejectedValue(new Error('sendErrorCallback failed'))
+    const logSpy = jest.spyOn(service.log.mlLogger, 'error')
+
+    const result = await service.handleRequest()
+      .catch(err => service.handleError(err))
+
+    expect(result).toBeUndefined()
+    expect(logSpy.mock.lastCall[0]).toBe('failed to handleError. No further processing! ')
+  })
+})

package/test/unit/models/participantEndpoint/facade.test.js

@@ -188,6 +188,26 @@ describe('participantEndpoint Facade', () => {
 
       expect(mockSendRequest.mock.lastCall[0].jwsSigner).toBeTruthy()
     })
+
+    it('should add default timeout to sendRequest', async () => {
+      const mockedConfig = {
+        JWS_SIGN: false,
+        FSPIOP_SOURCE_TO_SIGN: mockHubName,
+        PROTOCOL_VERSIONS: fixtures.protocolVersionsDto(),
+        HTTP_REQUEST_TIMEOUT_MS: 1000
+      }
+      jest.mock('../../../../src/lib/config', () => (mockedConfig))
+      mockGetEndpoint.mockImplementation(() => 'https://example.com/12345')
+      mockSendRequest.mockImplementation(async () => true)
+      const ParticipantFacade = require(`${src}/models/participantEndpoint/facade`)
+
+      const headers = {}
+      const requestedParticipant = {}
+      const endpointType = 'URL'
+
+      await ParticipantFacade.sendRequest(headers, requestedParticipant, endpointType)
+      expect(mockSendRequest.mock.calls[0][0].axiosRequestOptionsOverride.timeout).toBe(mockedConfig.HTTP_REQUEST_TIMEOUT_MS)
+    })
   })
 
   describe('validateParticipant', () => {