@mojaloop/central-services-shared 15.0.1 → 15.3.0-snapshot.2

package/.ncurc.json

@@ -1,5 +1,4 @@
 {
   "reject": [
-    "@mojaloop/sdk-standard-components"
   ]
 }

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [15.3.0](https://github.com/mojaloop/central-services-shared/compare/v15.2.0...v15.3.0) (2022-02-07)
+
+
+### Features
+
+* **mojaloop/project#2556:** implement patch notification for failure scenarios (following v1.1 update) ([#321](https://github.com/mojaloop/central-services-shared/issues/321)) ([92015a7](https://github.com/mojaloop/central-services-shared/commit/92015a7d9eec7e01e85eff86af5cc6e6147e5f20)), closes [mojaloop/project#2556](https://github.com/mojaloop/project/issues/2556)
+
+## [15.2.0](https://github.com/mojaloop/central-services-shared/compare/v15.1.0...v15.2.0) (2021-12-13)
+
+
+### Features
+
+* **mojaloop/#2608:** injected resource versions config for outbound requests ([#319](https://github.com/mojaloop/central-services-shared/issues/319)) ([13a3d9d](https://github.com/mojaloop/central-services-shared/commit/13a3d9dc8ab8d4815db2aea22563317e3670a19b)), closes [mojaloop/#2608](https://github.com/mojaloop/central-services-shared/issues/2608)
+
+## [15.1.0](https://github.com/mojaloop/central-services-shared/compare/v15.0.1...v15.1.0) (2021-11-17)
+
+
+### Features
+
+* add a new action enum for `RESERVED_ABORTED` ([#317](https://github.com/mojaloop/central-services-shared/issues/317)) ([0e743b8](https://github.com/mojaloop/central-services-shared/commit/0e743b82a90dd0c97ce3c72454621c191d2a6675))
+
 ### [15.0.1](https://github.com/mojaloop/central-services-shared/compare/v15.0.0...v15.0.1) (2021-11-08)
 
 

package/audit-resolve.json

@@ -24,6 +24,75 @@
       "decision": "ignore",
       "madeAt": 1636372055094,
       "expiresAt": 1638964045850
+    },
+    "1004809|widdershins>openapi-sampler>json-pointer": {
+      "decision": "ignore",
+      "madeAt": 1636956486789,
+      "expiresAt": 1639548471465
+    },
+    "1004812|widdershins>swagger2openapi>better-ajv-errors>jsonpointer": {
+      "decision": "ignore",
+      "madeAt": 1636956491233,
+      "expiresAt": 1639548471465
+    },
+    "1004812|widdershins>swagger2openapi>oas-validator>better-ajv-errors>jsonpointer": {
+      "decision": "ignore",
+      "madeAt": 1636956491233,
+      "expiresAt": 1639548471465
+    },
+    "1004854|widdershins>openapi-sampler>json-pointer": {
+      "decision": "ignore",
+      "madeAt": 1644227612906,
+      "expiresAt": 1646819457744
+    },
+    "1004869|widdershins>swagger2openapi>better-ajv-errors>jsonpointer": {
+      "decision": "ignore",
+      "madeAt": 1644227615371,
+      "expiresAt": 1646819457744
+    },
+    "1004869|widdershins>swagger2openapi>oas-validator>better-ajv-errors>jsonpointer": {
+      "decision": "ignore",
+      "madeAt": 1644227615371,
+      "expiresAt": 1646819457744
+    },
+    "1004946|widdershins>yargs>string-width>strip-ansi>ansi-regex": {
+      "decision": "ignore",
+      "madeAt": 1644227616947,
+      "expiresAt": 1646819457744
+    },
+    "1004946|widdershins>yargs>cliui>string-width>strip-ansi>ansi-regex": {
+      "decision": "ignore",
+      "madeAt": 1644227616947,
+      "expiresAt": 1646819457744
+    },
+    "1005383|shins>sanitize-html": {
+      "decision": "ignore",
+      "madeAt": 1644227618453,
+      "expiresAt": 1646819457744
+    },
+    "1005384|shins>sanitize-html": {
+      "decision": "ignore",
+      "madeAt": 1644227618454,
+      "expiresAt": 1646819457744
+    },
+    "1005534|widdershins>yargs>yargs-parser": {
+      "decision": "ignore",
+      "madeAt": 1644227619978,
+      "expiresAt": 1646819457744
+    },
+    "1006899|widdershins>node-fetch": {
+      "decision": "fix",
+      "madeAt": 1644227510867
+    },
+    "1006846|shins>sanitize-html>postcss": {
+      "decision": "ignore",
+      "madeAt": 1644227621510,
+      "expiresAt": 1646819457744
+    },
+    "1006886|shins>markdown-it": {
+      "decision": "ignore",
+      "madeAt": 1644227622831,
+      "expiresAt": 1646819457744
     }
   },
   "rules": {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/central-services-shared",
-  "version": "15.0.1",
+  "version": "15.3.0-snapshot.2",
   "description": "Shared code for mojaloop central services",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -48,16 +48,16 @@
   "dependencies": {
     "@hapi/catbox": "11.1.1",
     "@hapi/catbox-memory": "5.0.1",
-    "axios": "0.24.0",
+    "axios": "0.25.0",
     "clone": "2.1.2",
-    "dotenv": "10.0.0",
+    "dotenv": "16.0.0",
     "env-var": "7.1.1",
     "event-stream": "4.0.1",
     "immutable": "4.0.0",
     "lodash": "4.17.21",
     "mustache": "4.2.0",
-    "openapi-backend": "5.0.0",
-    "raw-body": "2.4.1",
+    "openapi-backend": "5.2.0",
+    "raw-body": "2.4.2",
     "rc": "1.2.8",
     "shins": "2.6.0",
     "uuid4": "2.0.2",
@@ -72,22 +72,22 @@
     "@mojaloop/central-services-metrics": "11.0.0",
     "@mojaloop/event-sdk": "10.7.1",
     "@mojaloop/sdk-standard-components": "10.3.2",
-    "ajv": "8.6.3",
-    "ajv-keywords": "5.0.0",
+    "ajv": "8.10.0",
+    "ajv-keywords": "5.1.0",
     "base64url": "3.0.1",
     "chance": "1.1.8",
     "npm-audit-resolver": "2.3.1",
-    "npm-check-updates": "12.0.0",
+    "npm-check-updates": "12.2.1",
     "nyc": "15.1.0",
     "pre-commit": "1.2.2",
     "proxyquire": "2.1.3",
-    "rewire": "5.0.0",
-    "sinon": "12.0.1",
+    "rewire": "6.0.0",
+    "sinon": "13.0.1",
     "standard": "16.0.4",
     "standard-version": "9.3.2",
     "tap-spec": "^5.0.0",
     "tap-xunit": "2.4.1",
-    "tape": "5.3.1",
+    "tape": "5.5.0",
     "tapes": "4.1.0"
   },
   "peerDependencies": {
@@ -95,8 +95,8 @@
     "@mojaloop/central-services-logger": "10.6.2",
     "@mojaloop/central-services-metrics": "11.0.0",
     "@mojaloop/event-sdk": "10.7.1",
-    "ajv": "8.6.3",
-    "ajv-keywords": "5.0.0"
+    "ajv": "8.10.0",
+    "ajv-keywords": "5.1.0"
   },
   "peerDependenciesMeta": {
     "@mojaloop/central-services-error-handling": {

package/src/enums/events.js

@@ -93,6 +93,10 @@ const Event = {
     RECORD_FUNDS_OUT_PREPARE_RESERVE: 'recordFundsOutPrepareReserve',
     REJECT: 'reject',
     RESOLVE: 'resolve',
+
+    // The Transfer was marked as RESERVED by the payee DFSP
+    // and was then aborted by the switch
+    RESERVED_ABORTED: 'reserved-aborted',
     REQUEST: 'request',
     RESERVE: 'reserve',
     SETTLEMENT_WINDOW: 'settlement-window',

package/src/enums/kafka.js

@@ -150,6 +150,10 @@ const TopicMap = {
       functionality: transferEventType.NOTIFICATION,
       action: transferEventAction.EVENT
     },
+    'reserved-aborted': {
+      functionality: transferEventType.NOTIFICATION,
+      action: transferEventAction.EVENT
+    },
     'settlement-window': {
       functionality: transferEventType.NOTIFICATION,
       action: transferEventAction.EVENT

package/src/index.d.ts

@@ -260,6 +260,7 @@ declare namespace CentralServicesShared {
   enum EventActionEnum {
     ABORT = 'abort',
     ABORT_DUPLICATE = 'abort-duplicate',
+    ABORT_VALIDATION = 'abort-validation',
     ACCEPT = 'accept',
     BULK_ABORT = 'bulk-abort',
     BULK_COMMIT = 'bulk-commit',
@@ -294,6 +295,7 @@ declare namespace CentralServicesShared {
     RESOLVE = 'resolve',
     REQUEST = 'request',
     RESERVE = 'reserve',
+    RESERVED_ABORTED = 'reserved-aborted',
     SETTLEMENT_WINDOW = 'settlement-window',
     TIMEOUT_RECEIVED = 'timeout-received',
     TIMEOUT_RESERVED = 'timeout-reserved',
@@ -317,6 +319,7 @@ declare namespace CentralServicesShared {
         Action: {
           ABORT: EventActionEnum.ABORT;
           ABORT_DUPLICATE: EventActionEnum.ABORT_DUPLICATE;
+          ABORT_VALIDATION: EventActionEnum.ABORT_VALIDATION;
           ACCEPT: EventActionEnum.ACCEPT;
           BULK_ABORT: EventActionEnum.BULK_ABORT;
           BULK_COMMIT: EventActionEnum.BULK_COMMIT;
@@ -351,6 +354,7 @@ declare namespace CentralServicesShared {
           RESOLVE: EventActionEnum.RESOLVE;
           REQUEST: EventActionEnum.REQUEST;
           RESERVE: EventActionEnum.RESERVE;
+          RESERVED_ABORTED: EventActionEnum.RESERVED_ABORTED;
           SETTLEMENT_WINDOW: EventActionEnum.SETTLEMENT_WINDOW;
           TIMEOUT_RECEIVED: EventActionEnum.TIMEOUT_RECEIVED;
           TIMEOUT_RESERVED: EventActionEnum.TIMEOUT_RESERVED;
@@ -399,8 +403,13 @@ declare namespace CentralServicesShared {
     getEndpointAndRender(switchUrl: string, fsp: string, endpointType: FspEndpointTypesEnum, path: string, options?: any): Promise<string>
   }
 
+  interface ProtocolVersionsType {
+    content: string,
+    accept: string
+  }
+  
   interface Request {
-    sendRequest(url: string, headers: HapiUtil.Dictionary<string>, source: string, destination: string, method?: RestMethodsEnum, payload?: any, responseType?: string, span?: any, jwsSigner?: any): Promise<any>
+    sendRequest(url: string, headers: HapiUtil.Dictionary<string>, source: string, destination: string, method?: RestMethodsEnum, payload?: any, responseType?: string, span?: any, jwsSigner?: any, protocolVersions?: ProtocolVersionsType): Promise<any>
   }
 
   interface Kafka {

package/src/util/headers/transformer.js

@@ -30,12 +30,36 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
 
 const resourceVersions = require('../helpers').resourceVersions
 
-const regexForContentAndAcceptHeaders = /(application\/vnd\.interoperability\.)(\w*)+(\+json\s{0,1};\s{0,1}version=)(.*)/
-
 /**
  * @module src/headers/transformer
  */
 
+const regexForContentAndAcceptHeaders = /(application\/vnd\.interoperability\.)(\w*)+(\+json\s{0,1};\s{0,1}version=)(.*)/
+
+/**
+* @function getResourceInfoFromHeader
+*
+* @description This will parse either a FSPIOP Content-Type or Accept header and return an object containing the resourceType and applicable version
+*
+* @typedef ResourceInfo
+* @type {object}
+* @property {string} resourceType - resource parsed from the headerValue.
+* @property {string} version - version parsed from the headerValue.
+*
+* @param {string} headerValue - the http header from the request, thus must be either an FSPIOP Content-Type or Accept header.
+*
+* @returns {ResourceInfo} Returns resourceInfo object. If the headerValue was not parsed correctly, an empty object {} will be returned.
+*/
+const getResourceInfoFromHeader = (headerValue) => {
+  const result = {}
+  const regex = regexForContentAndAcceptHeaders.exec(headerValue)
+  if (regex) {
+    if (regex[2]) result.resourceType = regex[2]
+    if (regex[4]) result.version = regex[4]
+  }
+  return result
+}
+
 /**
 * @function transformHeaders
 *
@@ -45,7 +69,31 @@ const regexForContentAndAcceptHeaders = /(application\/vnd\.interoperability\.)(
 *
 * see https://nodejs.org/dist/latest-v10.x/docs/api/http.html#http_message_headers
 *
+* @typedef TransformProtocolVersions
+* @type {object}
+* @property {string} content - protocol version to be used in the ContentType HTTP Header.
+* @property {string} accept - protocol version to be used in the Accept HTTP Header.
+*
+* @typedef TransformHeadersConfig
+* @type {object}
+* @property {string} contentType - HTTP method such as "POST", "PUT", etc.
+* @property {string} accept - Source FSP Identifier.
+* @property {string} destinationFsp - Destination FSP Identifier.
+* @property {TransformProtocolVersions} protocolVersions - Config for Protocol versions to be used.
+*
+* Config supports the following parameters:
+*  config: {
+*    httpMethod: string,
+*    sourceFsp: string,
+*    destinationFsp: string,
+*    protocolVersions: {
+*      content: string,
+*      accept: string
+*    }
+*  }
+*
 * @param {object} headers - the http header from the request
+* @param {TransformHeadersConfig} headers - the http header from the request
 *
 * @returns {object} Returns the normalized headers
 */
@@ -62,8 +110,15 @@ const transformHeaders = (headers, config) => {
   const normalizedHeaders = {}
 
   // resource type for content-type and accept headers
-  const getResourceFromHeader = (headerValue) => regexForContentAndAcceptHeaders.exec(headerValue)[2]
   let resourceType
+  let acceptVersion
+  let contentVersion
+
+  // Determine the acceptVersion using the injected config
+  if (config && config.protocolVersions && config.protocolVersions.accept) acceptVersion = config.protocolVersions.accept
+
+  // Determine the contentVersion using the injected config
+  if (config && config.protocolVersions && config.protocolVersions.content) contentVersion = config.protocolVersions.content
 
   // check to see if FSPIOP-Destination header has been left out of the initial request. If so then add it.
   if (!normalizedKeys[ENUM.Headers.FSPIOP.DESTINATION]) {
@@ -127,16 +182,20 @@ const transformHeaders = (headers, config) => {
           normalizedHeaders[headerKey] = headerValue
           break
         }
-        if (!resourceType) resourceType = getResourceFromHeader(headers[headerKey])
-        normalizedHeaders[headerKey] = `application/vnd.interoperability.${resourceType}+json;version=${resourceVersions[resourceType].acceptVersion}`
+        if (!resourceType) resourceType = getResourceInfoFromHeader(headers[headerKey]).resourceType
+        // Fall back to using the legacy approach to determine the resourceVersion
+        if (resourceType && !acceptVersion) acceptVersion = resourceVersions[resourceType].acceptVersion
+        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)) {
           normalizedHeaders[headerKey] = headerValue
           break
         }
-        if (!resourceType) resourceType = getResourceFromHeader(headers[headerKey])
-        normalizedHeaders[headerKey] = `application/vnd.interoperability.${resourceType}+json;version=${resourceVersions[resourceType].contentVersion}`
+        if (!resourceType) resourceType = getResourceInfoFromHeader(headers[headerKey]).resourceType
+        // Fall back to using the legacy approach to determine the resourceVersion
+        if (resourceType && !contentVersion) contentVersion = resourceVersions[resourceType].contentVersion
+        normalizedHeaders[headerKey] = `application/vnd.interoperability.${resourceType}+json;version=${contentVersion}`
         break
       default:
         normalizedHeaders[headerKey] = headerValue
@@ -157,5 +216,6 @@ const transformHeaders = (headers, config) => {
 }
 
 module.exports = {
+  getResourceInfoFromHeader,
   transformHeaders
 }

package/src/util/kafka/index.js

@@ -327,5 +327,8 @@ module.exports = {
   produceParticipantMessage,
   produceGeneralMessage,
   commitMessageSync,
-  proceed
+  proceed,
+
+  // exported for testing purposes:
+  _getFunctionalityAction: getFunctionalityAction
 }

package/src/util/request.js

@@ -43,20 +43,26 @@ delete request.defaults.headers.common.Accept
  *
  * @description sends a request to url
  *
+ * @typedef SendRequestProtocolVersions
+ * @type {object}
+ * @property {string} content - protocol version to be used in the ContentType HTTP Header.
+ * @property {string} accept - protocol version to be used in the Accept HTTP Header.
+ *
  * @param {string} url the endpoint for the service you require
  * @param {object} headers the http headers
  * @param {string} method http method being requested i.e. GET, POST, PUT
  * @param {string} source id for which callback is being sent from
  * @param {string} destination id for which callback is being sent
- * @param {object} payload the body of the request being sent
+ * @param {object | undefined} payload the body of the request being sent
  * @param {string} responseType the type of the response object
- * @param {object} span a span for event logging if this request is within a span
- * @param {object} jwsSigner the jws signer for signing the requests
+ * @param {object | undefined} span a span for event logging if this request is within a span
+ * @param {object | undefined} jwsSigner the jws signer for signing the requests
+ * @param {SendRequestProtocolVersions | undefined} protocolVersions the config for Protocol versions to be used
  *
- *@return {object} The response for the request being sent or error object with response included
+ *@return {Promise<any>} The response for the request being sent or error object with response included
  */
 
-const sendRequest = async (url, headers, source, destination, method = enums.Http.RestMethods.GET, payload = undefined, responseType = enums.Http.ResponseTypes.JSON, span = undefined, jwsSigner = undefined) => {
+const sendRequest = async (url, headers, source, destination, method = enums.Http.RestMethods.GET, payload = undefined, responseType = enums.Http.ResponseTypes.JSON, span = undefined, jwsSigner = undefined, protocolVersions = undefined) => {
   const histTimerEnd = !!Metrics.isInitiated() && Metrics.getHistogram(
     'sendRequest',
     `sending ${method} request to: ${url} from: ${source} to: ${destination}`,
@@ -75,7 +81,8 @@ const sendRequest = async (url, headers, source, destination, method = enums.Htt
     const transformedHeaders = Headers.transformHeaders(headers, {
       httpMethod: method,
       sourceFsp: source,
-      destinationFsp: destination
+      destinationFsp: destination,
+      protocolVersions
     })
     requestOptions = {
       url,

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

@@ -31,6 +31,7 @@ const Sinon = require('sinon')
 const Transformer = require('../../../src/util').Headers
 const Enum = require('../../../src/enums')
 const Util = require('../../../src/util')
+const Helper = require('../../util/helper')
 
 const headerConfigExample = {
   httpMethod: 'PUT',
@@ -67,6 +68,30 @@ Test('Transfer Transformer tests', TransformerTest => {
     t.end()
   })
 
+  TransformerTest.test('Transformer.getResourceInfoFromHeaderTest() should', getResourceInfoFromHeaderTest => {
+    getResourceInfoFromHeaderTest.test('parse FSPIOP Content-Type example correctly', async test => {
+      const result = Transformer.getResourceInfoFromHeader(headerDataInputExample['Content-Type'])
+      test.equal(headerDataInputExample['Content-Type'], Helper.generateProtocolHeader(result.resourceType, result.version))
+      test.end()
+    })
+
+    getResourceInfoFromHeaderTest.test('return an empty result with standard application/json', async test => {
+      const contentType = 'application/json'
+      const result = Transformer.getResourceInfoFromHeader(contentType)
+      test.same(result, {})
+      test.end()
+    })
+
+    getResourceInfoFromHeaderTest.test('return an empty result with incorrect FSPIOP Content-Type input', async test => {
+      const contentType = 'application/vnd.interoperability.transfers+json'
+      const result = Transformer.getResourceInfoFromHeader(contentType)
+      test.same(result, {})
+      test.end()
+    })
+
+    getResourceInfoFromHeaderTest.end()
+  })
+
   TransformerTest.test('Transformer.transformHeaders() should', transformHeadersTest => {
     transformHeadersTest.test('Remove all unnecessary fields from Header', async test => {
       const headerData = Util.clone(headerDataInputExample)
@@ -78,6 +103,58 @@ Test('Transfer Transformer tests', TransformerTest => {
       test.end()
     })
 
+    transformHeadersTest.test('Set ContentType && Accept versions via RESOURCE_VERSIONS env variable', async test => {
+      const RESOURCE_VERSIONS_BACKUP = process.env.RESOURCE_VERSIONS
+      process.env.RESOURCE_VERSIONS = 'transfers=1.1,quotes=1.0'
+
+      const headerConfig = {
+        httpMethod: 'PUT',
+        sourceFsp: 'switch',
+        destinationFsp: 'FSPDest'
+      }
+
+      const headerData = Util.clone(headerDataInputExample)
+      headerData.Accept = Helper.generateProtocolHeader('transfers', '1')
+
+      const transformedHeaderData = Transformer.transformHeaders(headerData, headerConfig)
+
+      test.deepEqual(headerData['Content-Type'], transformedHeaderData['Content-Type'])
+      test.deepEqual(headerData.Accept, transformedHeaderData.Accept)
+      test.end()
+      process.env.RESOURCE_VERSIONS = RESOURCE_VERSIONS_BACKUP
+    })
+
+    transformHeadersTest.test('Set ContentType && Accept versions via config', async test => {
+      const RESOURCE_VERSIONS_BACKUP = process.env.RESOURCE_VERSIONS
+      // we keep this here to make sure it does not override the injected protocolVersions config
+      process.env.RESOURCE_VERSIONS = 'transfers=1.0,quotes=1.0'
+
+      const headerConfig = {
+        httpMethod: 'PUT',
+        sourceFsp: 'switch',
+        destinationFsp: 'FSPDest',
+        protocolVersions: {
+          content: '1.1',
+          accept: '1'
+        }
+      }
+
+      const headerData = Util.clone(headerDataInputExample)
+      headerData.Accept = Helper.generateProtocolHeader('transfers', '1.1')
+
+      const resourceInfoFromHeader = Transformer.getResourceInfoFromHeader(headerData['Content-Type'])
+
+      const transformedHeaderData = Transformer.transformHeaders(headerData, headerConfig)
+      const resourceInfoFromTransformedHeader = Transformer.getResourceInfoFromHeader(transformedHeaderData['Content-Type'])
+
+      test.equal(resourceInfoFromHeader.resourceType, resourceInfoFromTransformedHeader.resourceType)
+      test.equal(resourceInfoFromHeader.version, '1.0')
+      test.equal(resourceInfoFromTransformedHeader.version, '1.1')
+      test.equal(transformedHeaderData.Accept, Helper.generateProtocolHeader('transfers', headerConfig.protocolVersions.accept))
+      test.end()
+      process.env.RESOURCE_VERSIONS = RESOURCE_VERSIONS_BACKUP
+    })
+
     transformHeadersTest.test('Translate Date field into correct format for String value', async test => {
       const key = 'Date'
       const val = '2018-09-13T13:52:15.221Z'

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

@@ -46,6 +46,7 @@ const Utility = require('../../../../src/util').Kafka
 const Enum = require('../../../../src').Enum
 const Config = require('../../../util/config')
 const clone = require('../../../../src/util').clone
+const { _getFunctionalityAction } = require('../../../../src/util/kafka')
 
 let participantName
 const TRANSFER = Enum.Events.Event.Type.TRANSFER
@@ -124,6 +125,43 @@ Test('Utility Test', utilityTest => {
     test.end()
   })
 
+  utilityTest.test('getFunctionalityAction', gfaTest => {
+    gfaTest.test('should return config for transfer-prepare', test => {
+      // Arrange
+      const expected = { functionalityMapped: 'transfer', actionMapped: 'prepare' }
+      // Act
+      const result = _getFunctionalityAction('transfer', 'prepare')
+
+      // Assert
+      test.deepEqual(result, expected)
+      test.end()
+    })
+
+    gfaTest.test('should return config for NOTIFICATION ABORT_VALIDATION', test => {
+      // Arrange
+      const expected = { functionalityMapped: 'notification', actionMapped: 'event' }
+      // Act
+      const result = _getFunctionalityAction('notification', 'abort-validation')
+
+      // Assert
+      test.deepEqual(result, expected)
+      test.end()
+    })
+
+    gfaTest.test('should return config for transfer-reserved-aborted', test => {
+      // Arrange
+      const expected = { functionalityMapped: 'notification', actionMapped: 'event' }
+      // Act
+      const result = _getFunctionalityAction('notification', 'reserved-aborted')
+
+      // Assert
+      test.deepEqual(result, expected)
+      test.end()
+    })
+
+    gfaTest.end()
+  })
+
   utilityTest.test('createParticipantTopicConf should', createParticipantTopicConfTest => {
     createParticipantTopicConfTest.test('return a participant topic conf object', test => {
       const response = Utility.createParticipantTopicConf(Config.KAFKA_CONFIG.TOPIC_TEMPLATES.PARTICIPANT_TOPIC_TEMPLATE.TEMPLATE, participantName, TRANSFER, PREPARE, 0)

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

@@ -112,6 +112,59 @@ Test('ParticipantEndpoint Model Test', modelTest => {
       }
     })
 
+    getEndpointTest.test('handle protocolVersions for config injection', async (test) => {
+      const protocolVersions = {
+        content: '2.1',
+        accept: '2'
+      }
+      const fsp = 'fsp'
+      const requestOptions = {
+        url: Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp }),
+        method: 'get'
+      }
+      const requestFunction = (request) => {
+        test.equal(request.headers['content-type'], Helper.generateProtocolHeader('participants', protocolVersions.content))
+        test.equal(request.headers.accept, Helper.generateProtocolHeader('participants', protocolVersions.accept))
+        return Helper.getEndPointsResponse
+      }
+      const span = EventSdk.Tracer.createSpan('test-span')
+      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)
+        test.deepEqual(result, Helper.getEndPointsResponse, 'The results match')
+        test.end()
+      } catch (err) {
+        test.fail('Error thrown', err)
+        test.end()
+      }
+    })
+
+    getEndpointTest.test('handle protocolVersions without config injection', async (test) => {
+      const protocolVersions = null
+      const fsp = 'fsp'
+      const requestOptions = {
+        url: Mustache.render(Config.ENDPOINT_SOURCE_URL + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp }),
+        method: 'get'
+      }
+      const requestFunction = (request) => {
+        test.equal(request.headers['content-type'], Helper.generateProtocolHeader('participants', '1.0'))
+        test.equal(request.headers.accept, Helper.generateProtocolHeader('participants', '1'))
+        return Helper.getEndPointsResponse
+      }
+      const span = EventSdk.Tracer.createSpan('test-span')
+      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)
+        test.deepEqual(result, Helper.getEndPointsResponse, 'The results match')
+        test.end()
+      } catch (err) {
+        test.fail('Error thrown', err)
+        test.end()
+      }
+    })
+
     getEndpointTest.test('throw error', async (test) => {
       const fsp = 'fsp1'
 

package/test/util/helper.js

@@ -26,13 +26,15 @@
 
 const Enums = require('../../src/enums')
 
-function defaultHeaders (destination, resource, source, version = '1.0') {
+const generateProtocolHeader = (resource, version) => `application/vnd.interoperability.${resource}+json;version=${version}`
+
+const defaultHeaders = (destination, resource, source, version = '1.0') => {
   // TODO: See API section 3.2.1; what should we do about X-Forwarded-For? Also, should we
   // add/append to this field in all 'queueResponse' calls?
   return {
-    accept: `application/vnd.interoperability.${resource}+json;version=${version}`,
+    accept: generateProtocolHeader(resource, version),
     'fspiop-destination': destination || '',
-    'content-type': `application/vnd.interoperability.${resource}+json;version=${version}`,
+    'content-type': generateProtocolHeader(resource, version),
     date: '2019-05-24 08:52:19',
     'fspiop-source': source
   }
@@ -74,6 +76,7 @@ const getEndpointAndRenderResponse = {
 
 module.exports = {
   defaultHeaders,
+  generateProtocolHeader,
   getEndPointsResponse,
   getEndpointAndRenderResponse
 }