botium-core 1.13.17 → 1.13.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botium-core",
-  "version": "1.13.17",
+  "version": "1.13.19",
   "description": "The Selenium for Chatbots",
   "main": "index.js",
   "module": "dist/botium-es.js",
@@ -51,6 +51,7 @@
     "mime-types": "^2.1.35",
     "mkdirp": "^3.0.1",
     "moment": "^2.29.4",
+    "moment-timezone": "^0.5.43",
     "mustache": "^4.2.0",
     "promise-retry": "^2.0.1",
     "promise.allsettled": "^1.0.6",

package/src/BotDriver.js

@@ -3,7 +3,7 @@ const fs = require('fs')
 const path = require('path')
 const async = require('async')
 const { rimraf } = require('rimraf')
-const { mkdirpSync } = require('mkdirp')
+const mkdirp = require('mkdirp')
 const sanitize = require('sanitize-filename')
 const moment = require('moment')
 const randomize = require('randomatic')
@@ -130,7 +130,7 @@ module.exports = class BotDriver {
         (tempDirectoryCreated) => {
           tempDirectory = path.resolve(process.cwd(), this.caps[Capabilities.TEMPDIR], sanitize(`${this.caps[Capabilities.PROJECTNAME]} ${moment().format('YYYYMMDD HHmmss')} ${randomize('Aa0', 5)}`))
           try {
-            mkdirpSync(tempDirectory)
+            mkdirp.sync(tempDirectory)
             tempDirectoryCreated()
           } catch (err) {
             tempDirectoryCreated(new Error(`Unable to create temp directory ${tempDirectory}: ${err.message}`))

package/src/Capabilities.js

@@ -68,6 +68,12 @@ module.exports = {
   SIMPLEREST_POLL_INTERVAL: 'SIMPLEREST_POLL_INTERVAL',
   SIMPLEREST_POLL_TIMEOUT: 'SIMPLEREST_PING_TIMEOUT',
   SIMPLEREST_POLL_UPDATE_CONTEXT: 'SIMPLEREST_POLL_UPDATE_CONTEXT',
+  SIMPLEREST_CONTEXT_IGNORE_JSONPATH: 'SIMPLEREST_CONTEXT_IGNORE_JSONPATH',
+  SIMPLEREST_CONTEXT_IGNORE_MATCH: 'SIMPLEREST_CONTEXT_IGNORE_MATCH',
+  SIMPLEREST_CONTEXT_SKIP_JSONPATH: 'SIMPLEREST_CONTEXT_SKIP_JSONPATH',
+  SIMPLEREST_CONTEXT_SKIP_MATCH: 'SIMPLEREST_CONTEXT_SKIP_MATCH',
+  SIMPLEREST_CONTEXT_CONTINUE_JSONPATH: 'SIMPLEREST_CONTEXT_CONTINUE_JSONPATH',
+  SIMPLEREST_CONTEXT_CONTINUE_MATCH: 'SIMPLEREST_CONTEXT_CONTINUE_MATCH',
   SIMPLEREST_BODY_JSONPATH: 'SIMPLEREST_BODY_JSONPATH',
   SIMPLEREST_RESPONSE_JSONPATH: 'SIMPLEREST_RESPONSE_JSONPATH',
   SIMPLEREST_RESPONSE_HOOK: 'SIMPLEREST_RESPONSE_HOOK',

package/src/containers/BaseContainer.js

@@ -1,6 +1,6 @@
 const util = require('util')
 const async = require('async')
-const { rimraf } = require('rimraf')
+const rimraf = require('rimraf')
 const Bottleneck = require('bottleneck')
 const _ = require('lodash')
 const request = require('request')
@@ -173,9 +173,12 @@ module.exports = class BaseContainer {
         (rimraffed) => {
           if (this.caps[Capabilities.CLEANUPTEMPDIR]) {
             debug(`Cleanup rimrafing temp dir ${this.tempDirectory}`)
-            rimraf(this.tempDirectory)
-              .catch((err) => debug(`Cleanup temp dir ${this.tempDirectory} failed: ${util.inspect(err)}`))
-              .finally(() => rimraffed())
+            try {
+              rimraf.sync(this.tempDirectory)
+              rimraffed()
+            } catch (err) {
+              rimraffed(new Error(`Cleanup temp directory ${this.tempDirectory} failed: ${util.inspect(err)}`))
+            }
           } else {
             rimraffed()
           }

package/src/containers/plugins/SimpleRestContainer.js

@@ -293,6 +293,47 @@ module.exports = class SimpleRestContainer {
       debug(`current session context: ${util.inspect(this.view.context)}`)
     }
 
+    const _isAnyContextJsonPathMatch = (capName, capNameMatch) => {
+      const jsonPaths = getAllCapValues(capName, this.caps)
+      if (jsonPaths.length > 0) {
+        const jsonPathsMatch = getAllCapValues(capNameMatch, this.caps)
+        for (const [index, jsonPath] of jsonPaths.entries()) {
+          const contextNodes = jp.query(this.view.context, jsonPath)
+          if (_.isArray(contextNodes) && contextNodes.length > 0) {
+            if (jsonPathsMatch[index]) {
+              if (contextNodes[0] === jsonPathsMatch[index]) {
+                return {
+                  jsonPath,
+                  match: contextNodes[0]
+                }
+              }
+            } else {
+              return {
+                jsonPath
+              }
+            }
+          }
+        }
+      }
+      return null
+    }
+
+    const ignoreMatch = _isAnyContextJsonPathMatch(Capabilities.SIMPLEREST_CONTEXT_IGNORE_JSONPATH, Capabilities.SIMPLEREST_CONTEXT_IGNORE_MATCH)
+    if (ignoreMatch) {
+      if (ignoreMatch.match) debug(`ignoring response for context match: ${ignoreMatch.jsonPath} = ${ignoreMatch.match}`)
+      else debug(`ignoring response for context: ${ignoreMatch.jsonPath}`)
+      return
+    }
+
+    const skipMatch = _isAnyContextJsonPathMatch(Capabilities.SIMPLEREST_CONTEXT_SKIP_JSONPATH, Capabilities.SIMPLEREST_CONTEXT_SKIP_MATCH)
+    if (skipMatch) {
+      if (skipMatch.match) debug(`skipping response for context match: ${skipMatch.jsonPath} = ${skipMatch.match}`)
+      else debug(`skipping response for context: ${skipMatch.jsonPath}`)
+
+      setTimeout(() => this._doRequest({ messageText: '' }, true, true), 0)
+      return
+    }
+
     const result = []
     if (isFromUser) {
       const _extractFrom = (root, jsonPaths) => {
@@ -442,6 +483,14 @@ module.exports = class SimpleRestContainer {
         }
       }
     }
+
+    const continueMatch = _isAnyContextJsonPathMatch(Capabilities.SIMPLEREST_CONTEXT_CONTINUE_JSONPATH, Capabilities.SIMPLEREST_CONTEXT_CONTINUE_MATCH)
+    if (continueMatch) {
+      if (continueMatch.match) debug(`continue with next response for context match: ${continueMatch.jsonPath} = ${continueMatch.match}`)
+      else debug(`continue with next response for context: ${continueMatch.jsonPath}`)
+
+      setTimeout(() => this._doRequest({ messageText: '' }, true, true), 0)
+    }
     return result
   }
 

package/src/scripting/Convo.js

@@ -356,6 +356,7 @@ class Convo {
               throw failErr
             }
           } else if (convoStep.sender === 'bot') {
+            const previousWaitForBotSays = waitForBotSays
             if (waitForBotSays) {
               botMsg = null
             } else {
@@ -404,6 +405,26 @@ class Convo {
               throw failErr
             }
 
+            if (convoStep.conditional) {
+              const nextConvoStep = this.conversation[i + 1]
+
+              if (!previousWaitForBotSays) {
+                skipTranscriptStep = true
+              }
+              waitForBotSays = false
+              if (!nextConvoStep || nextConvoStep.sender !== 'bot' || !nextConvoStep.logicHooks || !nextConvoStep.logicHooks.some(lh => lh.name.toUpperCase().startsWith('CONDITIONAL_STEP'))) {
+                waitForBotSays = true
+              } else {
+                const conditionalLogicHook = convoStep.logicHooks.find(lh => lh.name.startsWith('CONDITIONAL_STEP'))
+                const nextConditionalLogicHook = nextConvoStep.logicHooks.find(lh => lh.name.startsWith('CONDITIONAL_STEP'))
+                waitForBotSays = conditionalLogicHook.args[1] !== nextConditionalLogicHook.args[1]
+              }
+
+              if (convoStep.conditional.skip) {
+                continue
+              }
+            }
+
             if (!botMsg || (!botMsg.messageText && !botMsg.media && !botMsg.buttons && !botMsg.cards && !botMsg.sourceData && !botMsg.nlp)) {
               const failErr = new BotiumError(`${this.header.name}/${convoStep.stepTag}: bot says nothing`)
               debug(failErr)

package/src/scripting/ScriptingProvider.js

@@ -940,10 +940,16 @@ module.exports = class ScriptingProvider {
       convoFilter: null
     }, options)
     const expandedConvos = []
+    // The globalContext is going to keep the data even if the Object.assign which happening to create the myContext in _expandConvo function
+    const context = {
+      globalContext: {
+        totalConvoCount: 0
+      }
+    }
     debug(`ExpandConvos - Using utterances expansion mode: ${this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE]}`)
     this.convos.forEach((convo) => {
       convo.expandPartialConvos()
-      for (const expanded of this._expandConvo(convo, options, {})) {
+      for (const expanded of this._expandConvo(convo, options, context)) {
         expanded.header.assertionCount = this.GetAssertionCount(expanded)
         if (options.justHeader) {
           const ConvoWithOnlyHeader = {
@@ -959,6 +965,7 @@ module.exports = class ScriptingProvider {
       }
     })
     this.convos = expandedConvos
+    this.totalConvoCount = context.globalContext.totalConvoCount
     if (!options.justHeader) {
       this._sortConvos()
     } else {
@@ -971,17 +978,24 @@ module.exports = class ScriptingProvider {
       // drop unwanted convos
       convoFilter: null
     }, options)
+    // The globalContext is going to keep the data even if the Object.assign which happening to create the myContext in _expandConvo function
+    const context = {
+      globalContext: {
+        totalConvoCount: 0
+      }
+    }
     debug(`ExpandConvos - Using utterances expansion mode: ${this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE]}`)
     // creating a nested generator, calling the other.
     // We hope this.convos does not changes while this iterator is used
     const _convosIterable = function * (options) {
       for (const convo of this.convos) {
         convo.expandPartialConvos()
-        yield * this._expandConvo(convo, options, {})
+        yield * this._expandConvo(convo, options, context)
       }
     }.bind(this)
 
     this.convosIterable = _convosIterable(options)
+    this.totalConvoCount = context.globalContext.totalConvoCount
   }
 
   /**
@@ -1173,6 +1187,9 @@ module.exports = class ScriptingProvider {
       }
     } else {
       const expanded = Object.assign(_.cloneDeep(currentConvo), { conversation: _.cloneDeep(convoStepsStack) })
+      if (!_.isNil(_.get(context, 'globalContext.totalConvoCount'))) {
+        context.globalContext.totalConvoCount++
+      }
       if (!options.convoFilter || options.convoFilter(expanded)) {
         yield expanded
       }

package/src/scripting/logichook/LogicHookConsts.js

@@ -57,7 +57,11 @@ module.exports = {
     { name: 'ASSIGN_SCRIPTING_MEMORY', className: 'AssignScriptingMemoryLogicHook' },
     { name: 'UPDATE_CUSTOM', className: 'UpdateCustomLogicHook' },
     { name: 'SKIP_BOT_UNCONSUMED', className: 'ClearQueueLogicHook' },
-    { name: LOGIC_HOOK_INCLUDE, className: 'IncludeLogicHook' }
+    { name: LOGIC_HOOK_INCLUDE, className: 'IncludeLogicHook' },
+    { name: 'CONDITIONAL_STEP_TIME_BASED', className: 'ConditionalTimeBasedLogicHook' },
+    { name: 'CONDITIONAL_STEP_BUSINESS_HOURS', className: 'ConditionalBusinessHoursLogicHook' },
+    { name: 'CONDITIONAL_STEP_CAPABILITY_VALUE_BASED', className: 'ConditionalCapabilityValueBasedLogicHook' },
+    { name: 'CONDITIONAL_STEP_JSON_PATH_BASED', className: 'ConditionalJsonPathBasedLogicHook.js' }
   ],
   DEFAULT_USER_INPUTS: [
     { name: 'BUTTON', className: 'ButtonInput' },

package/src/scripting/logichook/asserter/ButtonsAsserter.js

@@ -1,3 +1,4 @@
+const _ = require('lodash')
 const { SCRIPTING_NORMALIZE_TEXT } = require('../../../Capabilities')
 const { BotiumError } = require('../../BotiumError')
 const { buttonsFromMsg } = require('../helpers')
@@ -11,17 +12,29 @@ module.exports = class ButtonsAsserter {
   }
 
   _evalButtons (args, botMsg) {
-    const allButtons = buttonsFromMsg(botMsg, true).map(b => b.text).filter(b => b).map(b => normalizeText(b, !!this.caps[SCRIPTING_NORMALIZE_TEXT]))
+    const allButtons = buttonsFromMsg(botMsg, true).map(b => ({ text: b.text, payload: b.payload })).filter(b => b).map(b => ({ text: normalizeText(b.text, !!this.caps[SCRIPTING_NORMALIZE_TEXT]), payload: b.payload }))
     if (!args || args.length === 0) {
-      return { allButtons, buttonsNotFound: [], buttonsFound: allButtons }
+      return { allButtons, buttonsNotFound: [], buttonsFound: allButtons.map(b => b.text) }
     }
     const buttonsNotFound = []
     const buttonsFound = []
+    const stringifyPayload = (payload) => {
+      if (_.isNil(payload)) {
+        return ''
+      }
+      try {
+        return JSON.stringify(JSON.parse(payload))
+      } catch (e) {
+        return JSON.stringify(payload)
+      }
+    }
     for (let i = 0; i < (args || []).length; i++) {
-      if (allButtons.findIndex(b => this.context.Match(b, normalizeText(args[i], !!this.caps[SCRIPTING_NORMALIZE_TEXT]))) < 0) {
-        buttonsNotFound.push(args[i])
-      } else {
+      const matchByText = allButtons.some(b => this.context.Match(b.text, normalizeText(args[i], !!this.caps[SCRIPTING_NORMALIZE_TEXT])))
+      const matchByPayload = allButtons.some(b => this.context.Match(stringifyPayload(b.payload), normalizeText(args[i], !!this.caps[SCRIPTING_NORMALIZE_TEXT])))
+      if (matchByText || matchByPayload) {
         buttonsFound.push(args[i])
+      } else {
+        buttonsNotFound.push(args[i])
       }
     }
     return { allButtons, buttonsNotFound, buttonsFound }
@@ -42,7 +55,7 @@ module.exports = class ButtonsAsserter {
           cause: {
             not: true,
             expected: args,
-            actual: allButtons,
+            actual: JSON.stringify(allButtons, null, 2),
             diff: buttonsFound
           }
         }
@@ -67,7 +80,7 @@ module.exports = class ButtonsAsserter {
             cause: {
               not: false,
               expected: args,
-              actual: allButtons,
+              actual: JSON.stringify(allButtons, null, 2),
               diff: buttonsNotFound
             }
           }
@@ -85,7 +98,7 @@ module.exports = class ButtonsAsserter {
             cause: {
               not: false,
               expected: args,
-              actual: allButtons,
+              actual: JSON.stringify(allButtons, null, 2),
               diff: buttonsNotFound
             }
           }

package/src/scripting/logichook/logichooks/ClearQueueLogicHook.js

@@ -1,4 +1,3 @@
-
 module.exports = class ClearQueueLogicHook {
   constructor (context, caps = {}) {
     this.context = context

package/src/scripting/logichook/logichooks/ConditionalBusinessHoursLogicHook.js

@@ -0,0 +1,56 @@
+const util = require('util')
+const moment = require('moment-timezone')
+const debug = require('debug')('botium-core-ConditionalTimeBasedLogicHook')
+
+module.exports = class ConditionalBusinessHoursLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  _isBetween ({ now, start, end, days, timeZone }) {
+    if ((!start || !end) && (!days || days.length === 0)) {
+      throw new Error('ConditionalBusinessHoursLogicHook: Either start and end time or days array needs to be specified in params')
+    }
+    now.tz(timeZone)
+    if (days && days.length > 0 && !days.includes(now.format('dddd'))) {
+      return false
+    }
+
+    if (!start && !end && days && days.length > 0 && days.includes(now.format('dddd'))) {
+      return true
+    }
+
+    const momentStartTime = moment(start, 'HH:mm')
+    const startTime = now.clone().set({ hour: momentStartTime.hour(), minute: momentStartTime.minute() })
+    startTime.tz(timeZone)
+    const momentEndTime = moment(end, 'HH:mm')
+    const endTime = now.clone().set({ hour: momentEndTime.hour(), minute: momentEndTime.minute() })
+    endTime.tz(timeZone)
+    if (startTime.isSameOrAfter(endTime)) {
+      if (now.isSameOrAfter(startTime)) {
+        endTime.add(1, 'days')
+      } else {
+        startTime.add(-1, 'days')
+      }
+    }
+    return now.isBetween(startTime, endTime, 'minutes', '[]')
+  }
+
+  onBotPrepare ({ convo, convoStep, args }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalBusinessHoursLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    params.now = moment()
+    convoStep.conditional.skip = !this._isBetween(params)
+    debug(`ConditionalBusinessHoursLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+  }
+}

package/src/scripting/logichook/logichooks/ConditionalCapabilityValueBasedLogicHook.js

@@ -0,0 +1,37 @@
+const util = require('util')
+const jp = require('jsonpath')
+const _ = require('lodash')
+const debug = require('debug')('botium-core-ConditionalCapabilityValueBasedLogicHook')
+
+module.exports = class ConditionalCapabilityValueBasedLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  _isCapabilityValueEqual ({ capabilityName, jsonPath, value }) {
+    if (jsonPath) {
+      const capabilityObject = _.isObject(this.caps[capabilityName]) ? this.caps[capabilityName] : JSON.parse(this.caps[capabilityName])
+      const values = jp.query(capabilityObject, jsonPath)
+      return !!(values && values.length > 0 && values.includes(value))
+    } else {
+      return this.caps[capabilityName] === value
+    }
+  }
+
+  onBotPrepare ({ convo, convoStep, args }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalCapabilityValueBasedLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    convoStep.conditional.skip = !this._isCapabilityValueEqual(params)
+    debug(`ConditionalCapabilityValueBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+  }
+}

package/src/scripting/logichook/logichooks/ConditionalJsonPathBasedLogicHook.js

@@ -0,0 +1,31 @@
+const util = require('util')
+const jp = require('jsonpath')
+const debug = require('debug')('botium-core-ConditionalJsonPathBasedLogicHook')
+
+module.exports = class ConditionalJsonPathBasedLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  onBotPrepare ({ convo, convoStep, args, botMsg }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalJsonPathBasedLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    let skip = true
+    if (params.jsonPath) {
+      const values = jp.query(botMsg, params.jsonPath)
+      skip = !(values && values.length > 0 && values.includes(params.value))
+    }
+    convoStep.conditional.skip = skip
+    debug(`ConditionalJsonPathBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+  }
+}

package/src/scripting/logichook/logichooks/ConditionalTimeBasedLogicHook.js

@@ -0,0 +1,46 @@
+const util = require('util')
+const moment = require('moment-timezone')
+const debug = require('debug')('botium-core-ConditionalTimeBasedLogicHook')
+
+module.exports = class ConditionalTimeBasedLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  _isBetween ({ now, start, end, timeZone }) {
+    now.tz(timeZone)
+    const momentStartTime = moment(start, 'HH:mm')
+    const startTime = now.clone().set({ hour: momentStartTime.hour(), minute: momentStartTime.minute() })
+    startTime.tz(timeZone)
+    const momentEndTime = moment(end, 'HH:mm')
+    const endTime = now.clone().set({ hour: momentEndTime.hour(), minute: momentEndTime.minute() })
+    endTime.tz(timeZone)
+
+    if (startTime.isSameOrAfter(endTime)) {
+      if (now.isSameOrAfter(startTime)) {
+        endTime.add(1, 'days')
+      } else {
+        startTime.add(-1, 'days')
+      }
+    }
+    return now.isBetween(startTime, endTime, 'minutes', '[]')
+  }
+
+  onBotPrepare ({ convo, convoStep, args }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalTimeBasedLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    params.now = moment()
+    convoStep.conditional.skip = !this._isBetween(params)
+    debug(`ConditionalTimeBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+  }
+}

package/test/connectors/logicHook.js

@@ -1,4 +1,3 @@
-
 module.exports = ({ requestOptions, context }) => {
   let counter = 1
   requestOptions.body = { bodyFieldRequestHook: counter++ }

package/test/connectors/simplerest.spec.js

@@ -319,7 +319,6 @@ describe('connectors.simplerest', function () {
       scope2.persist(false)
     })
   })
-
   describe('build', function () {
     it('should build JSON GET url', async function () {
       const myCaps = Object.assign({}, myCapsGet)
@@ -997,7 +996,6 @@ describe('connectors.simplerest', function () {
       assert.deepEqual(values, ['$.1', '$.2', '$.3', '$.4'])
     })
   })
-
   describe('useresponse', function () {
     beforeEach(async function () {
       this.init = async (caps) => {
@@ -1151,7 +1149,6 @@ describe('connectors.simplerest', function () {
       }
     })
   })
-
   describe('inbound', function () {
     it('should accept inbound message with matching jsonpath', async function () {
       const myCaps = Object.assign({}, myCapsGet)
@@ -1249,7 +1246,6 @@ describe('connectors.simplerest', function () {
       return result
     })
   })
-
   describe('polling', function () {
     it('should poll HTTP url', async function () {
       const caps = {
@@ -1313,4 +1309,83 @@ describe('connectors.simplerest', function () {
       scope.persist(false)
     }).timeout(5000)
   })
+  describe('flow', function () {
+    it('should ignore matching message', async function () {
+      const caps = {
+        [Capabilities.CONTAINERMODE]: 'simplerest',
+        [Capabilities.WAITFORBOTTIMEOUT]: 1000,
+        [Capabilities.SIMPLEREST_URL]: 'https://mock.com/flowignore',
+        [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: ['$.text'],
+        [Capabilities.SIMPLEREST_CONTEXT_IGNORE_JSONPATH]: '$.ignore',
+        [Capabilities.SIMPLEREST_CONTEXT_IGNORE_MATCH]: 'Y'
+      }
+      const scope = nock('https://mock.com')
+        .get('/flowignore').reply(200, { text: 'ignore it', ignore: 'Y' })
+
+      const driver = new BotDriver(caps)
+      const container = await driver.Build()
+      await container.Start()
+
+      await container.UserSays({ text: 'hallo' })
+      try {
+        await container.WaitBotSays()
+        assert.fail('expected response to be ignored')
+      } catch (err) {
+        assert.equal(err.message, 'Bot did not respond within 1s')
+      }
+      await container.Stop()
+      await container.Clean()
+      scope.persist(false)
+    })
+    it('should skip matching message', async function () {
+      const caps = {
+        [Capabilities.CONTAINERMODE]: 'simplerest',
+        [Capabilities.SIMPLEREST_URL]: 'https://mock.com/flowskip',
+        [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: ['$.text'],
+        [Capabilities.SIMPLEREST_CONTEXT_SKIP_JSONPATH]: '$.skip',
+        [Capabilities.SIMPLEREST_CONTEXT_SKIP_MATCH]: 'Y'
+      }
+      const scope = nock('https://mock.com')
+        .get('/flowskip').reply(200, { text: 'skip it', skip: 'Y' })
+        .get('/flowskip').reply(200, { text: 'not skip it', skip: 'N' })
+
+      const driver = new BotDriver(caps)
+      const container = await driver.Build()
+      await container.Start()
+
+      await container.UserSays({ text: 'hello' })
+      const botMsg = await container.WaitBotSays()
+      assert.equal(botMsg.messageText, 'not skip it')
+
+      await container.Stop()
+      await container.Clean()
+      scope.persist(false)
+    })
+    it('should continue on matching message', async function () {
+      const caps = {
+        [Capabilities.CONTAINERMODE]: 'simplerest',
+        [Capabilities.SIMPLEREST_URL]: 'https://mock.com/flowcontinue',
+        [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: ['$.text'],
+        [Capabilities.SIMPLEREST_CONTEXT_CONTINUE_JSONPATH]: '$.continue',
+        [Capabilities.SIMPLEREST_CONTEXT_CONTINUE_MATCH]: 'Y'
+      }
+      const scope = nock('https://mock.com')
+        .get('/flowcontinue').reply(200, { text: 'continue it', continue: 'Y' })
+        .get('/flowcontinue').reply(200, { text: 'not continue it', continue: 'N' })
+
+      const driver = new BotDriver(caps)
+      const container = await driver.Build()
+      await container.Start()
+
+      await container.UserSays({ text: 'hello' })
+      const botMsg1 = await container.WaitBotSays()
+      assert.equal(botMsg1.messageText, 'continue it')
+      const botMsg2 = await container.WaitBotSays()
+      assert.equal(botMsg2.messageText, 'not continue it')
+
+      await container.Stop()
+      await container.Clean()
+      scope.persist(false)
+    })
+  })
 })