botium-core 1.11.13 → 1.12.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "botium-core",
-  "version": "1.11.13",
+  "version": "1.12.0",
   "description": "The Selenium for Chatbots",
   "main": "index.js",
   "module": "dist/botium-es.js",
   "engines": {
-    "node": ">=10.0.0"
+    "node": ">=14.0.0"
   },
   "scripts": {
     "postinstall": "node ./report.js",
@@ -32,65 +32,66 @@
   },
   "homepage": "https://www.botium.ai",
   "dependencies": {
-    "@babel/runtime": "^7.15.4",
-    "async": "^3.2.1",
-    "body-parser": "^1.19.0",
+    "@babel/runtime": "^7.16.5",
+    "async": "^3.2.2",
+    "body-parser": "^1.19.1",
     "boolean": "^3.1.4",
     "bottleneck": "^2.19.5",
-    "csv-parse": "^4.16.3",
-    "debug": "^4.3.2",
+    "csv-parse": "^5.0.3",
+    "debug": "^4.3.3",
     "esprima": "^4.0.1",
-    "express": "^4.17.1",
+    "express": "^4.17.2",
     "globby": "11.0.4",
-    "ioredis": "^4.27.9",
+    "ioredis": "^4.28.2",
     "is-class": "^0.0.9",
     "is-json": "^2.0.1",
     "jsonpath": "^1.1.1",
     "lodash": "^4.17.21",
-    "markdown-it": "^12.2.0",
-    "mime-types": "^2.1.32",
+    "markdown-it": "^12.3.0",
+    "mime-types": "^2.1.34",
     "mkdirp": "^1.0.4",
     "moment": "^2.29.1",
     "mustache": "^4.2.0",
     "promise-retry": "^2.0.1",
-    "promise.allsettled": "^1.0.4",
+    "promise.allsettled": "^1.0.5",
     "randomatic": "^3.1.1",
     "request": "^2.88.2",
     "rimraf": "^3.0.2",
     "sanitize-filename": "^1.6.3",
-    "slugify": "^1.6.0",
-    "socket.io": "^4.2.0",
-    "socket.io-client": "^4.2.0",
+    "slugify": "^1.6.4",
+    "socket.io": "^4.4.0",
+    "socket.io-client": "^4.4.0",
     "socketio-auth": "^0.1.1",
     "swagger-jsdoc": "^6.1.0",
-    "swagger-ui-express": "^4.1.6",
+    "swagger-ui-express": "^4.3.0",
     "uuid": "^8.3.2",
-    "vm2": "^3.9.3",
+    "vm2": "^3.9.5",
     "write-yaml": "^1.0.0",
-    "xlsx": "^0.17.1",
+    "xlsx": "^0.17.4",
     "xregexp": "^5.1.0",
     "yaml": "^1.10.2"
   },
   "devDependencies": {
-    "@babel/core": "^7.15.5",
-    "@babel/node": "^7.15.4",
-    "@babel/plugin-transform-runtime": "^7.15.0",
-    "@babel/preset-env": "^7.15.6",
+    "@babel/core": "^7.16.5",
+    "@babel/node": "^7.16.5",
+    "@babel/plugin-transform-runtime": "^7.16.5",
+    "@babel/preset-env": "^7.16.5",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "cross-env": "^7.0.3",
-    "eslint": "^7.32.0",
+    "eslint": "^8.4.1",
     "eslint-config-standard": "^16.0.3",
-    "eslint-plugin-import": "^2.24.2",
+    "eslint-plugin-import": "^2.25.3",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^5.1.0",
+    "eslint-plugin-promise": "^5.2.0",
     "eslint-plugin-standard": "^4.1.0",
     "license-checker": "^25.0.1",
-    "mocha": "^9.1.1",
-    "nock": "^13.1.3",
-    "npm-check-updates": "^11.8.5",
+    "license-compatibility-checker": "^0.3.5",
+    "mocha": "^9.1.3",
+    "nock": "^13.2.1",
+    "npm-check-updates": "^12.0.5",
     "nyc": "^15.1.0",
-    "rollup": "^2.56.3",
+    "rollup": "^2.61.1",
     "rollup-plugin-babel": "^4.4.0",
     "rollup-plugin-commonjs": "^10.1.0",
     "rollup-plugin-json": "^4.0.0",

package/samples/connectors/custom/botium-connector-myapi.js

@@ -23,13 +23,13 @@ class BotiumConnectorMyApi {
         [CoreCapabilities.SIMPLEREST_URL]: this.caps[Capabilities.MYAPI_URL],
         [CoreCapabilities.SIMPLEREST_METHOD]: 'POST',
         [CoreCapabilities.SIMPLEREST_RESPONSE_JSONPATH]: '$.reply',
-        [CoreCapabilities.SIMPLEREST_BODY_TEMPLATE]: JSON.stringify({ 
+        [CoreCapabilities.SIMPLEREST_BODY_TEMPLATE]: JSON.stringify({
           username: 'botium',
           message: '{{msg.messageText}}',
           session: '{{botium.conversationId}}',
           startsession: false,
           quickreply: null
-         })
+        })
       }
       if (this.caps[Capabilities.MYAPI_TOKEN]) {
         this.delegateCaps[CoreCapabilities.SIMPLEREST_HEADERS_TEMPLATE] = `{ "Authorization": "Token ${this.caps[Capabilities.MYAPI_TOKEN]}"}`
@@ -104,4 +104,4 @@ module.exports = {
       }
     ]
   }
