Bugfixes/test case editor (#123)

* Added custom.sleep function and refactored request.delay functionality

* Made requestVariables to be accessible from request editor

* Added request timeout

* Bumped up the version, fixed unit tests and postponed audits

* Changed the versions in docker-compose file

docker-compose.yml

@@ -2,7 +2,7 @@ version: "3.7"
 
 services:
   mojaloop-testing-toolkit:
-    image: mojaloop/ml-testing-toolkit:v11.7.0
+    image: mojaloop/ml-testing-toolkit:v11.7.3
     #image: mojaloop-testing-toolkit:local
     #build:
     #  context: .
@@ -18,7 +18,7 @@ services:
       - -c
       - "npm start"
   mojaloop-testing-toolkit-ui:
-    image: mojaloop/ml-testing-toolkit-ui:v11.6.1
+    image: mojaloop/ml-testing-toolkit-ui:v11.7.2
     ports:
       - "6060:6060"
     environment:

documents/User-Guide-Mojaloop-Testing-Toolkit.md

@@ -360,6 +360,8 @@ You can write scripts in two formats.
     ```
     environment.payeeRequest.headers['content-type']
     ```
+  - **custom.setRequestTimeout** - To set a specific timeout value for the request in milli seconds (Default: 3000ms)
+  - **custom.sleep** - To wait for particular amount of milli seconds
   - **custom.jws** - library
 
     With custom.jws library, you can sign and validate an FSPIOP request using JWS

package.json

@@ -1,7 +1,7 @@
 {
   "name": "ml-testing-toolkit",
   "description": "Testing Toolkit for Mojaloop implementations",
-  "version": "11.7.4",
+  "version": "11.7.5",
   "license": "Apache-2.0",
   "author": "Vijaya Kumar Guthi, ModusBox Inc.",
   "contributors": [

src/lib/scripting-engines/vm-javascript-sandbox.js

@@ -58,6 +58,12 @@ const customWrapperFn = (requestVariables) => {
           return err.message
         }
       }
+    },
+    sleep: function (delay) {
+      return new Promise(resolve => setTimeout(resolve, delay))
+    },
+    setRequestTimeout: function (timeout) {
+      requestVariables.REQUEST_TIMEOUT = timeout
     }
   }
 }

src/lib/test-outbound/outbound-initiator.js

@@ -214,6 +214,10 @@ const processTestCase = async (testCase, traceID, inputValues, variableData, dfs
       )
     })
 
+    if (request.delay) {
+      await new Promise(resolve => setTimeout(resolve, request.delay))
+    }
+
     let convertedRequest = JSON.parse(JSON.stringify(request))
 
     // Form the actual http request headers, body, path and method by replacing configurable parameters
@@ -247,6 +251,7 @@ const processTestCase = async (testCase, traceID, inputValues, variableData, dfs
       }
 
       convertedRequest = replaceEnvironmentVariables(convertedRequest, variableData.environment)
+      convertedRequest = replaceRequestLevelEnvironmentVariables(convertedRequest, contextObj.requestVariables)
 
       let successCallbackUrl = null
       let errorCallbackUrl = null
@@ -261,9 +266,6 @@ const processTestCase = async (testCase, traceID, inputValues, variableData, dfs
         }
       }
 
