@mojaloop/central-services-shared 18.4.0 → 18.5.0-snapshot.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/central-services-shared",
-  "version": "18.4.0",
+  "version": "18.5.0-snapshot.0",
   "description": "Shared code for mojaloop central services",
   "license": "Apache-2.0",
   "author": "ModusBox",

package/src/enums/http.js

@@ -34,10 +34,6 @@
 
 const Headers = {
   FSPIOP: {
-    SWITCH: {
-      regex: /^switch$/i,
-      value: 'switch'
-    },
     SOURCE: 'fspiop-source',
     DESTINATION: 'fspiop-destination',
     HTTP_METHOD: 'fspiop-http-method',
@@ -127,7 +123,7 @@ const RestMethods = {
 const HeaderResources = {
   PARTICIPANTS: 'participants',
   ORACLE: 'oracle',
-  SWITCH: 'switch',
+  // SWITCH: 'switch', // @note: hub/switch name should now be passed in via service config.
   TRANSFERS: 'transfers',
   FX_TRANSFERS: 'fxTransfers',
   QUOTES: 'quotes',

package/src/util/endpoints.js

@@ -41,6 +41,8 @@ const Metrics = require('@mojaloop/central-services-metrics')
 let client
 let policy
 let switchEndpoint
+let hubName
+let hubNameRegex
 
 /**
  * @function fetchEndpoints
@@ -58,10 +60,22 @@ const fetchEndpoints = async (fsp) => {
   ).startTimer()
   try {
     Logger.isDebugEnabled && Logger.debug(`[fsp=${fsp}] ~ participantEndpointCache::fetchEndpoints := Refreshing the cache for FSP: ${fsp}`)
-    const defaultHeaders = Http.SwitchDefaultHeaders(Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.PARTICIPANTS, Enum.Http.HeaderResources.SWITCH)
+    if (!hubName) {
+      throw Error('"hubName" is not initialized. Initialize the cache first.')
+    }
+    if (!hubNameRegex) {
+      throw Error('"hubNameRegex" is not initialized. Initialize the cache first.')
+    }
+    const defaultHeaders = Http.SwitchDefaultHeaders(hubName, Enum.Http.HeaderResources.PARTICIPANTS, hubName)
     const url = Mustache.render(switchEndpoint + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp })
     Logger.isDebugEnabled && Logger.debug(`[fsp=${fsp}] ~ participantEndpointCache::fetchEndpoints := URL for FSP: ${url}`)
-    const response = await request.sendRequest(url, defaultHeaders, Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.SWITCH)
+    const response = await request.sendRequest({
+      url,
+      headers: defaultHeaders,
+      source: hubName,
+      destination: hubName,
+      hubNameRegex
+    })
     Logger.isDebugEnabled && Logger.debug(`[fsp=${fsp}] ~ Model::participantEndpoint::fetchEndpoints := successful with body: ${JSON.stringify(response.data)}`)
     const endpoints = response.data
     const endpointMap = {}
@@ -88,11 +102,11 @@ const fetchEndpoints = async (fsp) => {
  * @function initializeCache
  *
  * @description This initializes the cache for endpoints
- *  @param {object} policyOptions The Endpoint_Cache_Config for the Cache being stored https://hapi.dev/module/catbox/api/?v=12.1.1#policy
-
+ * @param {object} policyOptions The Endpoint_Cache_Config for the Cache being stored https://hapi.dev/module/catbox/api/?v=12.1.1#policy
+ * @param {object} config The config object containing paramters used for the request function
  * @returns {boolean} Returns true on successful initialization of the cache, throws error on failures
  */
-exports.initializeCache = async (policyOptions) => {
+exports.initializeCache = async (policyOptions, config) => {
   try {
     Logger.isDebugEnabled && Logger.debug(`participantEndpointCache::initializeCache::start::clientOptions - ${JSON.stringify(clientOptions)}`)
     client = new Catbox.Client(CatboxMemory, clientOptions)
@@ -101,6 +115,8 @@ exports.initializeCache = async (policyOptions) => {
     Logger.isDebugEnabled && Logger.debug(`participantEndpointCache::initializeCache::start::policyOptions - ${JSON.stringify(policyOptions)}`)
     policy = new Catbox.Policy(policyOptions, client, partition)
     Logger.isDebugEnabled && Logger.debug('participantEndpointCache::initializeCache::Cache initialized successfully')
+    hubName = config.hubName
+    hubNameRegex = config.hubNameRegex
     return true
   } catch (err) {
     Logger.isErrorEnabled && Logger.error(`participantEndpointCache::Cache error:: ERROR:'${err}'`)

package/src/util/headers/transformer.js

@@ -153,7 +153,7 @@ const transformHeaders = (headers, config) => {
       case (ENUM.Headers.FSPIOP.HTTP_METHOD):
         // Check to see if we find a regex match the source header containing the switch name.
         // If so we include the signature otherwise we remove it.
-        if (headers[normalizedKeys[ENUM.Headers.FSPIOP.SOURCE]].match(ENUM.Headers.FSPIOP.SWITCH.regex) === null) {
+        if (headers[normalizedKeys[ENUM.Headers.FSPIOP.SOURCE]].match(config.hubNameRegex) === null) {
           if (config.httpMethod.toLowerCase() === headerValue.toLowerCase()) {
             // HTTP Methods match, and thus no change is required
             normalizedHeaders[headerKey] = headerValue
@@ -178,7 +178,7 @@ const transformHeaders = (headers, config) => {
         normalizedHeaders[headerKey] = config.destinationFsp
         break
       case (ENUM.Headers.GENERAL.ACCEPT.value):
-        if (!ENUM.Headers.FSPIOP.SWITCH.regex.test(config.sourceFsp)) {
+        if (!config.hubNameRegex.test(config.sourceFsp)) {
           normalizedHeaders[headerKey] = headerValue
           break
         }
@@ -188,7 +188,7 @@ const transformHeaders = (headers, config) => {
         normalizedHeaders[headerKey] = `application/vnd.interoperability.${resourceType}+json;version=${acceptVersion}`
         break
       case (ENUM.Headers.GENERAL.CONTENT_TYPE.value):
-        if (!ENUM.Headers.FSPIOP.SWITCH.regex.test(config.sourceFsp)) {
+        if (!config.hubNameRegex.test(config.sourceFsp)) {
           normalizedHeaders[headerKey] = headerValue
           break
         }
@@ -202,7 +202,7 @@ const transformHeaders = (headers, config) => {
     }
   }
 
-  if (normalizedHeaders[normalizedKeys[ENUM.Headers.FSPIOP.SOURCE]].match(ENUM.Headers.FSPIOP.SWITCH.regex) !== null) {
+  if (normalizedHeaders[normalizedKeys[ENUM.Headers.FSPIOP.SOURCE]].match(config.hubNameRegex) !== null) {
     // Check to see if we find a regex match the source header containing the switch name.
     // If so we remove the signature added by default.
     delete normalizedHeaders[normalizedKeys[ENUM.Headers.FSPIOP.SIGNATURE]]

package/src/util/kafka/index.js

@@ -305,7 +305,7 @@ const proceed = async (defaultKafkaConfig, params, opts) => {
   }
   if (fromSwitch) {
     message.value.to = message.value.from
-    message.value.from = Enum.Http.Headers.FSPIOP.SWITCH.value
+    message.value.from = opts.hubName
     if (message.value.content.headers) {
       message.value.content.headers[Enum.Http.Headers.FSPIOP.SOURCE] = message.value.from
       message.value.content.headers[Enum.Http.Headers.FSPIOP.DESTINATION] = message.value.to

package/src/util/participants.js

@@ -39,10 +39,14 @@ const Metrics = require('@mojaloop/central-services-metrics')
 let client
 let policy
 let switchEndpoint
+let hubName
+let hubNameRegex
 
 /**
 * @function fetchParticipant
 *
+* @param {string} fsp The fsp id
+* @param {object} options The options for the request function
 * @description This populates the cache of participants
 *
 * @returns {object} participant Returns the object containing the participants
@@ -55,10 +59,22 @@ const fetchParticipant = async (fsp) => {
   ).startTimer()
   try {
     Logger.isDebugEnabled && Logger.debug('participantCache::fetchParticipant := Refreshing participant cache')
-    const defaultHeaders = Http.SwitchDefaultHeaders(Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.PARTICIPANTS, Enum.Http.HeaderResources.SWITCH)
+    if (!hubName) {
+      throw Error('"hubName" is not initialized. Initialize the cache first.')
+    }
+    if (!hubNameRegex) {
+      throw Error('"hubNameRegex" is not initialized. Initialize the cache first.')
+    }
+    const defaultHeaders = Http.SwitchDefaultHeaders(hubName, Enum.Http.HeaderResources.PARTICIPANTS, hubName)
     const url = Mustache.render(switchEndpoint + Enum.EndPoints.FspEndpointTemplates.PARTICIPANTS_GET, { fsp })
     Logger.isDebugEnabled && Logger.debug(`participantCache::fetchParticipant := URL: ${url}`)
-    const response = await request.sendRequest(url, defaultHeaders, Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.SWITCH)
+    const response = await request.sendRequest({
+      url,
+      headers: defaultHeaders,
+      source: hubName,
+      destination: hubName,
+      hubNameRegex
+    })
     const participant = response.data
     histTimer({ success: true })
     return participant
@@ -72,11 +88,11 @@ const fetchParticipant = async (fsp) => {
 * @function initializeCache
 *
 * @description This initializes the cache for endpoints
-*  @param {object} policyOptions The Endpoint_Cache_Config for the Cache being stored https://hapi.dev/module/catbox/api/?v=12.1.1#policy
-
+* @param {object} policyOptions The Endpoint_Cache_Config for the Cache being stored https://hapi.dev/module/catbox/api/?v=12.1.1#policy
+* @param {object} config The config object containing paramters used for the request function
 * @returns {boolean} Returns true on successful initialization of the cache, throws error on failures
 */
-exports.initializeCache = async (policyOptions) => {
+exports.initializeCache = async (policyOptions, config) => {
   try {
     Logger.isDebugEnabled && Logger.debug(`participantCache::initializeCache::start::clientOptions - ${JSON.stringify(clientOptions)}`)
     client = new Catbox.Client(CatboxMemory, clientOptions)
@@ -85,6 +101,8 @@ exports.initializeCache = async (policyOptions) => {
     Logger.isDebugEnabled && Logger.debug(`participantCache::initializeCache::start::policyOptions - ${JSON.stringify(policyOptions)}`)
     policy = new Catbox.Policy(policyOptions, client, partition)
     Logger.isDebugEnabled && Logger.debug('participantCache::initializeCache::Cache initialized successfully')
+    hubName = config.hubName
+    hubNameRegex = config.hubNameRegex
     return true
   } catch (err) {
     Logger.isErrorEnabled && Logger.error(`participantCache::Cache error:: ERROR:'${err}'`)

package/src/util/request.js

@@ -68,7 +68,7 @@ request.defaults.httpAgent.toJSON = () => ({})
  *@return {Promise<any>} The response for the request being sent or error object with response included
  */
 
-const sendRequest = async (
+const sendRequest = async ({
   url,
   headers,
   source,
@@ -79,8 +79,9 @@ const sendRequest = async (
   span = undefined,
   jwsSigner = undefined,
   protocolVersions = undefined,
-  axiosRequestOptionsOverride = {}
-) => {
+  axiosRequestOptionsOverride = {},
+  hubNameRegex
+}) => {
   const histTimerEnd = Metrics.getHistogram(
     'sendRequest',
     `sending ${method} request to: ${url} from: ${source} to: ${destination}`,
@@ -100,7 +101,8 @@ const sendRequest = async (
       httpMethod: method,
       sourceFsp: source,
       destinationFsp: destination,
-      protocolVersions
+      protocolVersions,
+      hubNameRegex
     })
     requestOptions = {
       url,

package/test/unit/headers/transformer.test.js

@@ -36,7 +36,8 @@ const Helper = require('../../util/helper')
 const headerConfigExample = {
   httpMethod: 'PUT',
   sourceFsp: 'switch',
-  destinationFsp: 'FSPDest'
+  destinationFsp: 'FSPDest',
+  hubNameRegex: /^Hub$/i
 }
 
 const headerDataInputExample = {
@@ -110,7 +111,8 @@ Test('Transfer Transformer tests', TransformerTest => {
       const headerConfig = {
         httpMethod: 'PUT',
         sourceFsp: 'switch',
-        destinationFsp: 'FSPDest'
+        destinationFsp: 'FSPDest',
+        hubNameRegex: /^Hub$/i
       }
 
       const headerData = Util.clone(headerDataInputExample)
@@ -131,12 +133,13 @@ Test('Transfer Transformer tests', TransformerTest => {
 
       const headerConfig = {
         httpMethod: 'PUT',
-        sourceFsp: 'switch',
+        sourceFsp: 'Hub',
         destinationFsp: 'FSPDest',
         protocolVersions: {
           content: '1.1',
           accept: '1'
-        }
+        },
+        hubNameRegex: /^Hub$/i
       }
 
       const headerData = Util.clone(headerDataInputExample)

package/test/unit/util/endpoints.test.js

@@ -13,13 +13,16 @@ const Config = require('../../util/config')
 const Http = require(`${src}/util`).Http
 const Enum = require(`${src}`).Enum
 const Helper = require('../../util/helper')
-const FSPIOP_CALLBACK_URL_TRANSFER_PUT = Enum.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_TRANSFER_PUT
+const FSPIOP_CALLBACK_URL_TRANSFER_PUT =
+  Enum.EndPoints.FspEndpointTypes.FSPIOP_CALLBACK_URL_TRANSFER_PUT
 const Metrics = require('@mojaloop/central-services-metrics')
 
-Test('Cache Test', cacheTest => {
+Test('Cache Test', (cacheTest) => {
   let sandbox
+  const hubName = 'Hub'
+  const hubNameRegex = /^Hub$/i
 
-  cacheTest.beforeEach(async test => {
+  cacheTest.beforeEach(async (test) => {
     Metrics.setup({
       INSTRUMENTATION: {
         METRICS: {
@@ -43,7 +46,7 @@ Test('Cache Test', cacheTest => {
     test.end()
   })
 
-  cacheTest.afterEach(async test => {
+  cacheTest.afterEach(async (test) => {
     sandbox.restore()
     test.end()
   })
@@ -51,45 +54,38 @@ Test('Cache Test', cacheTest => {
   cacheTest.test('getEndpoint should', async (getEndpointTest) => {
     getEndpointTest.test('return the endpoint', async (test) => {
       const fsp = 'fsp'
-      const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp })
+      const url = Mustache.render(
+        Config.ENDPOINT_SOURCE_URL +
+          Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET,
+        { fsp }
+      )
       const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
-      const expected = 'http://localhost:1080/transfers/97b01bd3-b223-415b-b37b-ab5bef9bdbed'
+      const expected =
+        'http://localhost:1080/transfers/97b01bd3-b223-415b-b37b-ab5bef9bdbed'
 
-      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).returns(Promise.resolve(Helper.getEndPointsResponse))
-
-      try {
-        const result = await Cache.getEndpoint(Config.ENDPOINT_SOURCE_URL, fsp, endpointType, { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' })
-        test.equal(result, expected, 'The results match')
-
-        const result2 = await Cache.getEndpoint(Config.ENDPOINT_SOURCE_URL, fsp, endpointType, { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' }, { path: '/additionalPath' })
-        test.equal(result2, `${expected}/additionalPath`, 'The results match')
-
-        await Cache.stopCache()
-        test.end()
-      } catch (err) {
-        test.fail('Error thrown', err)
-        test.end()
-      }
-    })
-
-    getEndpointTest.test('return the endpoint if catbox returns decoratedValue object', async (test) => {
-      const fsp = 'fsp'
-      const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp })
-      const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
-      const expected = 'http://localhost:1080/transfers/97b01bd3-b223-415b-b37b-ab5bef9bdbed'
-
-      await Cache.initializeCache({
-        ...Config.ENDPOINT_CACHE_CONFIG,
-        getDecoratedValue: true
+      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, {
+        hubName, hubNameRegex
       })
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).returns(Promise.resolve(Helper.getEndPointsResponse))
+      request.sendRequest
+        .withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex })
+        .returns(Promise.resolve(Helper.getEndPointsResponse))
 
       try {
-        const result = await Cache.getEndpoint(Config.ENDPOINT_SOURCE_URL, fsp, endpointType, { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' })
+        const result = await Cache.getEndpoint(
+          Config.ENDPOINT_SOURCE_URL,
+          fsp,
+          endpointType,
+          { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' }
+        )
         test.equal(result, expected, 'The results match')
 
-        const result2 = await Cache.getEndpoint(Config.ENDPOINT_SOURCE_URL, fsp, endpointType, { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' }, { path: '/additionalPath' })
+        const result2 = await Cache.getEndpoint(
+          Config.ENDPOINT_SOURCE_URL,
+          fsp,
+          endpointType,
+          { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' },
+          { path: '/additionalPath' }
+        )
         test.equal(result2, `${expected}/additionalPath`, 'The results match')
 
         await Cache.stopCache()
@@ -100,54 +96,145 @@ Test('Cache Test', cacheTest => {
       }
     })
 
-    getEndpointTest.test('return the endpoint if catbox returns decoratedValue object', async (test) => {
-      const fsp = 'fsp'
-      const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp })
-      const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
-      const expected = 'http://localhost:1080/transfers/97b01bd3-b223-415b-b37b-ab5bef9bdbed'
-
-      await Cache.initializeCache({
-        ...Config.ENDPOINT_CACHE_CONFIG,
-        getDecoratedValue: true
-      })
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).returns(Promise.resolve(Helper.getEndPointsResponse))
-
-      try {
-        const result = await Cache.getEndpoint(Config.ENDPOINT_SOURCE_URL, fsp, endpointType, { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' })
-        test.equal(result, expected, 'The results match')
+    getEndpointTest.test(
+      'return the endpoint if catbox returns decoratedValue object',
+      async (test) => {
+        const fsp = 'fsp'
+        const url = Mustache.render(
+          Config.ENDPOINT_SOURCE_URL +
+            Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET,
+          { fsp }
+        )
+        const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
+        const expected =
+          'http://localhost:1080/transfers/97b01bd3-b223-415b-b37b-ab5bef9bdbed'
+
+        await Cache.initializeCache(
+          { ...Config.ENDPOINT_CACHE_CONFIG, getDecoratedValue: true },
+          { hubName, hubNameRegex }
+        )
+        request.sendRequest
+          .withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex })
+          .returns(Promise.resolve(Helper.getEndPointsResponse))
+
+        try {
+          const result = await Cache.getEndpoint(
+            Config.ENDPOINT_SOURCE_URL,
+            fsp,
+            endpointType,
+            { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' }
+          )
+          test.equal(result, expected, 'The results match')
+
+          const result2 = await Cache.getEndpoint(
+            Config.ENDPOINT_SOURCE_URL,
+            fsp,
+            endpointType,
+            { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' },
+            { path: '/additionalPath' }
+          )
+          test.equal(
+            result2,
+            `${expected}/additionalPath`,
+            'The results match'
+          )
+
+          await Cache.stopCache()
+          test.end()
+        } catch (err) {
+          test.fail('Error thrown', err)
+          test.end()
+        }
+      }
+    )
+
+    getEndpointTest.test(
+      'return the endpoint if catbox returns decoratedValue object',
+      async (test) => {
+        const fsp = 'fsp'
+        const url = Mustache.render(
+          Config.ENDPOINT_SOURCE_URL +
+            Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET,
+          { fsp }
+        )
+        const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
+        const expected =
+          'http://localhost:1080/transfers/97b01bd3-b223-415b-b37b-ab5bef9bdbed'
+
+        await Cache.initializeCache(
+          { ...Config.ENDPOINT_CACHE_CONFIG, getDecoratedValue: true },
+          { hubName, hubNameRegex }
+        )
+        request.sendRequest
+          .withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex })
+          .returns(Promise.resolve(Helper.getEndPointsResponse))
+
+        try {
+          const result = await Cache.getEndpoint(
+            Config.ENDPOINT_SOURCE_URL,
+            fsp,
+            endpointType,
+            { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' }
+          )
+          test.equal(result, expected, 'The results match')
+          await Cache.stopCache()
+          test.end()
+        } catch (err) {
+          test.fail('Error thrown', err)
+          test.end()
+        }
+      }
+    )
+
+    getEndpointTest.test(
+      'return throw an error if array not returned in response object',
+      async (test) => {
+        const fsp = 'fsp'
+        const url = Mustache.render(
+          Config.ENDPOINT_SOURCE_URL +
+            Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET,
+          { fsp }
+        )
+        const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
+
+        await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, {
+          hubNameRegex
+        })
+        request.sendRequest
+          .withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex })
+          .returns(Promise.resolve({ data: {} }))
+
+        try {
+          await Cache.getEndpoint(
+            Config.ENDPOINT_SOURCE_URL,
+            fsp,
+            endpointType,
+            { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' }
+          )
+          test.fail('should throw error')
+        } catch (e) {
+          test.ok(e instanceof Error)
+        }
         await Cache.stopCache()
         test.end()
-      } catch (err) {
-        test.fail('Error thrown', err)
-        test.end()
       }
-    })
-
-    getEndpointTest.test('return throw an error if array not returned in response object', async (test) => {
-      const fsp = 'fsp'
-      const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp })
-      const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
-
-      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).returns(Promise.resolve({ data: {} }))
-
-      try {
-        await Cache.getEndpoint(Config.ENDPOINT_SOURCE_URL, fsp, endpointType, { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' })
-        test.fail('should throw error')
-      } catch (e) {
-        test.ok(e instanceof Error)
-      }
-      await Cache.stopCache()
-      test.end()
-    })
+    )
 
     getEndpointTest.test('throw error', async (test) => {
       const fsp = 'fsp1'
-      const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp })
+      const url = Mustache.render(
+        Config.ENDPOINT_SOURCE_URL +
+          Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET,
+        { fsp }
+      )
       const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
 
-      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).throws(new Error())
+      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, {
+        hubNameRegex
+      })
+      request.sendRequest
+        .withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex })
+        .throws(new Error())
       try {
         await Cache.getEndpoint(Config.ENDPOINT_SOURCE_URL, fsp, endpointType)
         test.fail('should throw error')
@@ -163,124 +250,177 @@ Test('Cache Test', cacheTest => {
     await getEndpointTest.end()
   })
 
-  cacheTest.test('getEndpointAndRender should', async (getEndpointAndRenderTest) => {
-    getEndpointAndRenderTest.test('return the rendered endpoint', async (test) => {
-      const fsp = 'fsp'
-      const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp })
-      const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
-      const expected = 'http://localhost:1080/transfers/97b01bd3-b223-415b-b37b-ab5bef9bdbed'
-
-      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).returns(Promise.resolve(Helper.getEndpointAndRenderResponse))
-
-      try {
-        const result = await Cache.getEndpointAndRender(
-          Config.ENDPOINT_SOURCE_URL,
-          fsp,
-          endpointType,
-          'transfers/{{transferId}}',
-          { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' })
-        test.equal(result, expected, 'The results match')
-        await Cache.stopCache()
-        test.end()
-      } catch (err) {
-        test.fail('Error thrown', err)
-        test.end()
-      }
-    })
-
-    getEndpointAndRenderTest.test('return the rendered endpoint if catbox returns decoratedValue object', async (test) => {
-      const fsp = 'fsp'
-      const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp })
-      const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
-      const expected = 'http://localhost:1080/transfers/97b01bd3-b223-415b-b37b-ab5bef9bdbed'
-
-      await Cache.initializeCache({
-        ...Config.ENDPOINT_CACHE_CONFIG,
-        getDecoratedValue: true
+  cacheTest.test(
+    'getEndpointAndRender should',
+    async (getEndpointAndRenderTest) => {
+      getEndpointAndRenderTest.test(
+        'return the rendered endpoint',
+        async (test) => {
+          const fsp = 'fsp'
+          const url = Mustache.render(
+            Config.ENDPOINT_SOURCE_URL +
+              Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET,
+            { fsp }
+          )
+          const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
+          const expected =
+            'http://localhost:1080/transfers/97b01bd3-b223-415b-b37b-ab5bef9bdbed'
+
+          await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, {
+            hubName, hubNameRegex
+          })
+          request.sendRequest
+            .withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex })
+            .returns(Promise.resolve(Helper.getEndpointAndRenderResponse))
+
+          try {
+            const result = await Cache.getEndpointAndRender(
+              Config.ENDPOINT_SOURCE_URL,
+              fsp,
+              endpointType,
+              'transfers/{{transferId}}',
+              { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' }
+            )
+            test.equal(result, expected, 'The results match')
+            await Cache.stopCache()
+            test.end()
+          } catch (err) {
+            test.fail('Error thrown', err)
+            test.end()
+          }
+        }
+      )
+
+      getEndpointAndRenderTest.test(
+        'return the rendered endpoint if catbox returns decoratedValue object',
+        async (test) => {
+          const fsp = 'fsp'
+          const url = Mustache.render(
+            Config.ENDPOINT_SOURCE_URL +
+              Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET,
+            { fsp }
+          )
+          const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
+          const expected =
+            'http://localhost:1080/transfers/97b01bd3-b223-415b-b37b-ab5bef9bdbed'
+
+          await Cache.initializeCache(
+            { ...Config.ENDPOINT_CACHE_CONFIG, getDecoratedValue: true },
+            { hubName, hubNameRegex }
+          )
+          request.sendRequest
+            .withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex })
+            .returns(Promise.resolve(Helper.getEndpointAndRenderResponse))
+
+          try {
+            const result = await Cache.getEndpointAndRender(
+              Config.ENDPOINT_SOURCE_URL,
+              fsp,
+              endpointType,
+              'transfers/{{transferId}}',
+              { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' }
+            )
+            test.equal(result, expected, 'The results match')
+            await Cache.stopCache()
+            test.end()
+          } catch (err) {
+            test.fail('Error thrown', err)
+            test.end()
+          }
+        }
+      )
+
+      getEndpointAndRenderTest.test(
+        'return throw an error if array not returned in response object',
+        async (test) => {
+          const fsp = 'fsp'
+          const url = Mustache.render(
+            Config.ENDPOINT_SOURCE_URL +
+              Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET,
+            { fsp }
+          )
+          const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
+
+          await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, { hubName, hubNameRegex })
+          request.sendRequest
+            .withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex })
+            .returns(Promise.resolve({ data: {} }))
+
+          try {
+            await Cache.getEndpointAndRender(
+              Config.ENDPOINT_SOURCE_URL,
+              fsp,
+              endpointType,
+              'transfers/{{transferId}}',
+              { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' }
+            )
+            test.fail('should throw error')
+            await Cache.stopCache()
+            test.end()
+          } catch (e) {
+            test.ok(e instanceof Error)
+            await Cache.stopCache()
+            test.end()
+          }
+        }
+      )
+
+      getEndpointAndRenderTest.test('throw error', async (test) => {
+        const fsp = 'fsp1'
+        const url = Mustache.render(
+          Config.ENDPOINT_SOURCE_URL +
+            Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET,
+          { fsp }
+        )
+        const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
+
+        await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, { hubName, hubNameRegex })
+        request.sendRequest
+          .withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex })
+          .throws(new Error())
+        try {
+          await Cache.getEndpointAndRender(
+            Config.ENDPOINT_SOURCE_URL,
+            fsp,
+            endpointType
+          )
+          test.fail('should throw error')
+          await Cache.stopCache()
+          test.end()
+        } catch (e) {
+          test.ok(e instanceof Error)
+          await Cache.stopCache()
+          test.end()
+        }
       })
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).returns(Promise.resolve(Helper.getEndpointAndRenderResponse))
-
-      try {
-        const result = await Cache.getEndpointAndRender(
-          Config.ENDPOINT_SOURCE_URL,
-          fsp,
-          endpointType,
-          'transfers/{{transferId}}',
-          { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' })
-        test.equal(result, expected, 'The results match')
-        await Cache.stopCache()
-        test.end()
-      } catch (err) {
-        test.fail('Error thrown', err)
-        test.end()
-      }
-    })
-
-    getEndpointAndRenderTest.test('return throw an error if array not returned in response object', async (test) => {
-      const fsp = 'fsp'
-      const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp })
-      const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
-
-      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).returns(Promise.resolve({ data: {} }))
-
-      try {
-        await Cache.getEndpointAndRender(
-          Config.ENDPOINT_SOURCE_URL,
-          fsp,
-          endpointType,
-          'transfers/{{transferId}}',
-          { transferId: '97b01bd3-b223-415b-b37b-ab5bef9bdbed' })
-        test.fail('should throw error')
-        await Cache.stopCache()
-        test.end()
-      } catch (e) {
-        test.ok(e instanceof Error)
-        await Cache.stopCache()
-        test.end()
-      }
-    })
 
-    getEndpointAndRenderTest.test('throw error', async (test) => {
-      const fsp = 'fsp1'
-      const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp })
-      const endpointType = FSPIOP_CALLBACK_URL_TRANSFER_PUT
-
-      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).throws(new Error())
-      try {
-        await Cache.getEndpointAndRender(Config.ENDPOINT_SOURCE_URL, fsp, endpointType)
-        test.fail('should throw error')
-        await Cache.stopCache()
-        test.end()
-      } catch (e) {
-        test.ok(e instanceof Error)
-        await Cache.stopCache()
-        test.end()
-      }
-    })
-
-    await getEndpointAndRenderTest.end()
-  })
+      await getEndpointAndRenderTest.end()
+    }
+  )
 
   cacheTest.test('initializeCache should', async (initializeCacheTest) => {
-    initializeCacheTest.test('initializeCache cache and return true', async (test) => {
-      try {
-        const result = await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
-        test.equal(result, true, 'The results match')
-        await Cache.stopCache()
-        test.end()
-      } catch (err) {
-        test.fail('Error thrown', err)
-        test.end()
+    initializeCacheTest.test(
+      'initializeCache cache and return true',
+      async (test) => {
+        try {
+          const result = await Cache.initializeCache(
+            Config.ENDPOINT_CACHE_CONFIG,
+            { hubName, hubNameRegex }
+          )
+          test.equal(result, true, 'The results match')
+          await Cache.stopCache()
+          test.end()
+        } catch (err) {
+          test.fail('Error thrown', err)
+          test.end()
+        }
       }
-    })
+    )
 
     initializeCacheTest.test('should throw error', async (test) => {
       try {
         sandbox.stub(Catbox, 'Client').throws(new Error())
-        await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
+        await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, { hubName, hubNameRegex })
         test.fail('should throw')
         test.end()
       } catch (err) {

package/test/unit/util/headers/transformer.test.js

@@ -34,7 +34,8 @@ const Util = require('../../../../src/util')
 const headerConfigExample = {
   httpMethod: 'PUT',
   sourceFsp: 'switch',
-  destinationFsp: 'FSPDest'
+  destinationFsp: 'FSPDest',
+  hubNameRegex: /^Hub$/i
 }
 
 const headerDataInputExample = {

package/test/unit/util/kafka/index.test.js

@@ -584,12 +584,12 @@ Test('Utility Test', utilityTest => {
     })
 
     proceedTest.test('produce fromSwitch and do not stop timer', async test => {
-      const opts = { fromSwitch: true, eventDetail }
+      const opts = { fromSwitch: true, eventDetail, hubName: 'Hub' }
       try {
         const result = await UtilityProxy.proceed(Config.KAFKA_CONFIG, params, opts)
         test.ok(produceGeneralMessageStub.withArgs(Config.KAFKA_CONFIG, producer, eventDetail.functionality, eventDetail.action, message.value, successState).calledOnce, 'produceGeneralMessageStub not called')
         test.equal(message.value.to, from, 'message destination set to sender')
-        test.equal(message.value.from, Enum.Http.Headers.FSPIOP.SWITCH.value, 'from set to switch')
+        test.equal(message.value.from, opts.hubName, 'from set to switch')
         test.equal(result, true, 'result returned')
       } catch (err) {
         test.fail(err.message)
@@ -599,14 +599,14 @@ Test('Utility Test', utilityTest => {
     })
 
     proceedTest.test('produce fromSwitch without headers', async test => {
-      const opts = { fromSwitch: true, eventDetail }
+      const opts = { fromSwitch: true, eventDetail, hubName: 'Hub' }
       try {
         const localParams = clone(params)
         delete localParams.message.value.content.headers
         const result = await UtilityProxy.proceed(Config.KAFKA_CONFIG, localParams, opts)
         test.ok(produceGeneralMessageStub.withArgs(Config.KAFKA_CONFIG, producer, eventDetail.functionality, eventDetail.action, localParams.message.value, successState).calledOnce, 'produceGeneralMessageStub not called')
         test.equal(localParams.message.value.to, from, 'message destination set to sender')
-        test.equal(localParams.message.value.from, Enum.Http.Headers.FSPIOP.SWITCH.value, 'from set to switch')
+        test.equal(localParams.message.value.from, opts.hubName, 'from set to switch')
         test.equal(result, true, 'result returned')
       } catch (err) {
         test.fail(err.message)

package/test/unit/util/participants.test.js

@@ -16,6 +16,8 @@ const Metrics = require('@mojaloop/central-services-metrics')
 
 Test('Participants Cache Test', participantsCacheTest => {
   let sandbox
+  const hubName = 'Hub'
+  const hubNameRegex = /^Hub$/i
 
   participantsCacheTest.beforeEach(async test => {
     Metrics.setup({
@@ -51,8 +53,8 @@ Test('Participants Cache Test', participantsCacheTest => {
       const fsp = 'fsp2'
       const expectedName = 'fsp2'
       const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANTS_GET, { fsp })
-      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).returns(Promise.resolve(Helper.getParticipantsResponseFsp2))
+      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, { hubName, hubNameRegex })
+      request.sendRequest.withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex }).returns(Promise.resolve(Helper.getParticipantsResponseFsp2))
 
       try {
         const result = await Cache.getParticipant(Config.ENDPOINT_SOURCE_URL, fsp)
@@ -69,17 +71,17 @@ Test('Participants Cache Test', participantsCacheTest => {
       const fsp = 'fsp2'
       const expectedName = 'fsp2'
       const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANTS_GET, { fsp })
-      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).returns(Promise.resolve(Helper.getParticipantsResponseFsp2))
+      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, { hubName, hubNameRegex })
+      request.sendRequest.withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex }).returns(Promise.resolve(Helper.getParticipantsResponseFsp2))
 
       try {
         const result = await Cache.getParticipant(Config.ENDPOINT_SOURCE_URL, fsp)
         test.equal(result.name, expectedName, 'The results match')
-        test.ok(request.sendRequest.calledOnceWith(url, Helper.defaultHeaders()), 'Fetch participants was called once')
+        test.ok(request.sendRequest.calledOnceWith({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex }), 'Fetch participants was called once')
 
         const resultCached = await Cache.getParticipant(Config.ENDPOINT_SOURCE_URL, fsp)
         test.equal(request.sendRequest.callCount, 1)
-        test.ok(request.sendRequest.calledOnceWith(url, Helper.defaultHeaders()), 'Fetch participants was not needlessly called')
+        test.ok(request.sendRequest.calledOnceWith({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex }), 'Fetch participants was not needlessly called')
         test.equal(resultCached.name, expectedName, 'The results match')
 
         await Cache.stopCache()
@@ -94,19 +96,19 @@ Test('Participants Cache Test', participantsCacheTest => {
       const fsp = 'fsp2'
       const expectedName = 'fsp2'
       const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANTS_GET, { fsp })
-      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).returns(Promise.resolve(Helper.getParticipantsResponseFsp2))
+      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, { hubName, hubNameRegex })
+      request.sendRequest.withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex }).returns(Promise.resolve(Helper.getParticipantsResponseFsp2))
 
       try {
         const result = await Cache.getParticipant(Config.ENDPOINT_SOURCE_URL, fsp)
         test.equal(result.name, expectedName, 'The results match')
-        test.ok(request.sendRequest.calledOnceWith(url, Helper.defaultHeaders()), 'Fetch participants was called once')
+        test.ok(request.sendRequest.calledOnceWith({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex }), 'Fetch participants was called once')
 
         await Cache.invalidateParticipantCache(fsp)
 
         const resultCached = await Cache.getParticipant(Config.ENDPOINT_SOURCE_URL, fsp)
         test.equal(request.sendRequest.callCount, 2)
-        test.ok(request.sendRequest.getCall(1).calledWith(url, Helper.defaultHeaders()), 'Fetch participants was called again')
+        test.ok(request.sendRequest.getCall(1).calledWith({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex }), 'Fetch participants was called again')
         test.equal(resultCached.name, expectedName, 'The results match')
 
         await Cache.stopCache()
@@ -124,8 +126,8 @@ Test('Participants Cache Test', participantsCacheTest => {
       await Cache.initializeCache({
         ...Config.ENDPOINT_CACHE_CONFIG,
         getDecoratedValue: true
-      })
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).returns(Promise.resolve(Helper.getParticipantsResponseFsp2))
+      }, { hubName, hubNameRegex })
+      request.sendRequest.withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex }).returns(Promise.resolve(Helper.getParticipantsResponseFsp2))
 
       try {
         const result = await Cache.getParticipant(Config.ENDPOINT_SOURCE_URL, fsp)
@@ -141,8 +143,8 @@ Test('Participants Cache Test', participantsCacheTest => {
     getParticipantTest.test('handles error from central-ledger', async (test) => {
       const fsp = 'fsp2'
       const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANTS_GET, { fsp })
-      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).returns(Promise.resolve(Helper.getParticipantsResponseError))
+      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, { hubName, hubNameRegex })
+      request.sendRequest.withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex }).returns(Promise.resolve(Helper.getParticipantsResponseError))
 
       try {
         await Cache.getParticipant(Config.ENDPOINT_SOURCE_URL, fsp)
@@ -159,8 +161,8 @@ Test('Participants Cache Test', participantsCacheTest => {
     getParticipantTest.test('throw error', async (test) => {
       const fsp = 'fsp2'
       const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANTS_GET, { fsp })
-      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
-      request.sendRequest.withArgs(url, Helper.defaultHeaders()).throws(new Error())
+      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, { hubName, hubNameRegex })
+      request.sendRequest.withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex }).throws(new Error())
 
       try {
         await Cache.getParticipant(Config.ENDPOINT_SOURCE_URL, fsp)
@@ -173,13 +175,50 @@ Test('Participants Cache Test', participantsCacheTest => {
         test.end()
       }
     })
+
+    getParticipantTest.test('throws error if hubName is not defined', async (test) => {
+      const fsp = 'fsp2'
+      const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANTS_GET, { fsp })
+      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, { hubNameRegex })
+      request.sendRequest.withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex }).returns(Promise.resolve(Helper.getParticipantsResponseFsp2))
+
+      try {
+        await Cache.getParticipant(Config.ENDPOINT_SOURCE_URL, fsp)
+        test.fail('should throw error')
+        await Cache.stopCache()
+        test.end()
+      } catch (err) {
+        test.ok(err instanceof Error)
+        await Cache.stopCache()
+        test.end()
+      }
+    })
+
+    getParticipantTest.test('throws error if hubNameRegex is not defined', async (test) => {
+      const fsp = 'fsp2'
+      const url = Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANTS_GET, { fsp })
+      await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, { hubName })
+      request.sendRequest.withArgs({ url, headers: Helper.defaultHeaders(), source: hubName, destination: hubName, hubNameRegex }).returns(Promise.resolve(Helper.getParticipantsResponseFsp2))
+
+      try {
+        await Cache.getParticipant(Config.ENDPOINT_SOURCE_URL, fsp)
+        test.fail('should throw error')
+        await Cache.stopCache()
+        test.end()
+      } catch (err) {
+        test.ok(err instanceof Error)
+        await Cache.stopCache()
+        test.end()
+      }
+    })
+
     await getParticipantTest.end()
   })
 
   participantsCacheTest.test('initializeCache should', async (participantsInitializeCacheTest) => {
     participantsInitializeCacheTest.test('initializeCache cache and return true', async (test) => {
       try {
-        const result = await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
+        const result = await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, { hubName, hubNameRegex })
         test.equal(result, true, 'The results match')
         await Cache.stopCache()
         test.end()
@@ -192,7 +231,7 @@ Test('Participants Cache Test', participantsCacheTest => {
     participantsInitializeCacheTest.test('should throw error', async (test) => {
       try {
         sandbox.stub(Catbox, 'Client').throws(new Error())
-        await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG)
+        await Cache.initializeCache(Config.ENDPOINT_CACHE_CONFIG, { hubName, hubNameRegex })
         test.fail('should throw')
         test.end()
       } catch (err) {

package/test/unit/util/request.test.js

@@ -44,6 +44,9 @@ Test('ParticipantEndpoint Model Test', modelTest => {
   let sandbox
   let request
   let Model
+  const hubName = 'Hub'
+  const hubNameRegex = /^Hub$/i
+
   Metrics.setup({
     INSTRUMENTATION: {
       METRICS: {
@@ -80,7 +83,13 @@ Test('ParticipantEndpoint Model Test', modelTest => {
       Model = proxyquire('../../../src/util/request', { axios: request })
 
       try {
-        const result = await Model.sendRequest(requestOptions.url, Helper.defaultHeaders(Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.PARTICIPANTS, Enum.Http.HeaderResources.SWITCH), Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.SWITCH)
+        const result = await Model.sendRequest({
+          url: requestOptions.url,
+          headers: Helper.defaultHeaders(hubName, Enum.Http.HeaderResources.PARTICIPANTS, hubName),
+          source: hubName,
+          destination: hubName,
+          hubNameRegex
+        })
         test.deepEqual(result, Helper.getEndPointsResponse, 'The results match')
         test.end()
       } catch (err) {
@@ -103,7 +112,16 @@ Test('ParticipantEndpoint Model Test', modelTest => {
       Model = proxyquire('../../../src/util/request', { axios: requestFunction })
 
       try {
-        const result = await Model.sendRequest(requestOptions.url, Helper.defaultHeaders(Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.PARTICIPANTS, Enum.Http.HeaderResources.SWITCH), Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.SWITCH, Enum.Http.RestMethods.GET, undefined, Enum.Http.ResponseTypes.JSON, span)
+        const result = await Model.sendRequest({
+          url: requestOptions.url,
+          headers: Helper.defaultHeaders(hubName, Enum.Http.HeaderResources.PARTICIPANTS, hubName),
+          source: hubName,
+          destination: hubName,
+          method: Enum.Http.RestMethods.GET,
+          responseType: Enum.Http.ResponseTypes.JSON,
+          span,
+          hubNameRegex
+        })
         test.deepEqual(result, Helper.getEndPointsResponse, 'The results match')
         test.end()
       } catch (err) {
@@ -131,7 +149,18 @@ Test('ParticipantEndpoint Model Test', modelTest => {
       Model = proxyquire('../../../src/util/request', { axios: requestFunction })
 
       try {
-        const result = await Model.sendRequest(requestOptions.url, Helper.defaultHeaders(Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.PARTICIPANTS, Enum.Http.HeaderResources.SWITCH), Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.SWITCH, Enum.Http.RestMethods.GET, undefined, Enum.Http.ResponseTypes.JSON, span, null, protocolVersions)
+        const result = await Model.sendRequest({
+          url: requestOptions.url,
+          headers: Helper.defaultHeaders(hubName, Enum.Http.HeaderResources.PARTICIPANTS, hubName),
+          source: hubName,
+          destination: hubName,
+          method: Enum.Http.RestMethods.GET,
+          responseType: Enum.Http.ResponseTypes.JSON,
+          span,
+          jwsSigner: null,
+          protocolVersions,
+          hubNameRegex
+        })
         test.deepEqual(result, Helper.getEndPointsResponse, 'The results match')
         test.end()
       } catch (err) {
@@ -156,7 +185,18 @@ Test('ParticipantEndpoint Model Test', modelTest => {
       Model = proxyquire('../../../src/util/request', { axios: requestFunction })
 
       try {
-        const result = await Model.sendRequest(requestOptions.url, Helper.defaultHeaders(Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.PARTICIPANTS, Enum.Http.HeaderResources.SWITCH), Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.SWITCH, Enum.Http.RestMethods.GET, undefined, Enum.Http.ResponseTypes.JSON, span, null, protocolVersions)
+        const result = await Model.sendRequest({
+          url: requestOptions.url,
+          headers: Helper.defaultHeaders(hubName, Enum.Http.HeaderResources.PARTICIPANTS, hubName),
+          source: hubName,
+          destination: hubName,
+          method: Enum.Http.RestMethods.GET,
+          responseType: Enum.Http.ResponseTypes.JSON,
+          span,
+          jwsSigner: null,
+          protocolVersions,
+          hubNameRegex
+        })
         test.deepEqual(result, Helper.getEndPointsResponse, 'The results match')
         test.end()
       } catch (err) {
@@ -177,7 +217,13 @@ Test('ParticipantEndpoint Model Test', modelTest => {
       Model = proxyquire('../../../src/util/request', { axios: request })
 
       try {
-        await Model.sendRequest(requestOptions.url, Helper.defaultHeaders(Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.PARTICIPANTS, Enum.Http.HeaderResources.SWITCH), Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.SWITCH)
+        await Model.sendRequest({
+          url: requestOptions.url,
+          headers: Helper.defaultHeaders(hubName, Enum.Http.HeaderResources.PARTICIPANTS, hubName),
+          source: hubName,
+          destination: hubName,
+          hubNameRegex
+        })
         test.fail('should throw error')
         test.end()
       } catch (e) {
@@ -204,7 +250,13 @@ Test('ParticipantEndpoint Model Test', modelTest => {
       Model = proxyquire('../../../src/util/request', { axios: request })
 
       try {
-        await Model.sendRequest(requestOptions.url, Helper.defaultHeaders(Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.PARTICIPANTS, Enum.Http.HeaderResources.SWITCH), Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.SWITCH)
+        await Model.sendRequest({
+          url: requestOptions.url,
+          headers: Helper.defaultHeaders(hubName, Enum.Http.HeaderResources.PARTICIPANTS, hubName),
+          source: hubName,
+          destination: hubName,
+          hubNameRegex
+        })
         test.fail('should throw error')
         test.end()
       } catch (e) {
@@ -225,7 +277,14 @@ Test('ParticipantEndpoint Model Test', modelTest => {
       Model = proxyquire('../../../src/util/request', { axios: request })
 
       try {
-        await Model.sendRequest(requestOptions.url, Helper.defaultHeaders(Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.PARTICIPANTS, Enum.Http.HeaderResources.SWITCH), Enum.Http.HeaderResources.SWITCH, Enum.Http.HeaderResources.SWITCH, Enum.Http.RestMethods.POST)
+        await Model.sendRequest({
+          url: requestOptions.url,
+          headers: Helper.defaultHeaders(hubName, Enum.Http.HeaderResources.PARTICIPANTS, hubName),
+          source: hubName,
+          destination: hubName,
+          method: Enum.Http.RestMethods.POST,
+          hubNameRegex
+        })
         test.fail('should throw error')
         test.end()
       } catch (e) {
@@ -252,7 +311,17 @@ Test('ParticipantEndpoint Model Test', modelTest => {
       request = sandbox.stub().returns({ status: 200 })
       Model = proxyquire('../../../src/util/request', { axios: request })
       const signSpy = Sinon.spy(jwsSigner, 'getSignature')
-      await Model.sendRequest(requestOptions.url, requestOptions.headers, Enum.Http.HeaderResources.SWITCH, fsp, requestOptions.method, payload, Enum.Http.ResponseTypes.JSON, undefined, jwsSigner)
+      await Model.sendRequest({
+        url: requestOptions.url,
+        headers: requestOptions.headers,
+        source: hubName,
+        destination: fsp,
+        method: requestOptions.method,
+        payload,
+        responseType: Enum.Http.ResponseTypes.JSON,
+        jwsSigner,
+        hubNameRegex
+      })
       test.ok(signSpy.calledOnce, 'JwsSigner.sign is called once')
       test.ok('fspiop-signature' in signSpy.getCall(0).firstArg.headers, 'The header has fspiop-signature')
       test.end()
@@ -276,7 +345,16 @@ Test('ParticipantEndpoint Model Test', modelTest => {
       request = sandbox.stub().returns({ status: 200 })
       Model = proxyquire('../../../src/util/request', { axios: request })
       const signSpy = Sinon.spy(jwsSigner, 'getSignature')
-      await Model.sendRequest(requestOptions.url, requestOptions.headers, Enum.Http.HeaderResources.SWITCH, fsp, requestOptions.method, payload, Enum.Http.ResponseTypes.JSON, undefined, undefined)
+      await Model.sendRequest({
+        url: requestOptions.url,
+        headers: requestOptions.headers,
+        source: hubName,
+        destination: fsp,
+        method: requestOptions.method,
+        payload,
+        responseType: Enum.Http.ResponseTypes.JSON,
+        hubNameRegex
+      })
       test.equal(signSpy.callCount, 0, 'JwsSigner.sign is NOT called')
       test.end()
     })