-}
+}

package/samples/extensions/asserterHooks/DummyAsserter.js

@@ -6,17 +6,17 @@ module.exports = class DummyAsserter {
     this.caps = caps
   }
 
-  assertConvoBegin ({convo, container, args}) {
+  assertConvoBegin ({ convo, container, args }) {
     console.log(`Dummy asserter Begin started with those args: ${utils.inspect(args)}`)
     return Promise.resolve()
   }
 
-  assertConvoStep ({convo, convoStep, args, botMsg}) {
+  assertConvoStep ({ convo, convoStep, args, botMsg }) {
     console.log(`ConvoStep dummy assertion with those args: ${utils.inspect(args)}, botMessage: ${utils.inspect(botMsg)} ...`)
     return Promise.resolve()
   }
 
-  assertConvoEnd ({convo, container, transcript, args}) {
+  assertConvoEnd ({ convo, container, transcript, args }) {
     console.log(`ConvoEnd dummy assertion with those args: ${utils.inspect(args)}, transcript: ${utils.inspect(transcript)} ...`)
     return Promise.resolve()
   }

package/src/Capabilities.js

@@ -18,6 +18,7 @@ module.exports = {
   SIMPLEREST_PING_BODY: 'SIMPLEREST_PING_BODY',
   SIMPLEREST_PING_BODY_RAW: 'SIMPLEREST_PING_BODY_RAW',
   SIMPLEREST_PING_HEADERS: 'SIMPLEREST_PING_HEADERS',
+  SIMPLEREST_PING_REQUEST_HOOK: 'SIMPLEREST_PING_REQUEST_HOOK',
   SIMPLEREST_PING_RETRIES: 'SIMPLEREST_PING_RETRIES',
   SIMPLEREST_PING_TIMEOUT: 'SIMPLEREST_PING_TIMEOUT',
   SIMPLEREST_PING_UPDATE_CONTEXT: 'SIMPLEREST_PING_UPDATE_CONTEXT',
@@ -27,6 +28,7 @@ module.exports = {
   SIMPLEREST_START_BODY: 'SIMPLEREST_START_BODY',
   SIMPLEREST_START_BODY_RAW: 'SIMPLEREST_START_BODY_RAW',
   SIMPLEREST_START_HEADERS: 'SIMPLEREST_START_HEADERS',
+  SIMPLEREST_START_REQUEST_HOOK: 'SIMPLEREST_START_REQUEST_HOOK',
   SIMPLEREST_START_RETRIES: 'SIMPLEREST_START_RETRIES',
   SIMPLEREST_START_TIMEOUT: 'SIMPLEREST_START_TIMEOUT',
   SIMPLEREST_START_UPDATE_CONTEXT: 'SIMPLEREST_START_UPDATE_CONTEXT',
@@ -36,10 +38,12 @@ module.exports = {
   SIMPLEREST_STOP_BODY: 'SIMPLEREST_STOP_BODY',
   SIMPLEREST_STOP_BODY_RAW: 'SIMPLEREST_STOP_BODY_RAW',
   SIMPLEREST_STOP_HEADERS: 'SIMPLEREST_STOP_HEADERS',
+  SIMPLEREST_STOP_REQUEST_HOOK: 'SIMPLEREST_STOP_REQUEST_HOOK',
   SIMPLEREST_STOP_RETRIES: 'SIMPLEREST_STOP_RETRIES',
   SIMPLEREST_STOP_TIMEOUT: 'SIMPLEREST_STOP_TIMEOUT',
   SIMPLEREST_INIT_CONTEXT: 'SIMPLEREST_INIT_CONTEXT',
   SIMPLEREST_INIT_TEXT: 'SIMPLEREST_INIT_TEXT',
+  SIMPLEREST_INIT_PROCESS_RESPONSE: 'SIMPLEREST_INIT_PROCESS_RESPONSE',
   SIMPLEREST_PROXY_URL: 'SIMPLEREST_PROXY_URL',
   SIMPLEREST_STRICT_SSL: 'SIMPLEREST_STRICT_SSL',
   SIMPLEREST_URL: 'SIMPLEREST_URL',
@@ -54,11 +58,13 @@ module.exports = {
   SIMPLEREST_START_HOOK: 'SIMPLEREST_START_HOOK',
   SIMPLEREST_STOP_HOOK: 'SIMPLEREST_STOP_HOOK',
   SIMPLEREST_REQUEST_HOOK: 'SIMPLEREST_REQUEST_HOOK',
+  SIMPLEREST_PARSER_HOOK: 'SIMPLEREST_PARSER_HOOK',
   SIMPLEREST_POLL_URL: 'SIMPLEREST_POLL_URL',
   SIMPLEREST_POLL_VERB: 'SIMPLEREST_POLL_VERB',
   SIMPLEREST_POLL_BODY: 'SIMPLEREST_POLL_BODY',
   SIMPLEREST_POLL_BODY_RAW: 'SIMPLEREST_POLL_BODY_RAW',
   SIMPLEREST_POLL_HEADERS: 'SIMPLEREST_POLL_HEADERS',
+  SIMPLEREST_POLL_REQUEST_HOOK: 'SIMPLEREST_POLL_REQUEST_HOOK',
   SIMPLEREST_POLL_INTERVAL: 'SIMPLEREST_POLL_INTERVAL',
   SIMPLEREST_POLL_TIMEOUT: 'SIMPLEREST_PING_TIMEOUT',
   SIMPLEREST_POLL_UPDATE_CONTEXT: 'SIMPLEREST_POLL_UPDATE_CONTEXT',
@@ -106,7 +112,7 @@ module.exports = {
   SCRIPTING_ENABLE_MEMORY: 'SCRIPTING_ENABLE_MEMORY',
   SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS: 'SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS',
   SCRIPTING_FORCE_BOT_CONSUMED: 'SCRIPTING_FORCE_BOT_CONSUMED',
-  // regexp, regexpIgnoreCase, wildcard, wildcardIgnoreCase, include, includeIgnoreCase, equals, equalsIgnoreCase
+  // regexp, regexpIgnoreCase, wildcard, wildcardIgnoreCase, wildcardExact, wildcardExactIgnoreCase, include, includeIgnoreCase, equals, equalsIgnoreCase
   SCRIPTING_MATCHING_MODE: 'SCRIPTING_MATCHING_MODE',
   // all, first, random
   SCRIPTING_UTTEXPANSION_MODE: 'SCRIPTING_UTTEXPANSION_MODE',

package/src/Defaults.js

@@ -15,6 +15,7 @@ module.exports = {
     [Capabilities.SIMPLEREST_PING_VERB]: 'GET',
     [Capabilities.SIMPLEREST_PING_UPDATE_CONTEXT]: true,
     [Capabilities.SIMPLEREST_PING_PROCESS_RESPONSE]: false,
+    [Capabilities.SIMPLEREST_INIT_PROCESS_RESPONSE]: false,
     [Capabilities.SIMPLEREST_STOP_RETRIES]: 6,
     [Capabilities.SIMPLEREST_STOP_TIMEOUT]: 10000,
     [Capabilities.SIMPLEREST_STOP_VERB]: 'GET',

package/src/containers/plugins/SimpleRestContainer.js

@@ -17,6 +17,7 @@ const Defaults = require('../../Defaults').Capabilities
 const { SCRIPTING_FUNCTIONS } = require('../../scripting/ScriptingMemory')
 const { getHook, executeHook } = require('../../helpers/HookUtils')
 const { escapeJSONString } = require('../../helpers/Utils')
+const { BotiumError } = require('../../scripting/BotiumError')
 
 Mustache.escape = s => s
 
@@ -57,7 +58,20 @@ module.exports = class SimpleRestContainer {
     this.startHook = getHook(this.caps, this.caps[Capabilities.SIMPLEREST_START_HOOK])
     this.stopHook = getHook(this.caps, this.caps[Capabilities.SIMPLEREST_STOP_HOOK])
     this.requestHook = getHook(this.caps, this.caps[Capabilities.SIMPLEREST_REQUEST_HOOK])
+    this.parserHook = getHook(this.caps, this.caps[Capabilities.SIMPLEREST_PARSER_HOOK])
     this.responseHook = getHook(this.caps, this.caps[Capabilities.SIMPLEREST_RESPONSE_HOOK])
+    this.pollRequestHook = getHook(this.caps, this.caps[Capabilities.SIMPLEREST_POLL_REQUEST_HOOK])
+
+    this.requestHooks = {}
+    if (this.caps[Capabilities.SIMPLEREST_PING_REQUEST_HOOK]) {
+      this.requestHooks.SIMPLEREST_PING = getHook(this.caps, this.caps[Capabilities.SIMPLEREST_PING_REQUEST_HOOK])
+    }
+    if (this.caps[Capabilities.SIMPLEREST_START_REQUEST_HOOK]) {
+      this.requestHooks.SIMPLEREST_START = getHook(this.caps, this.caps[Capabilities.SIMPLEREST_START_REQUEST_HOOK])
+    }
+    if (this.caps[Capabilities.SIMPLEREST_STOP_REQUEST_HOOK]) {
+      this.requestHooks.SIMPLEREST_STOP = getHook(this.caps, this.caps[Capabilities.SIMPLEREST_STOP_REQUEST_HOOK])
+    }
   }
 
   Build () {
@@ -111,18 +125,34 @@ module.exports = class SimpleRestContainer {
           executeHook(this.caps, this.startHook, this.view).then(() => startHookComplete()).catch(startHookComplete)
         },
 
+        (inboundListenerComplete) => {
+          this._subscribeInbound()
+            .then(() => inboundListenerComplete())
+            .catch(inboundListenerComplete)
+        },
+
+        (startPollingComplete) => {
+          this._startPolling()
+            .then(() => startPollingComplete())
+            .catch(startPollingComplete)
+        },
+
         (pingComplete) => {
           if (this.caps[Capabilities.SIMPLEREST_PING_URL]) {
             this._makeCall('SIMPLEREST_PING')
-              .then(response => {
+              .then(body => {
                 if (this.caps[Capabilities.SIMPLEREST_PING_UPDATE_CONTEXT] || this.caps[Capabilities.SIMPLEREST_PING_PROCESS_RESPONSE]) {
-                  if (_.isObject(response) || botiumUtils.isStringJson(response)) {
-                    debug(`Ping Uri ${this.caps[Capabilities.SIMPLEREST_PING_URL]} returned JSON response: ${botiumUtils.shortenJsonString(response)}`)
-                    const body = _.isObject(response) ? response : JSON.parse(response)
-                    return this._processBodyAsync(body, !!this.caps[Capabilities.SIMPLEREST_PING_PROCESS_RESPONSE], !!this.caps[Capabilities.SIMPLEREST_PING_UPDATE_CONTEXT])
-                  } else {
-                    debug(`Ping Uri ${this.caps[Capabilities.SIMPLEREST_PING_URL]} didn't return JSON response, ignoring it.`)
-                  }
+                  return this._parseResponseBody(body)
+                    .then(body => {
+                      if (body) {
+                        debug(`Ping Uri ${this.caps[Capabilities.SIMPLEREST_PING_URL]} returned JSON response: ${botiumUtils.shortenJsonString(body)}`)
+                        return this._processBodyAsync(body, !!this.caps[Capabilities.SIMPLEREST_PING_PROCESS_RESPONSE], !!this.caps[Capabilities.SIMPLEREST_PING_UPDATE_CONTEXT])
+                      } else {
+                        debug(`Ping Uri ${this.caps[Capabilities.SIMPLEREST_PING_URL]} didn't return JSON response, ignoring it.`)
+                      }
+                    }).catch(err => {
+                      debug(`Ping Uri ${this.caps[Capabilities.SIMPLEREST_PING_URL]} didn't return JSON response, ignoring it (${err.message})`)
+                    })
                 }
               }).then(() => {
                 pingComplete()
@@ -136,37 +166,29 @@ module.exports = class SimpleRestContainer {
 
         (initComplete) => {
           if (_.isString(this.caps[Capabilities.SIMPLEREST_INIT_TEXT])) {
-            this._doRequest({ messageText: this.caps[Capabilities.SIMPLEREST_INIT_TEXT] }, false, true).then(() => initComplete()).catch(initComplete)
+            this._doRequest({ messageText: this.caps[Capabilities.SIMPLEREST_INIT_TEXT] }, !!this.caps[Capabilities.SIMPLEREST_INIT_PROCESS_RESPONSE], true).then(() => initComplete()).catch(initComplete)
           } else {
             initComplete()
           }
         },
 
-        (inboundListenerComplete) => {
-          this._subscribeInbound()
-            .then(() => inboundListenerComplete())
-            .catch(inboundListenerComplete)
-        },
-
-        (startPollingComplete) => {
-          this._startPolling()
-            .then(() => startPollingComplete())
-            .catch(startPollingComplete)
-        },
-
         (startCallComplete) => {
           this.processInbound = true
           if (this.caps[Capabilities.SIMPLEREST_START_URL]) {
             this._makeCall('SIMPLEREST_START')
-              .then(response => {
+              .then(body => {
                 if (this.caps[Capabilities.SIMPLEREST_START_UPDATE_CONTEXT] || this.caps[Capabilities.SIMPLEREST_START_PROCESS_RESPONSE]) {
-                  if (_.isObject(response) || botiumUtils.isStringJson(response)) {
-                    debug(`Start Uri ${this.caps[Capabilities.SIMPLEREST_START_URL]} returned JSON response: ${botiumUtils.shortenJsonString(response)}`)
-                    const body = _.isObject(response) ? response : JSON.parse(response)
-                    return this._processBodyAsync(body, !!this.caps[Capabilities.SIMPLEREST_START_PROCESS_RESPONSE], !!this.caps[Capabilities.SIMPLEREST_START_UPDATE_CONTEXT])
-                  } else {
-                    debug(`Start Uri ${this.caps[Capabilities.SIMPLEREST_START_URL]} didn't return JSON response, ignoring it.`)
-                  }
+                  return this._parseResponseBody(body)
+                    .then(body => {
+                      if (body) {
+                        debug(`Start Uri ${this.caps[Capabilities.SIMPLEREST_START_URL]} returned JSON response: ${botiumUtils.shortenJsonString(body)}`)
+                        return this._processBodyAsync(body, !!this.caps[Capabilities.SIMPLEREST_START_PROCESS_RESPONSE], !!this.caps[Capabilities.SIMPLEREST_START_UPDATE_CONTEXT])
+                      } else {
+                        debug(`Start Uri ${this.caps[Capabilities.SIMPLEREST_START_URL]} didn't return JSON response, ignoring it.`)
+                      }
+                    }).catch(err => {
+                      debug(`Start Uri ${this.caps[Capabilities.SIMPLEREST_START_URL]} didn't return JSON response, ignoring it (${err.message})`)
+                    })
                 }
               }).then(() => {
                 startCallComplete()
@@ -357,27 +379,40 @@ module.exports = class SimpleRestContainer {
 
         this.waitProcessQueue = []
 
-        request(requestOptions, (err, response, body) => {
+        request(requestOptions, async (err, response, body) => {
           if (err) {
-            reject(new Error(`rest request failed: ${err.message}`))
+            return reject(new Error(`rest request failed: ${err.message}`))
           } else {
             if (response.statusCode >= 400) {
               debug(`got error response: ${response.statusCode}/${response.statusMessage}`)
+              if (debug.enabled && body) {
+                debug(botiumUtils.shortenJsonString(body))
+              }
+              if (body) {
+                const jsonBody = botiumUtils.toJsonWeak(body)
+                const errKey = Object.keys(jsonBody).find(k => k.startsWith('err') || k.startsWith('fail'))
+                if (errKey) {
+                  return reject(new BotiumError(`got error response: ${response.statusCode}/${response.statusMessage} - ${jsonBody[errKey]}`, {
+                    message: botiumUtils.shortenJsonString(body)
+                  }))
+                }
+              }
               return reject(new Error(`got error response: ${response.statusCode}/${response.statusMessage}`))
             }
 
             if (body) {
               debug(`got response code: ${response.statusCode}, body: ${botiumUtils.shortenJsonString(body)}`)
-              if (_.isString(body)) {
-                try {
-                  body = JSON.parse(body.trim())
-                  this._processBodyAsync(body, isFromUser, updateContext).then(() => resolve(this)).then(() => this._emptyWaitProcessQueue())
-                } catch (err) {
-                  debug(`ignoring not JSON formatted response body (${err.message})`)
-                  resolve(this)
-                  this._emptyWaitProcessQueue()
-                }
-              } else if (_.isObject(body)) {
+
+              try {
+                body = await this._parseResponseBody(body)
+              } catch (err) {
+                debug(`ignoring not JSON formatted response body: ${err.message}`)
+                resolve(this)
+                this._emptyWaitProcessQueue()
+                return
+              }
+
+              if (body) {
                 this._processBodyAsync(body, isFromUser, updateContext).then(() => resolve(this)).then(() => this._emptyWaitProcessQueue())
               } else {
                 debug('ignoring response body (no string and no JSON object)')
@@ -453,6 +488,15 @@ module.exports = class SimpleRestContainer {
         requestOptions.uri = `${requestOptions.uri}?${appendToUri}`
       }
     }
+    if (msg.ADD_FORM_PARAM && Object.keys(msg.ADD_FORM_PARAM).length > 0) {
+      requestOptions.form = {}
+      for (const formKey of Object.keys(msg.ADD_FORM_PARAM)) {
+        const formValue = this._getMustachedVal(
+          _.isString(msg.ADD_FORM_PARAM[formKey]) ? msg.ADD_FORM_PARAM[formKey] : JSON.stringify(msg.ADD_FORM_PARAM[formKey]),
+          false)
+        requestOptions.form[formKey] = formValue
+      }
+    }
     if (msg.ADD_HEADER && Object.keys(msg.ADD_HEADER).length > 0) {
       requestOptions.headers = requestOptions.headers || {}
 
@@ -494,14 +538,36 @@ module.exports = class SimpleRestContainer {
         await timeout(pingConfig.timeout)
       } else if (response.statusCode >= 400) {
         debug(`_waitForUrlResponse on url check ${pingConfig.uri} got error response: ${response.statusCode}/${response.statusMessage}`)
+        if (debug.enabled && body) {
+          debug(botiumUtils.shortenJsonString(body))
+        }
         await timeout(pingConfig.timeout)
       } else {
-        debug(`_waitForUrlResponse success on url check ${pingConfig.uri}`)
+        debug(`_waitForUrlResponse success on url check ${pingConfig.uri}: ${response.statusCode}/${response.statusMessage}`)
+        if (debug.enabled && body) {
+          debug(botiumUtils.shortenJsonString(body))
+        }
         return body
       }
     }
   }
 
+  async _parseResponseBody (body) {
+    if (!_.isObject(body) && _.isString(body)) {
+      try {
+        body = JSON.parse(body)
+      } catch (err) {
+        if (!this.parserHook) throw err
+      }
+    }
+    if (this.parserHook) {
+      await executeHook(this.caps, this.parserHook, Object.assign({ body, changeBody: (b) => { body = b } }, this.view))
+    }
+    if (_.isObject(body)) return body
+    else if (_.isString(body)) return JSON.parse(body)
+    else return null
+  }
+
   _getCapValue (capName) {
     return _.isFunction(this.caps[capName]) ? (this.caps[capName])() : this.caps[capName]
   }
@@ -629,7 +695,7 @@ module.exports = class SimpleRestContainer {
     }
   }
 
-  _runPolling () {
+  async _runPolling () {
     if (!this.processInbound) return
 
     if (this.caps[Capabilities.SIMPLEREST_POLL_URL]) {
@@ -662,22 +728,31 @@ module.exports = class SimpleRestContainer {
       }
       this._addRequestOptions(pollConfig)
 
-      request(pollConfig, (err, response, body) => {
+      try {
+        await executeHook(this.caps, this.pollRequestHook, Object.assign({ requestOptions: pollConfig }, this.view))
+      } catch (err) {
+        debug(`_runPolling: exeucting request hook failed - (${err.message})`)
+        return
+      }
+      request(pollConfig, async (err, response, body) => {
         if (err) {
           debug(`_runPolling: rest request failed: ${err.message}, request: ${JSON.stringify(pollConfig)}`)
         } else {
           if (response.statusCode >= 400) {
             debug(`_runPolling: got error response: ${response.statusCode}/${response.statusMessage}, request: ${JSON.stringify(pollConfig)}`)
+            if (debug.enabled && body) {
+              debug(botiumUtils.shortenJsonString(body))
+            }
           } else if (body) {
             debug(`_runPolling: got response code: ${response.statusCode}, body: ${botiumUtils.shortenJsonString(body)}`)
-            if (_.isString(body)) {
-              try {
-                body = JSON.parse(body)
-                setTimeout(() => this._processBodyAsync(body, true, !!this.caps[Capabilities.SIMPLEREST_POLL_UPDATE_CONTEXT]), 0)
-              } catch (err) {
-                debug(`_runPolling: ignoring not JSON formatted response body (${err.message})`)
-              }
-            } else if (_.isObject(body)) {
+
+            try {
+              body = await this._parseResponseBody(body)
+            } catch (err) {
+              debug(`_runPolling: ignoring not JSON formatted response body: ${err.message}`)
+              return
+            }
+            if (body) {
               setTimeout(() => this._processBodyAsync(body, true, !!this.caps[Capabilities.SIMPLEREST_POLL_UPDATE_CONTEXT]), 0)
             } else {
               debug('_runPolling: ignoring response body (no string and no JSON object)')
@@ -733,6 +808,8 @@ module.exports = class SimpleRestContainer {
     }
     this._addRequestOptions(httpConfig)
 
+    await executeHook(this.caps, this.requestHooks[capPrefix], Object.assign({ requestOptions: httpConfig }, this.view))
+
     const retries = this._getCapValue(`${capPrefix}_RETRIES`)
     debug(`_makeCall(${capPrefix}): rest request: ${JSON.stringify(httpConfig)}`)
     const response = await this._waitForUrlResponse(httpConfig, retries)

package/src/scripting/CompilerCsv.js

@@ -1,4 +1,4 @@
-const parse = require('csv-parse/lib/sync')
+const { parse } = require('csv-parse/sync')
 const _ = require('lodash')
 const debug = require('debug')('botium-core-CompilerCsv')
 

package/src/scripting/MatchFunctions.js

@@ -37,6 +37,24 @@ const wildcard = (ignoreCase) => (botresponse, utterance) => {
   return regexp.test(botresponse)
 }
 
+const wildcardExact = (ignoreCase) => (botresponse, utterance) => {
+  if (_.isUndefined(botresponse)) {
+    if (utterance.trim() === '*') return true
+    else return false
+  }
+  utterance = toString(utterance)
+  botresponse = _normalize(botresponse)
+
+  const numWildcards = utterance.split('*').length - 1
+  if (numWildcards > 10) {
+    throw new Error('Maximum number of 10 wildcards supported.')
+  }
+  const utteranceRe = '^' + quoteRegexpString(utterance).replace(/\\\*/g, '(.*)') + '$'
+
+  const regexp = ignoreCase ? (new RegExp(utteranceRe, 'i')) : (new RegExp(utteranceRe, ''))
+  return regexp.test(botresponse)
+}
+
 const include = (ignoreCase) => (botresponse, utterance) => {
   if (_.isUndefined(botresponse)) return false
   utterance = toString(utterance)
@@ -66,6 +84,8 @@ const getMatchFunction = (matchingMode) => {
     return regexp(matchingMode === 'regexpIgnoreCase')
   } else if (matchingMode === 'wildcard' || matchingMode === 'wildcardIgnoreCase' || matchingMode === 'wildcardLowerCase') {
     return wildcard(matchingMode === 'wildcardIgnoreCase' || matchingMode === 'wildcardLowerCase')
+  } else if (matchingMode === 'wildcardExact' || matchingMode === 'wildcardExactIgnoreCase') {
+    return wildcardExact(matchingMode === 'wildcardExactIgnoreCase')
   } else if (matchingMode === 'include' || matchingMode === 'includeIgnoreCase' || matchingMode === 'includeLowerCase') {
     return include(matchingMode === 'includeIgnoreCase' || matchingMode === 'includeLowerCase')
   } else if (matchingMode === 'equals' || matchingMode === 'equalsIgnoreCase') {
@@ -78,6 +98,7 @@ const getMatchFunction = (matchingMode) => {
 module.exports = {
   regexp,
   wildcard,
+  wildcardExact,
   include,
   equals,
   getMatchFunction