-      if (request.delay) {
-        await new Promise(resolve => setTimeout(resolve, request.delay))
-      }
       const resp = await sendRequest(convertedRequest.url, convertedRequest.method, convertedRequest.path, convertedRequest.queryParams, convertedRequest.headers, convertedRequest.body, successCallbackUrl, errorCallbackUrl, convertedRequest.ignoreCallbacks, dfspId, contextObj)
       await setResponse(convertedRequest, resp, variableData, request, 'SUCCESS', tracing, testCase, scriptsExecution, contextObj, globalConfig)
     } catch (err) {
@@ -476,7 +478,7 @@ const sendRequest = (baseUrl, method, path, queryParams, headers, body, successC
         params: queryParams,
         headers: headers,
         data: body,
-        timeout: 3000,
+        timeout: (contextObj.requestVariables && contextObj.requestVariables.REQUEST_TIMEOUT) || 3000,
         validateStatus: function (status) {
           return status < 900 // Reject only if the status code is greater than or equal to 900
         },
@@ -625,35 +627,18 @@ const replaceVariables = (inputObject, inputValues, request, requestsObj) => {
 }
 
 const replaceRequestVariables = (inputRequest) => {
-  let resultObject = setResultObject(inputRequest)
-  if (!resultObject) {
-    return inputRequest
-  }
+  return _replaceGenericVariables(inputRequest, inputRequest, 'request')
+}
 
-  // Check once again for the replaced request variables
-  const matchedArray = resultObject.match(/{\$([^}]+)}/g)
-  if (matchedArray) {
-    matchedArray.forEach(element => {
-      // Check for the function type of param, if its function we need to call a function in custom-functions and replace the returned value
-      const splitArr = element.split('.')
-      switch (splitArr[0]) {
-        case '{$request':
-          var temp2 = element.replace(/{\$request.(.*)}/, '$1')
-          var replacedValue2 = _.get(inputRequest, temp2)
-          if (replacedValue2) {
-            resultObject = resultObject.replace(element, replacedValue2)
-          }
-          break
-        default:
-          break
-      }
-    })
-  }
+const replaceEnvironmentVariables = (inputRequest, environment) => {
+  return _replaceGenericVariables(inputRequest, environment, 'environment')
+}
 
-  return (typeof inputRequest === 'object') ? JSON.parse(resultObject) : resultObject
+const replaceRequestLevelEnvironmentVariables = (inputRequest, requestVariables) => {
+  return _replaceGenericVariables(inputRequest, requestVariables, 'requestVariables')
 }
 
-const replaceEnvironmentVariables = (inputRequest, environment) => {
+const _replaceGenericVariables = (inputRequest, replaceObject, variablePrefix) => {
   let resultObject = setResultObject(inputRequest)
   if (!resultObject) {
     return inputRequest
@@ -665,16 +650,13 @@ const replaceEnvironmentVariables = (inputRequest, environment) => {
     matchedArray.forEach(element => {
       // Check for the function type of param, if its function we need to call a function in custom-functions and replace the returned value
       const splitArr = element.split('.')
-      switch (splitArr[0]) {
-        case '{$environment':
-          var temp2 = element.replace(/{\$environment.(.*)}/, '$1')
-          var replacedValue2 = _.get(environment, temp2)
-          if (replacedValue2) {
-            resultObject = resultObject.replace(element, replacedValue2)
-          }
-          break
-        default:
-          break
+      if (splitArr[0] === '{$' + variablePrefix) {
+        const regExp1 = new RegExp('{\\$' + variablePrefix + '.(.*)}')
+        var temp2 = element.replace(regExp1, '$1')
+        var replacedValue2 = _.get(replaceObject, temp2)
+        if (replacedValue2) {
+          resultObject = resultObject.replace(element, replacedValue2)
+        }
       }
     })
   }
@@ -748,6 +730,7 @@ module.exports = {
   replaceVariables,
   replaceRequestVariables,
   replaceEnvironmentVariables,
+  replaceRequestLevelEnvironmentVariables,
   replacePathVariables,
   getFunctionResult,
   generateFinalReport

test/unit/lib/scripting-engines/vm-javascript-sandbox.test.js

@@ -230,6 +230,56 @@ describe('Test Outbound Context', () => {
 
     })
 
+    it('executeAsync should call custom.sleep function', async () => {
+
+      const contextObj = await Context.generateContextObj({})
+
+      const args = {
+        script: [
+          "await custom.sleep(20)",
+          "console.log('SAMPLE_OUTPUT_AFTER_SLEEP')",
+        ],
+        data: { context: {...contextObj}, id: uuid.v4()},
+        contextObj: contextObj
+      }
+
+      let scriptResult
+      try {
+        scriptResult = await Context.executeAsync(args.script, args.data, args.contextObj)
+      } finally {
+        contextObj.ctx.dispose()
+        contextObj.ctx = null
+      }
+      expect(scriptResult.consoleLog[0][1]).toEqual('log')
+      expect(scriptResult.consoleLog[0][2]).toEqual('SAMPLE_OUTPUT_AFTER_SLEEP')
+
+    })
+
+    it('executeAsync should call custom.setRequestTimeout function', async () => {
+
+      const contextObj = await Context.generateContextObj({})
+
+      const args = {
+        script: [
+          "custom.setRequestTimeout(2000)",
+          "console.log(requestVariables.REQUEST_TIMEOUT)",
+        ],
+        data: { context: {...contextObj}, id: uuid.v4()},
+        contextObj: contextObj
+      }
+
+      let scriptResult
+      try {
+        scriptResult = await Context.executeAsync(args.script, args.data, args.contextObj)
+      } finally {
+        contextObj.ctx.dispose()
+        contextObj.ctx = null
+      }
+      expect(scriptResult.consoleLog[0][1]).toEqual('log')
+      expect(scriptResult.consoleLog[0][2]).toEqual(2000)
+
+    })
+
     // Error scenarios
     it('executeAsync should return consoleLog with error messages', async () => {