account-lookup-service 17.13.0-snapshot.0 → 17.13.0-snapshot.10

package/.grype.yaml

@@ -3,7 +3,6 @@ disabled: false
 
 ignore:
 
-
 # Set output format defaults
 output:
   - "table"

package/audit-ci.jsonc

@@ -5,5 +5,6 @@
   "moderate": true,
   // NOTE: Please add as much information as possible to any items added to the allowList
   "allowlist": [
+    "GHSA-4hjh-wcwx-xvwj" // todo: update axios -  https://github.com/advisories/GHSA-4hjh-wcwx-xvwj
   ]
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "account-lookup-service",
   "description": "Account Lookup Service is used to validate Party and Participant lookups.",
-  "version": "17.13.0-snapshot.0",
+  "version": "17.13.0-snapshot.10",
   "license": "Apache-2.0",
   "author": "ModusBox",
   "contributors": [
@@ -91,22 +91,22 @@
     "@hapi/hapi": "21.4.3",
     "@hapi/inert": "7.1.0",
     "@hapi/vision": "7.0.3",
-    "@mojaloop/central-services-error-handling": "13.1.1",
+    "@mojaloop/central-services-error-handling": "13.1.2-snapshot.0",
     "@mojaloop/central-services-health": "15.1.0",
     "@mojaloop/central-services-logger": "11.9.3",
     "@mojaloop/central-services-metrics": "12.7.1",
-    "@mojaloop/central-services-shared": "18.32.0",
+    "@mojaloop/central-services-shared": "18.33.0",
     "@mojaloop/central-services-stream": "11.8.7",
     "@mojaloop/database-lib": "^11.3.2",
     "@mojaloop/event-sdk": "14.7.0",
     "@mojaloop/inter-scheme-proxy-cache-lib": "2.6.0",
-    "@mojaloop/ml-schema-transformer-lib": "2.7.7",
-    "@mojaloop/sdk-standard-components": "19.16.7",
+    "@mojaloop/ml-schema-transformer-lib": "2.7.8",
+    "@mojaloop/sdk-standard-components": "19.17.0",
     "@now-ims/hapi-now-auth": "2.1.0",
     "ajv": "8.17.1",
     "ajv-keywords": "5.1.0",
     "blipp": "4.0.2",
-    "commander": "14.0.0",
+    "commander": "14.0.1",
     "cron": "4.3.3",
     "hapi-auth-bearer-token": "8.0.0",
     "joi": "18.0.1",
@@ -124,6 +124,7 @@
     "postcss": {
       "nanoid": "^3.3.8"
     },
+    "@mojaloop/central-services-error-handling": "13.1.2-snapshot.0",
     "@mojaloop/central-services-health": {
       "@mojaloop/central-services-logger": ">=11.4.0"
     },
@@ -165,7 +166,7 @@
   "devDependencies": {
     "@types/jest": "30.0.0",
     "audit-ci": "^7.1.0",
-    "axios": "1.11.0",
+    "axios": "1.12.2",
     "axios-retry": "^4.5.0",
     "docdash": "2.0.2",
     "dotenv": "^17.2.2",
@@ -175,7 +176,7 @@
     "jest-junit": "16.0.0",
     "jsdoc": "4.0.4",
     "nodemon": "3.1.10",
-    "npm-check-updates": "18.1.0",
+    "npm-check-updates": "18.1.1",
     "nyc": "17.1.0",
     "pre-commit": "1.2.2",
     "proxyquire": "2.1.3",

package/src/constants.js

@@ -29,7 +29,7 @@ const { API_TYPES } = require('@mojaloop/central-services-shared').Util.Hapi
 
 const ERROR_MESSAGES = Object.freeze({
   emptyFilteredPartyList: 'Empty oracle partyList, filtered based on callbackEndpointType',
-  externalPartyError: 'External party error', // todo: think better message
+  externalPartyError: 'External party resolution error',
   failedToCacheSendToProxiesList: 'Failed to cache sendToProxiesList',
   noDiscoveryRequestsForwarded: 'No discovery requests forwarded to participants',
   sourceFspNotFound: 'Requester FSP not found',

package/src/domain/parties/putParties.js

@@ -47,7 +47,7 @@ const services = require('./services')
  * @param {IProxyCache} [proxyCache] - IProxyCache instance
  */
 const putPartiesByTypeAndID = async (headers, params, method, payload, dataUri, cache, proxyCache = undefined) => {
-  // todo: think, if we need to pass span here
+  // think, if we need to pass span here
   const component = putPartiesByTypeAndID.name
   const histTimerEnd = Metrics.getHistogram(
     component,

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

@@ -26,12 +26,10 @@
  ******/
 
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
-const { Enum } = require('@mojaloop/central-services-shared')
-const { decodePayload } = require('@mojaloop/central-services-shared').Util.StreamingProtocol
+const { Enum, Util } = require('@mojaloop/central-services-shared')
 const { initStepState } = require('../../../lib/util')
 const { createCallbackHeaders } = require('../../../lib/headers')
 const { ERROR_MESSAGES } = require('../../../constants')
-const { makeAcceptContentTypeHeader } = require('@mojaloop/central-services-shared').Util.Headers
 
 const { FspEndpointTypes, FspEndpointTemplates } = Enum.EndPoints
 const { Headers, RestMethods, HeaderResources } = Enum.Http
@@ -170,6 +168,26 @@ class BasePartiesService {
     this.log.info('sendErrorCallback is done', { sendTo, errorInfo })
   }
 
+  /**
+   * @returns {Promise<{ fspId: string, partySubIdOrType?: string }[]>} List of parties from oracle response
+   */
+  async sendOracleDiscoveryRequest () {
+    this.stepInProgress('#sendOracleDiscoveryRequest')
+    const { headers, params, query } = this.inputs
+
+    const response = await this.deps.oracle.oracleRequest(headers, RestMethods.GET, params, query, undefined, this.deps.cache)
+    this.log.verbose('oracle discovery raw response:', { response })
+
+    let { partyList } = response?.data || {}
+    if (!Array.isArray(partyList)) {
+      this.log.warn('invalid oracle discovery response:', { response })
+      // todo: maybe, it's better to throw an error
+      partyList = []
+    }
+
+    return partyList
+  }
+
   async sendDeleteOracleRequest (headers, params) {
     this.stepInProgress('sendDeleteOracleRequest')
     const result = await this.deps.oracle.oracleRequest(headers, RestMethods.DELETE, params, null, null, this.deps.cache)
@@ -184,6 +202,24 @@ class BasePartiesService {
     return isRemoved
   }
 
+  async sendPartyResolutionErrorCallback () {
+    this.stepInProgress('sendPartyResolutionErrorCallback')
+    const { headers, params } = this.inputs
+
+    const error = this.createFspiopPartyResolutionError(ERROR_MESSAGES.externalPartyError)
+    const callbackHeaders = BasePartiesService.createErrorCallbackHeaders(headers, params)
+    const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(this.deps.config, error, callbackHeaders, params)
+    this.state.destination = callbackHeaders[Headers.FSPIOP.DESTINATION]
+
+    await this.identifyDestinationForCallback()
+    await this.sendErrorCallback({
+      errorInfo,
+      headers: callbackHeaders,
+      params
+    })
+    this.log.verbose('sendPartyResolutionErrorCallback is done', { callbackHeaders, errorInfo })
+  }
+
   createFspiopIdNotFoundError (errMessage, log = this.log) {
     log.warn(errMessage)
     return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
@@ -194,9 +230,9 @@ class BasePartiesService {
     return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND, errMessage)
   }
 
-  createFspiopServiceUnavailableError (errMessage, log = this.log) {
+  createFspiopPartyResolutionError (errMessage, log = this.log) {
     log.warn(errMessage)
-    return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.SERVICE_CURRENTLY_UNAVAILABLE, errMessage)
+    return ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_RESOLUTION_FAILURE, errMessage)
   }
 
   stepInProgress (stepName) {
@@ -222,7 +258,7 @@ class BasePartiesService {
   }
 
   static decodeDataUriPayload (dataUri) {
-    const decoded = decodePayload(dataUri, { asParsed: false })
+    const decoded = Util.StreamingProtocol.decodePayload(dataUri, { asParsed: false })
     return decoded.body.toString()
   }
 
@@ -257,7 +293,7 @@ class BasePartiesService {
     return {
       [Headers.FSPIOP.SOURCE]: hubName,
       [Headers.FSPIOP.DESTINATION]: destination,
-      [Headers.GENERAL.CONTENT_TYPE.value]: makeAcceptContentTypeHeader(
+      [Headers.GENERAL.CONTENT_TYPE.value]: Util.Headers.makeAcceptContentTypeHeader(
         HeaderResources.PARTIES,
         config.PROTOCOL_VERSIONS.CONTENT.DEFAULT.toString(),
         config.API_TYPE

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

@@ -28,7 +28,7 @@
 const { ERROR_MESSAGES } = require('../../../constants')
 const BasePartiesService = require('./BasePartiesService')
 
-const { FspEndpointTypes, RestMethods } = BasePartiesService.enums()
+const { RestMethods } = BasePartiesService.enums()
 const proxyCacheTtlSec = 40 // todo: make configurable
 
 class GetPartiesService extends BasePartiesService {
@@ -45,8 +45,8 @@ class GetPartiesService extends BasePartiesService {
       return
     }
 
-    const response = await this.sendOracleDiscoveryRequest()
-    const isSent = await this.processOraclePartyListResponse(response)
+    const partyList = await this.sendOracleDiscoveryRequest()
+    const isSent = await this.processOraclePartyListResponse(partyList)
     this.log.info(`getParties request is ${isSent ? '' : 'NOT '}forwarded to oracle lookup DFSP`)
     if (isSent) return
 
@@ -108,7 +108,7 @@ class GetPartiesService extends BasePartiesService {
       const isValid = await this.#validateLocalDestinationForExternalSource()
       if (!isValid) {
         log.warn('incorrect destination from external source', { destination })
-        await this.#sendPartyNotFoundErrorCallback(headers)
+        await this.sendPartyResolutionErrorCallback()
         return
       }
     }
@@ -117,20 +117,14 @@ class GetPartiesService extends BasePartiesService {
     log.info('discovery getPartiesByTypeAndID request was sent', { sendTo })
   }
 
-  async sendOracleDiscoveryRequest () {
-    this.stepInProgress('#sendOracleDiscoveryRequest')
-    const { headers, params, query } = this.inputs
-    return this.deps.oracle.oracleRequest(headers, RestMethods.GET, params, query, undefined, this.deps.cache)
-  }
-
-  async processOraclePartyListResponse (response) {
-    if (!Array.isArray(response?.data?.partyList) || response.data.partyList.length === 0) {
+  async processOraclePartyListResponse (rawPartyList) {
+    if (rawPartyList.length === 0) {
       this.log.verbose('oracle partyList is empty')
       return false
     }
 
     this.stepInProgress('processOraclePartyList')
-    const partyList = this.#filterOraclePartyList(response)
+    const partyList = this.#filterOraclePartyList(rawPartyList)
 
     let sentCount = 0
     await Promise.all(partyList.map(async party => {
@@ -174,28 +168,20 @@ class GetPartiesService extends BasePartiesService {
     return isLocal
   }
 
-  #filterOraclePartyList (response) {
+  #filterOraclePartyList (partyList) {
     // Oracle's API is a standard rest-style end-point Thus a GET /party on the oracle will return all participant-party records.
     // We must filter the results based on the callbackEndpointType to make sure we remove records containing partySubIdOrType when we are in FSPIOP_CALLBACK_URL_PARTIES_GET mode:
-    this.stepInProgress('filterOraclePartyList')
+    this.stepInProgress('#filterOraclePartyList')
     const { params } = this.inputs
-    const callbackEndpointType = this.deps.partiesUtils.getPartyCbType(params.SubId)
-    let filteredPartyList
-
-    switch (callbackEndpointType) {
-      case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_GET:
-        filteredPartyList = response.data.partyList.filter(party => party.partySubIdOrType == null) // Filter records that DON'T contain a partySubIdOrType
-        break
-      case FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_SUB_ID_GET:
-        filteredPartyList = response.data.partyList.filter(party => party.partySubIdOrType === params.SubId) // Filter records that match partySubIdOrType
-        break
-      default:
-        filteredPartyList = response // Fallback to providing the standard list
-    }
 
-    if (!Array.isArray(filteredPartyList) || !filteredPartyList.length) {
+    const filteredPartyList = !params?.SubId
+      ? partyList.filter(party => party.partySubIdOrType == null) // Filter records that DON'T contain a partySubIdOrType
+      : partyList.filter(party => party.partySubIdOrType === params.SubId) // Filter records that match partySubIdOrType
+
+    if (!filteredPartyList.length) {
       throw super.createFspiopIdNotFoundError(ERROR_MESSAGES.emptyFilteredPartyList)
     }
+    this.log.verbose('#filterOraclePartyList is done:', { filteredPartyList })
 
     return filteredPartyList
   }
@@ -338,13 +324,13 @@ class GetPartiesService extends BasePartiesService {
     log.verbose('needOracleValidation: ', { needValidation })
     if (!needValidation) return true
 
-    const oracleResponse = await this.sendOracleDiscoveryRequest()
-    if (!Array.isArray(oracleResponse?.data?.partyList) || oracleResponse.data.partyList.length === 0) {
+    const partyList = await this.sendOracleDiscoveryRequest()
+    if (partyList.length === 0) {
       log.warn('Oracle returned empty party list')
       return false
     }
 
-    const isValid = oracleResponse.data.partyList.some(party => party.fspId === state.destination)
+    const isValid = partyList.some(party => party.fspId === state.destination)
     log.verbose('#validateLocalDestinationForExternalSource is done', { isValid })
     return isValid
   }

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

@@ -26,13 +26,13 @@
  ******/
 
 const BasePartiesService = require('./BasePartiesService')
-const { ERROR_MESSAGES } = require('../../../constants')
 
 class PutPartiesErrorService extends BasePartiesService {
   async handleRequest () {
     if (this.state.proxyEnabled && this.state.proxy) {
-      const alsReq = this.deps.partiesUtils.alsRequestDto(this.state.destination, this.inputs.params) // or source?
+      const alsReq = this.deps.partiesUtils.alsRequestDto(this.state.destination, this.inputs.params)
       const isInterSchemeDiscoveryCase = await this.deps.proxyCache.isPendingCallback(alsReq)
+      this.log.verbose(`isInterSchemeDiscoveryCase: ${isInterSchemeDiscoveryCase}`, this.state)
 
       if (isInterSchemeDiscoveryCase) {
         const isLast = await this.checkLastProxyCallback(alsReq)
@@ -41,13 +41,11 @@ class PutPartiesErrorService extends BasePartiesService {
           return
         }
       } else {
-        const schemeParticipant = await this.validateParticipant(this.state.destination)
-        if (!schemeParticipant) {
-          this.log.info('Need to cleanup oracle and forward SERVICE_CURRENTLY_UNAVAILABLE error')
+        const isExternal = await this.#isPartyFromExternalDfsp()
+        if (isExternal) {
+          this.log.info('need to cleanup oracle coz party is from external DFSP')
           await this.cleanupOracle()
-          await this.removeProxyGetPartiesTimeoutCache(alsReq)
-          await this.forwardServiceUnavailableErrorCallback()
-          return
+          await this.removeProxyGetPartiesTimeoutCache(alsReq) // think if we need this
         }
       }
     }
@@ -79,20 +77,18 @@ class PutPartiesErrorService extends BasePartiesService {
     return super.sendErrorCallback({ errorInfo, headers, params })
   }
 
-  async forwardServiceUnavailableErrorCallback () {
-    this.stepInProgress('forwardServiceUnavailableErrorCallback')
-    const { headers, params } = this.inputs
-    const error = super.createFspiopServiceUnavailableError(ERROR_MESSAGES.externalPartyError)
-    const callbackHeaders = BasePartiesService.createErrorCallbackHeaders(headers, params, this.state.destination)
-    const errorInfo = await this.deps.partiesUtils.makePutPartiesErrorPayload(this.deps.config, error, callbackHeaders, params)
+  async #isPartyFromExternalDfsp () {
+    this.stepInProgress('#isPartyFromExternalDfsp')
+    const partyList = await super.sendOracleDiscoveryRequest()
+    if (!partyList.length) {
+      this.log.verbose('oracle returns empty partyList')
+      return false
+    }
+    // think, if we have several parties from oracle
+    const isExternal = !(await this.validateParticipant(partyList[0].fspId))
+    this.log.verbose('#isPartyFromExternalDfsp is done:', { isExternal, partyList })
 
-    await this.identifyDestinationForCallback()
-    await super.sendErrorCallback({
-      errorInfo,
-      headers: callbackHeaders,
-      params
-    })
-    this.log.verbose('#forwardServiceUnavailableErrorCallback is done', { callbackHeaders, errorInfo })
+    return isExternal
   }
 }
 

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

@@ -104,7 +104,7 @@ class PutPartiesService extends BasePartiesService {
       fspId: source
     }
     await this.deps.oracle.oracleRequest(headers, RestMethods.POST, params, null, mappingPayload, this.deps.cache)
-    this.log.info('oracle was updated with mappingPayload', { mappingPayload })
+    this.log.info('oracle was updated with mappingPayload: ', mappingPayload)
   }
 }
 

package/src/lib/headers.js

@@ -41,6 +41,7 @@ const Config = require('../lib/config')
  */
 exports.createCallbackHeaders = (params) => {
   const callbackHeaders = { ...params.requestHeaders }
+  delete callbackHeaders[Enums.Http.Headers.FSPIOP.PROXY]
 
   callbackHeaders[Enums.Http.Headers.FSPIOP.SOURCE] = Config.HUB_NAME
   callbackHeaders[Enums.Http.Headers.FSPIOP.DESTINATION] = params.requestHeaders[Enums.Http.Headers.FSPIOP.SOURCE]

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

@@ -947,6 +947,7 @@ describe('Parties Tests', () => {
       Config.PROXY_CACHE_CONFIG.enabled = true
       const errorCode = MojaloopApiErrorCodes.PAYEE_IDENTIFIER_NOT_VALID.code
       const payload = fixtures.errorCallbackResponseDto({ errorCode })
+      const dataUri = encodePayload(JSON.stringify(payload), 'application/json')
       const destination = `dest-${Date.now()}`
       const proxy = `proxy-${Date.now()}`
       const headers = fixtures.partiesCallHeadersDto({ destination, proxy })
@@ -958,11 +959,13 @@ describe('Parties Tests', () => {
       oracleEndpointCached.getOracleEndpointByType = sandbox.stub().resolves([
         { value: 'http://oracle.endpoint' }
       ])
-      oracle.oracleRequest = sandbox.stub().resolves()
+      oracle.oracleRequest = sandbox.stub().resolves({
+        data: { partyList: [{ fspId: 'fspId' }] }
+      })
 
-      await partiesDomain.putPartiesErrorByTypeAndID(headers, params, payload, '', null, null, proxyCache)
+      await partiesDomain.putPartiesErrorByTypeAndID(headers, params, payload, dataUri, null, null, proxyCache)
 
-      expect(oracle.oracleRequest.callCount).toBe(1)
+      expect(oracle.oracleRequest.callCount).toBe(2)
       expect(oracle.oracleRequest.lastCall.args[1]).toBe(RestMethods.DELETE)
       expect(participant.sendRequest.callCount).toBe(0)
       expect(participant.sendErrorToParticipant.callCount).toBe(1)
@@ -970,7 +973,7 @@ describe('Parties Tests', () => {
       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')
+      expect(JSON.parse(data).errorInformation.errorCode).toBe(errorCode)
     })
   })
 })

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

@@ -28,12 +28,12 @@
 const { setTimeout: sleep } = require('node:timers/promises')
 const {
   createMockDeps,
-  createOracleFacadeMock, // use it instead of oracleMock
-  createParticipantFacadeMock, // use it instead of participantMock
+  createOracleFacadeMock,
+  createParticipantFacadeMock,
   createProxyCacheMock,
   createProxiesUtilMock,
-  oracleMock, // deprecated - use createOracleFacadeMock
-  participantMock// deprecated - use createParticipantFacadeMock
+  oracleMock, // deprecated!  use createOracleFacadeMock instead
+  participantMock // deprecated!  use createParticipantFacadeMock instead
 } = require('./deps')
 // ↑ should be first require to mock external deps ↑
 const { GetPartiesService } = require('#src/domain/parties/services/index')
@@ -44,15 +44,14 @@ const { RestMethods, Headers } = GetPartiesService.enums()
 
 describe('GetPartiesService Tests -->', () => {
   const { config } = createMockDeps()
-  let apiType
+  const { API_TYPE } = config
 
   beforeEach(() => {
     jest.clearAllMocks()
-    apiType = config.API_TYPE
   })
 
   afterEach(() => {
-    config.API_TYPE = apiType // to avoid side effects
+    config.API_TYPE = API_TYPE // to avoid side effects
   })
 
   describe('forwardRequestToDestination method', () => {
@@ -335,9 +334,10 @@ describe('GetPartiesService Tests -->', () => {
     }
     const headers = fixtures.partiesCallHeadersDto({ destination: '' })
     const params = fixtures.partiesParamsDto()
-    const service = new GetPartiesService(deps, { headers, params })
 
+    const service = new GetPartiesService(deps, { headers, params })
     await service.handleRequest()
+
     expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
     const isoPayload = participantMock.sendErrorToParticipant.mock.lastCall[2]
     expect(isoPayload.Assgnmt).toBeDefined()
@@ -353,13 +353,17 @@ describe('GetPartiesService Tests -->', () => {
     let deps
     let oracle // facade
     let participant // facade
+    let proxyCache
     let headers
     let params
 
     beforeEach(() => {
       oracle = createOracleFacadeMock()
       participant = createParticipantFacadeMock()
-      deps = createMockDeps({ oracle, participant })
+      proxyCache = createProxyCacheMock({
+        addDfspIdToProxyMapping: jest.fn().mockResolvedValueOnce(true)
+      })
+      deps = createMockDeps({ oracle, participant, proxyCache })
       headers = fixtures.partiesCallHeadersDto({
         source: EXTERNAL_SOURCE_DFSP,
         destination: LOCAL_DESTINATION_DFSP,
@@ -369,17 +373,12 @@ describe('GetPartiesService Tests -->', () => {
     })
 
     test('should forward request when oracle DFSP matches destination DFSP', async () => {
-      // Setup proxy cache to NOT find proxy mapping for local destination
-      deps.proxyCache.addDfspIdToProxyMapping = jest.fn().mockResolvedValueOnce(true)
-      deps.proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValueOnce(null)
-
       participant.validateParticipant = jest.fn()
         .mockResolvedValueOnce(null) // external source (validateRequester)
         .mockResolvedValueOnce({}) // proxy exists (validateRequester)
         .mockResolvedValueOnce({}) // local destination (forwardRequestToDestination)
         .mockResolvedValueOnce(null) // external source (shouldValidateViaOracle)
         .mockResolvedValueOnce({}) // local destination (shouldValidateViaOracle)
-
       oracle.oracleRequest = jest.fn().mockResolvedValueOnce(
         fixtures.oracleRequestResponseDto({
           partyList: [{ fspId: LOCAL_DESTINATION_DFSP }]
@@ -412,22 +411,18 @@ describe('GetPartiesService Tests -->', () => {
     })
 
     test('should send error callback when oracle DFSP differs from destination DFSP', async () => {
-      // Setup proxy cache to NOT find proxy mapping for local destination
-      deps.proxyCache.addDfspIdToProxyMapping = jest.fn().mockResolvedValueOnce(true)
-      deps.proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValueOnce(null)
-
       participant.validateParticipant = jest.fn()
         .mockResolvedValueOnce(null) // external source (validateRequester)
         .mockResolvedValueOnce({}) // proxy exists (validateRequester)
         .mockResolvedValueOnce({}) // local destination (forwardRequestToDestination)
         .mockResolvedValueOnce(null) // external source (shouldValidateViaOracle)
         .mockResolvedValueOnce({})
-
       oracle.oracleRequest = jest.fn().mockResolvedValueOnce(
         fixtures.oracleRequestResponseDto({
           partyList: [{ fspId: ORACLE_DFSP_DIFFERENT }]
         })
       )
+      proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValueOnce(PROXY_ID)
 
       const service = new GetPartiesService(deps, { headers, params })
       await service.handleRequest()
@@ -478,12 +473,11 @@ describe('GetPartiesService Tests -->', () => {
         destination: 'externalDestinationDfsp',
         proxy: PROXY_ID
       })
-
       participant.validateParticipant = jest.fn()
         .mockResolvedValueOnce(null) // external source
         .mockResolvedValueOnce({}) // proxy exists
         .mockResolvedValueOnce(null) // external destination
-      deps.proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValueOnce(PROXY_ID)
+      proxyCache.lookupProxyByDfspId = jest.fn().mockResolvedValueOnce(PROXY_ID)
 
       const service = new GetPartiesService(deps, { headers: externalDestHeaders, params })
       await service.handleRequest()
@@ -502,7 +496,6 @@ describe('GetPartiesService Tests -->', () => {
         .mockResolvedValueOnce(null) // external source (shouldValidateViaOracle)
         .mockResolvedValueOnce({}) // local destination (shouldValidateViaOracle)
         .mockResolvedValueOnce({}) // local destination (forwardRequestToDestination)
-
       oracle.oracleRequest = jest.fn().mockResolvedValueOnce(
         fixtures.oracleRequestResponseDto({
           partyList: [{ fspId: ORACLE_DFSP_DIFFERENT }]

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

@@ -25,45 +25,54 @@
  --------------
  ******/
 
-const { createMockDeps, oracleMock, participantMock } = require('./deps')
-// ↑ should be first require to mock external deps ↑
 const { PutPartiesErrorService } = require('#src/domain/parties/services/index')
+const { createMockDeps, createOracleFacadeMock, createParticipantFacadeMock } = require('./deps')
 const fixtures = require('#test/fixtures/index')
 
 const { RestMethods, Headers } = PutPartiesErrorService.enums()
 
 describe('PutPartiesErrorService Tests -->', () => {
+  let oracle
+  let participant
+
   beforeEach(() => {
     jest.clearAllMocks()
+    oracle = createOracleFacadeMock()
+    participant = createParticipantFacadeMock()
   })
 
-  test('should cleanup oracle and forward SERVICE_CURRENTLY_UNAVAILABLE error for party from external dfsp', async () => {
-    participantMock.validateParticipant = jest.fn().mockRejectedValue(new Error('No participant found')) // external participant
-    const destination = 'externalDfsp'
+  test('should cleanup oracle and forward PARTY_RESOLUTION_FAILURE error for party from external dfsp', async () => {
+    participant.validateParticipant = jest.fn().mockRejectedValue(new Error('No participant found')) // external participant
+    oracle.oracleRequest = jest.fn().mockResolvedValue({
+      data: { partyList: [{ fspId: 'fspId' }] }
+    })
+    const destination = 'externalDestination'
     const proxyDest = 'proxyDest'
-    const deps = createMockDeps()
+    const deps = createMockDeps({ oracle, participant })
     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(deps, { headers, params, dataUri })
+    const data = { test: true }
+    const dataUri = fixtures.dataUriDto(data)
 
+    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, cbHeaders] = participantMock.sendErrorToParticipant.mock.lastCall
+
+    expect(oracle.oracleRequest).toHaveBeenCalledTimes(2)
+    expect(oracle.oracleRequest.mock.lastCall[1]).toBe(RestMethods.DELETE)
+    expect(participant.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+
+    const [sentTo, , payload, cbHeaders] = participant.sendErrorToParticipant.mock.lastCall
     expect(sentTo).toBe(proxyDest)
     expect(cbHeaders[Headers.FSPIOP.DESTINATION]).toBe(destination)
-    expect(payload.errorInformation.errorCode).toBe('2003')
+    expect(payload).toBe(JSON.stringify(data))
   })
 
   test('should NOT cleanup oracle if destination is local', async () => {
     const destination = 'localDfsp'
-    const deps = createMockDeps()
-    deps.participant.validateParticipant = jest.fn().mockResolvedValue({})
+    participant.validateParticipant = jest.fn().mockResolvedValue({})
+    const deps = createMockDeps({ participant })
 
     const headers = fixtures.partiesCallHeadersDto({ destination })
     const params = fixtures.partiesParamsDto()
@@ -71,8 +80,8 @@ describe('PutPartiesErrorService Tests -->', () => {
     const service = new PutPartiesErrorService(deps, { headers, params, dataUri })
 
     await service.handleRequest()
-    expect(oracleMock.oracleRequest).not.toHaveBeenCalled()
-    expect(participantMock.sendErrorToParticipant).toHaveBeenCalledTimes(1)
-    expect(participantMock.sendErrorToParticipant.mock.lastCall[0]).toBe(destination)
+    expect(oracle.oracleRequest).not.toHaveBeenCalled()
+    expect(participant.sendErrorToParticipant).toHaveBeenCalledTimes(1)
+    expect(participant.sendErrorToParticipant.mock.lastCall[0]).toBe(destination)
   })
 })