botium-core 1.11.14 → 1.12.1

package/src/scripting/ScriptingProvider.js

@@ -464,11 +464,33 @@ module.exports = class ScriptingProvider {
     return { convos: dirConvos, utterances: dirUtterances, pconvos: dirPartialConvos, scriptingMemories: dirScriptingMemories }
   }
 
+  ReadScriptFromBuffer (scriptBuffer, scriptingFormat, scriptingTypes = null) {
+    if (_.isString(scriptingTypes)) scriptingTypes = [scriptingTypes]
+    if (_.isArray(scriptingTypes) && scriptingTypes.length === 0) scriptingTypes = null
+
+    const result = {
+      convos: [],
+      utterances: [],
+      pconvos: [],
+      scriptingMemories: []
+    }
+    if (!scriptingTypes || scriptingTypes.includes(Constants.SCRIPTING_TYPE_UTTERANCES)) {
+      result.utterances = this.Compile(scriptBuffer, scriptingFormat, Constants.SCRIPTING_TYPE_UTTERANCES)
+    }
+    if (!scriptingTypes || scriptingTypes.includes(Constants.SCRIPTING_TYPE_PCONVO)) {
+      result.pconvos = this.Compile(scriptBuffer, scriptingFormat, Constants.SCRIPTING_TYPE_PCONVO)
+    }
+    if (!scriptingTypes || scriptingTypes.includes(Constants.SCRIPTING_TYPE_CONVO)) {
+      result.convos = this.Compile(scriptBuffer, scriptingFormat, Constants.SCRIPTING_TYPE_CONVO)
+    }
+    if (!scriptingTypes || scriptingTypes.includes(Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)) {
+      result.scriptingMemories = this.Compile(scriptBuffer, scriptingFormat, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)
+    }
+    return result
+  }
+
   ReadScript (convoDir, filename) {
-    let fileConvos = []
-    let fileUtterances = []
-    let filePartialConvos = []
-    let fileScriptingMemories = []
+    let result = {}
 
     try {
       let scriptBuffer = fs.readFileSync(path.resolve(convoDir, filename))
@@ -487,36 +509,25 @@ module.exports = class ScriptingProvider {
       }
 
       if (filename.endsWith('.xlsx') || filename.endsWith('.xlsm')) {
-        fileUtterances = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_XSLX, Constants.SCRIPTING_TYPE_UTTERANCES)
-        filePartialConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_XSLX, Constants.SCRIPTING_TYPE_PCONVO)
-        fileConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_XSLX, Constants.SCRIPTING_TYPE_CONVO)
-        fileScriptingMemories = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_XSLX, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_XSLX, [Constants.SCRIPTING_TYPE_UTTERANCES, Constants.SCRIPTING_TYPE_PCONVO, Constants.SCRIPTING_TYPE_CONVO, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY])
       } else if (filename.endsWith('.convo.txt')) {
-        fileConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_CONVO)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_CONVO)
       } else if (filename.endsWith('.pconvo.txt')) {
-        filePartialConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_PCONVO)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_PCONVO)
       } else if (filename.endsWith('.utterances.txt')) {
-        fileUtterances = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_UTTERANCES)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_UTTERANCES)
       } else if (filename.endsWith('.scriptingmemory.txt')) {
-        fileScriptingMemories = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)
       } else if (filename.endsWith('.convo.csv')) {
-        fileConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_CSV, Constants.SCRIPTING_TYPE_CONVO)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_CSV, Constants.SCRIPTING_TYPE_CONVO)
       } else if (filename.endsWith('.pconvo.csv')) {
-        filePartialConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_CSV, Constants.SCRIPTING_TYPE_PCONVO)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_CSV, Constants.SCRIPTING_TYPE_PCONVO)
       } else if (filename.endsWith('.yaml') || filename.endsWith('.yml')) {
-        fileUtterances = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_YAML, Constants.SCRIPTING_TYPE_UTTERANCES)
-        filePartialConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_YAML, Constants.SCRIPTING_TYPE_PCONVO)
-        fileConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_YAML, Constants.SCRIPTING_TYPE_CONVO)
-        fileScriptingMemories = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_YAML, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_YAML, [Constants.SCRIPTING_TYPE_UTTERANCES, Constants.SCRIPTING_TYPE_PCONVO, Constants.SCRIPTING_TYPE_CONVO, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY])
       } else if (filename.endsWith('.json')) {
-        fileUtterances = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_JSON, Constants.SCRIPTING_TYPE_UTTERANCES)
-        filePartialConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_JSON, Constants.SCRIPTING_TYPE_PCONVO)
-        fileConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_JSON, Constants.SCRIPTING_TYPE_CONVO)
-        fileScriptingMemories = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_JSON, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_JSON, [Constants.SCRIPTING_TYPE_UTTERANCES, Constants.SCRIPTING_TYPE_PCONVO, Constants.SCRIPTING_TYPE_CONVO, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY])
       } else if (filename.endsWith('.markdown') || filename.endsWith('.md')) {
-        fileUtterances = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_MARKDOWN, Constants.SCRIPTING_TYPE_UTTERANCES)
-        fileConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_MARKDOWN, Constants.SCRIPTING_TYPE_CONVO)
-        filePartialConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_MARKDOWN, Constants.SCRIPTING_TYPE_PCONVO)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_MARKDOWN, [Constants.SCRIPTING_TYPE_UTTERANCES, Constants.SCRIPTING_TYPE_PCONVO, Constants.SCRIPTING_TYPE_CONVO])
       } else {
         debug(`ReadScript - dropped file: ${filename}, filename not supported`)
       }
@@ -526,42 +537,40 @@ module.exports = class ScriptingProvider {
     }
 
     // Compilers saved the convos, and we alter here the saved version too
-    if (fileConvos) {
-      fileConvos.forEach((fileConvo) => {
+    if (result.convos && result.convos.length > 0) {
+      result.convos.forEach((fileConvo) => {
         fileConvo.sourceTag = { convoDir, filename }
         if (!fileConvo.header.name) {
           fileConvo.header.name = filename
         }
       })
       const isSkip = (c) => c.header.name && skipPattern.test(c.header.name.toLowerCase())
-      fileConvos.filter(c => isSkip(c)).forEach(c => debug(`ReadScript - skipping convo '${c.header.name}'`))
-      fileConvos = fileConvos.filter(c => !isSkip(c))
+      result.convos.filter(c => isSkip(c)).forEach(c => debug(`ReadScript - skipping convo '${c.header.name}'`))
+      result.convos = result.convos.filter(c => !isSkip(c))
     }
-    if (filePartialConvos) {
-      filePartialConvos.forEach((filePartialConvo) => {
+    if (result.pconvos && result.pconvos.length > 0) {
+      result.pconvos.forEach((filePartialConvo) => {
         filePartialConvo.sourceTag = { convoDir, filename }
         if (!filePartialConvo.header.name) {
           filePartialConvo.header.name = filename
         }
       })
     }
-    if (fileScriptingMemories && fileScriptingMemories.length) {
-      fileScriptingMemories.forEach((scriptingMemory) => {
+    if (result.scriptingMemories && result.scriptingMemories.length > 0) {
+      result.scriptingMemories.forEach((scriptingMemory) => {
         scriptingMemory.sourceTag = { filename }
       })
     }
-
-    if (fileUtterances) {
-      this.fileUtterances = this._tagAndCleanupUtterances(fileUtterances, convoDir, filename)
+    if (result.utterances) {
+      result.utterances = this._tagAndCleanupUtterances(result.utterances, convoDir, filename)
     }
-    return { convos: fileConvos, utterances: fileUtterances, pconvos: filePartialConvos, scriptingMemories: fileScriptingMemories }
+    return { convos: result.convos || [], utterances: result.utterances || [], pconvos: result.pconvos || [], scriptingMemories: result.scriptingMemories || [] }
   }
 
   _tagAndCleanupUtterances (utteranceFiles, convoDir, filename) {
     return utteranceFiles.map((fileUtt) => {
       fileUtt.sourceTag = { convoDir, filename }
-      fileUtt.utterances = fileUtt.utterances
-        .filter(u => u)
+      fileUtt.utterances = fileUtt.utterances.filter(u => u)
       return fileUtt
     })
   }
@@ -752,6 +761,7 @@ module.exports = class ScriptingProvider {
 
     debug(`ExpandScriptingMemoryToConvos - ${convosExpandedAll.length} convo expanded, added to convos (${this.convos.length}). Result ${convosExpandedAll.length + this.convos.length} convo`)
     this.convos = this.convos.concat(convosExpandedAll)
+    this._sortConvos()
   }
 
   ExpandUtterancesToConvos ({ useNameAsIntent, incomprehensionUtt } = {}) {
@@ -787,6 +797,11 @@ module.exports = class ScriptingProvider {
         conversation: [
           {
             sender: 'me',
+            logicHooks: [
+              {
+                name: 'SKIP_BOT_UNCONSUMED'
+              }
+            ],
             messageText: utt.name,
             stepTag: 'Step 1 - tell utterance'
           },
@@ -944,7 +959,7 @@ module.exports = class ScriptingProvider {
         }
       }
     } else {
-      expandedConvos.push(Object.assign(_.cloneDeep(currentConvo), { conversation: convoStepsStack }))
+      expandedConvos.push(Object.assign(_.cloneDeep(currentConvo), { conversation: _.cloneDeep(convoStepsStack) }))
     }
   }
 

package/src/scripting/helper.js

@@ -1,6 +1,8 @@
 const _ = require('lodash')
 const isJSON = require('is-json')
 
+const { E_SCRIPTING_MEMORY_COLUMN_MODE } = require('../Enums')
+
 const normalizeText = (str, doCleanup) => {
   if (str && _.isArray(str)) {
     str = str.join(' ')
@@ -72,7 +74,7 @@ const toString = (value) => {
 }
 
 const flatString = (str) => {
-  return str.split('\n').map(s => s.trim()).join(' ')
+  return str ? str.split('\n').map(s => s.trim()).join(' ') : ''
 }
 
 const linesToConvoStep = (lines, sender, context, eol, singleLineMode = false) => {
@@ -439,7 +441,7 @@ const convoStepToLines = (step) => {
     if (step.messageText) {
       lines.push((step.optional ? '?' : '') + (step.not ? '!' : '') + step.messageText)
     }
-    if (step.buttons && step.buttons.length > 0) lines.push('BUTTONS ' + step.buttons.map(b => flatString(b.text)).join('|'))
+    if (step.buttons && step.buttons.length > 0) lines.push('BUTTONS ' + step.buttons.filter(b => b.text).map(b => flatString(b.text)).join('|'))
     if (step.media && step.media.length > 0) lines.push('MEDIA ' + step.media.filter(m => !m.buffer && m.mediaUri).map(m => m.mediaUri).join('|'))
     if (step.cards && step.cards.length > 0) {
       step.cards.forEach(c => {
@@ -449,7 +451,7 @@ const convoStepToLines = (step) => {
         if (c.content) cardTexts = cardTexts.concat(_.isArray(c.content) ? c.content : [c.content])
         if (cardTexts.length > 0) lines.push('CARDS ' + cardTexts.map(c => flatString(c)).join('|'))
 
-        if (c.buttons && c.buttons.length > 0) lines.push('BUTTONS ' + c.buttons.map(b => flatString(b.text)).join('|'))
+        if (c.buttons && c.buttons.length > 0) lines.push('BUTTONS ' + c.buttons.filter(b => b.text).map(b => flatString(b.text)).join('|'))
         if (c.image && !c.image.buffer && c.image.mediaUri) lines.push('MEDIA ' + c.image.mediaUri)
       })
     }
@@ -463,6 +465,56 @@ const convoStepToLines = (step) => {
   return lines.map(l => l.trim())
 }
 
+const linesToScriptingMemories = (lines, columnMode = null) => {
+  const guessScriptingMemoryColumnMode = (lines) => {
+    if (lines && lines.length > 1) {
+      if (lines[1].trim().startsWith('$')) return E_SCRIPTING_MEMORY_COLUMN_MODE.TESTCASENAMES
+    }
+    return E_SCRIPTING_MEMORY_COLUMN_MODE.VARNAMES
+  }
+  columnMode = columnMode || guessScriptingMemoryColumnMode(lines)
+
+  const scriptingMemories = []
+
+  if (columnMode === E_SCRIPTING_MEMORY_COLUMN_MODE.TESTCASENAMES) {
+    const caseNames = lines[0].split('|').map((name) => name.trim()).slice(1)
+
+    const varNames = []
+    const varValues = []
+    for (let row = 1; row < lines.length; row++) {
+      if (!lines[row] || lines[row].length === 0) continue
+      const rawRow = lines[row].split('|').map((name) => name.trim())
+      varNames.push(rawRow[0])
+      varValues.push(rawRow.slice(1))
+    }
+    for (let caseIndex = 0; caseIndex < caseNames.length; caseIndex++) {
+      const caseName = caseNames[caseIndex]
+
+      const values = varNames.reduce((agg, varName, varIndex) => {
+        agg[varName] = varValues[varIndex][caseIndex] || null
+        return agg
+      }, {})
+      const scriptingMemory = { header: { name: caseName }, values: values }
+      scriptingMemories.push(scriptingMemory)
+    }
+  } else {
+    const varNames = lines[0].split('|').map((name) => name.trim()).slice(1)
+    for (let row = 1; row < lines.length; row++) {
+      if (!lines[row] || lines[row].length === 0) continue
+      const rawRow = lines[row].split('|').map((name) => name.trim())
+      const caseName = rawRow[0]
+      const values = rawRow.slice(1)
+      const varValues = {}
+      for (let varIndex = 0; varIndex < varNames.length; varIndex++) {
+        varValues[varNames[varIndex]] = values[varIndex]
+      }
+      const scriptingMemory = { header: { name: caseName }, values: varValues }
+      scriptingMemories.push(scriptingMemory)
+    }
+  }
+  return scriptingMemories
+}
+
 module.exports = {
   normalizeText,
   splitStringInNonEmptyLines,
@@ -475,5 +527,6 @@ module.exports = {
   convoStepToObject,
   validSenders,
   validateSender,
-  validateConvo
+  validateConvo,
+  linesToScriptingMemories
 }

package/src/scripting/logichook/LogicHookConsts.js

@@ -33,6 +33,10 @@ module.exports = {
     { name: 'TEXT_WILDCARD_ANY_IC', className: 'TextWildcardAnyICAsserter' },
     { name: 'TEXT_WILDCARD_ALL', className: 'TextWildcardAllAsserter' },
     { name: 'TEXT_WILDCARD_ALL_IC', className: 'TextWildcardAllICAsserter' },
+    { name: 'TEXT_WILDCARDEXACT_ANY', className: 'TextWildcardExactAnyAsserter' },
+    { name: 'TEXT_WILDCARDEXACT_ANY_IC', className: 'TextWildcardExactAnyICAsserter' },
+    { name: 'TEXT_WILDCARDEXACT_ALL', className: 'TextWildcardExactAllAsserter' },
+    { name: 'TEXT_WILDCARDEXACT_ALL_IC', className: 'TextWildcardExactAllICAsserter' },
     { name: 'TEXT_REGEXP_ANY', className: 'TextRegexpAnyAsserter' },
     { name: 'TEXT_REGEXP_ANY_IC', className: 'TextRegexpAnyICAsserter' },
     { name: 'TEXT_REGEXP_ALL', className: 'TextRegexpAllAsserter' },

package/src/scripting/logichook/LogicHookUtils.js

@@ -240,6 +240,8 @@ module.exports = class LogicHookUtils {
           return CheckClass({ ref, ...this.buildScriptContext }, this.caps, args)
         } else if (isClass(CheckClass.PluginClass)) {
           return new CheckClass.PluginClass({ ref, ...this.buildScriptContext }, this.caps, args)
+        } else if (_.isFunction(CheckClass.PluginClass)) {
+          return CheckClass.PluginClass({ ref, ...this.buildScriptContext }, this.caps, args)
         } else {
           throw new Error(`${src} class or function expected`)
         }

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

@@ -118,7 +118,7 @@ module.exports = class JsonPathAsserter {
               }
             },
             cause: {
-              expected: assert || (args && `any element for ${args.join('|')}`) || (!args && `any element in ${path}`),
+              expected: assert || ((args && args.length > 0) && `any element for ${args.join('|')}`) || ((!args || args.length === 0) && `any element in ${path}`),
               actual: null,
               path
             }

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

@@ -0,0 +1,8 @@
+const BaseTextAsserter = require('./BaseTextAsserter')
+const MatchFunctions = require('../../MatchFunctions')
+
+module.exports = class TextWildcardExactAnyAsserter extends BaseTextAsserter {
+  constructor (context, caps = {}) {
+    super(context, caps, MatchFunctions.wildcardExact(false), 'all')
+  }
+}

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

@@ -0,0 +1,8 @@
+const BaseTextAsserter = require('./BaseTextAsserter')
+const MatchFunctions = require('../../MatchFunctions')
+
+module.exports = class TextWildcardExactAnyAsserter extends BaseTextAsserter {
+  constructor (context, caps = {}) {
+    super(context, caps, MatchFunctions.wildcardExact(true), 'all')
+  }
+}

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

@@ -0,0 +1,8 @@
+const BaseTextAsserter = require('./BaseTextAsserter')
+const MatchFunctions = require('../../MatchFunctions')
+
+module.exports = class TextWildcardExactAnyAsserter extends BaseTextAsserter {
+  constructor (context, caps = {}) {
+    super(context, caps, MatchFunctions.wildcardExact(false), 'any')
+  }
+}

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

@@ -0,0 +1,8 @@
+const BaseTextAsserter = require('./BaseTextAsserter')
+const MatchFunctions = require('../../MatchFunctions')
+
+module.exports = class TextWildcardExactAnyAsserter extends BaseTextAsserter {
+  constructor (context, caps = {}) {
+    super(context, caps, MatchFunctions.wildcardExact(true), 'any')
+  }
+}

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

@@ -9,7 +9,7 @@ module.exports = class ClearQueueLogicHook {
     container._EmptyQueue()
   }
 
-  onMeEnd ({ container }) {
+  onMeStart ({ container }) {
     container._EmptyQueue()
   }
 

package/src/scripting/logichook/userinput/MediaInput.js

@@ -20,6 +20,9 @@ module.exports = class MediaInput {
   }
 
   _getResolvedUri (uri, convo) {
+    if (uri.startsWith('data:')) {
+      return new url.URL(uri)
+    }
     if (this.globalArgs && this.globalArgs.baseUris) {
       const baseUrisSelector = _.get(convo, this.globalArgs.baseSelector || DEFAULT_BASE_SELECTOR)
       if (baseUrisSelector && this.globalArgs.baseUris[baseUrisSelector]) {
@@ -134,6 +137,8 @@ module.exports = class MediaInput {
             }
           })
         })
+      } else if (uri.protocol === 'data:') {
+        return Buffer.from(uri.href.split(',')[1], 'base64')
       }
     }
   }
@@ -142,6 +147,13 @@ module.exports = class MediaInput {
     return arg.indexOf('*') >= 0
   }
 
+  _mime (arg) {
+    if (arg.startsWith('data:')) {
+      return arg.substring(arg.indexOf(':') + 1, arg.indexOf(';'))
+    }
+    return mime.lookup(arg)
+  }
+
   expandConvo ({ convo, convoStep, args }) {
     const hasWildcard = args.findIndex(a => this._isWildcard(a)) >= 0
 
@@ -187,14 +199,14 @@ module.exports = class MediaInput {
         meMsg.media.push(new BotiumMockMedia({
           mediaUri: args[0],
           downloadUri: uri.toString(),
-          mimeType: mime.lookup(args[0]),
+          mimeType: this._mime(args[0]),
           buffer
         }))
       }
     } else if (args.length === 2) {
       meMsg.media.push(new BotiumMockMedia({
         mediaUri: args[0],
-        mimeType: mime.lookup(args[0]),
+        mimeType: this._mime(args[0]),
         buffer: args[1]
       }))
     }

package/test/connectors/convos/hello.convo.txt

@@ -0,0 +1,6 @@
+hello
+
+#me
+hello
+
+#bot

package/test/connectors/simplerest.spec.js

@@ -22,6 +22,12 @@ const myCapsPost = {
   [Capabilities.SIMPLEREST_BODY_TEMPLATE]: { BODY1: 'BODY1VALUE', BODY2: '{{msg.messageText}}' },
   [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: ['$']
 }
+const myCapsFormPost = {
+  [Capabilities.CONTAINERMODE]: 'simplerest',
+  [Capabilities.SIMPLEREST_URL]: 'http://my-host.com/api/endpoint/{{msg.messageText}}',
+  [Capabilities.SIMPLEREST_METHOD]: 'POST',
+  [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: ['$']
+}
 
 const myCapsScriptingMemory = {
   [Capabilities.CONTAINERMODE]: 'simplerest',
@@ -448,7 +454,7 @@ describe('connectors.simplerest.build', function () {
       assert.isTrue(err.message.includes('Cant load hook, syntax is not valid'))
     }
   })
-  it('should query params from UPDATE_CUSTOM (without "?")', async function () {
+  it('should add query params from UPDATE_CUSTOM (without "?")', async function () {
     const myCaps = Object.assign({}, myCapsGet)
     const myMsg = Object.assign({}, msg)
     myMsg.ADD_QUERY_PARAM = {
@@ -467,7 +473,7 @@ describe('connectors.simplerest.build', function () {
 
     await container.Clean()
   })
-  it('should query params from UPDATE_CUSTOM (with "?")', async function () {
+  it('should add query params from UPDATE_CUSTOM (with "?")', async function () {
     const myCaps = Object.assign({}, myCapsGet)
     myCaps.SIMPLEREST_URL = 'http://my-host.com/api/endpoint/messageText?const1=const1'
     const myMsg = Object.assign({}, msg)
@@ -510,6 +516,26 @@ describe('connectors.simplerest.build', function () {
 
     await container.Clean()
   })
+  it('should add form params from UPDATE_CUSTOM (without "?")', async function () {
+    const myCaps = Object.assign({}, myCapsFormPost)
+    const myMsg = Object.assign({}, msg)
+    myMsg.ADD_FORM_PARAM = {
+      formparam1: 'valueparam1',
+      formparam2: '{{msg.messageText}}'
+    }
+
+    const driver = new BotDriver(myCaps)
+    const container = await driver.Build()
+    assert.equal(container.pluginInstance.constructor.name, 'SimpleRestContainer')
+
+    await container.Start()
+    const request = await container.pluginInstance._buildRequest(myMsg)
+    assert.isObject(request.form)
+    assert.equal(request.form.formparam1, 'valueparam1')
+    assert.equal(request.form.formparam2, 'messageText')
+
+    await container.Clean()
+  })
   it('should add header from UPDATE_CUSTOM', async function () {
     const myCaps = Object.assign({}, myCapsGet)
     const myMsg = Object.assign({}, msg)
@@ -789,6 +815,7 @@ describe('connectors.simplerest.useresponse', function () {
         .get('/startencoded').reply(200, { text: JSON.stringify({ prop: 'response from start' }) })
         .get('/startstring').reply(200, 'response from start')
         .get('/msg').reply(200, { text: 'response from msg' })
+        .get('/msgfail').reply(400, { error: 'failure text' })
         .persist()
 
       const myCaps = Object.assign({
@@ -914,6 +941,19 @@ describe('connectors.simplerest.useresponse', function () {
     assert.equal(transcript.steps.length, 1)
     assert.equal(transcript.steps[0].actual.messageText, 'response from start')
   })
+
+  it('should use error body content', async function () {
+    await this.init({
+      [Capabilities.SIMPLEREST_URL]: 'https://mock.com/msgfail'
+    })
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'hello.convo.txt')
+    try {
+      await this.compiler.convos[0].Run(this.container)
+    } catch (err) {
+      assert.isTrue(err.message.indexOf('failure text') >= 0)
+    }
+  })
 })
 
 describe('connectors.simplerest.inbound', function () {

package/test/convo/convos/continuefailing.convo.txt

@@ -0,0 +1,19 @@
+continuefailing
+
+#me
+Hello
+
+#bot
+Hello
+
+#me
+Hello again!
+
+#bot
+Hello again FAILING!
+
+#me
+working again
+
+#bot
+working again

package/test/convo/transcript.spec.js

@@ -42,12 +42,25 @@ describe('convo.transcript', function () {
     this.compilerMultipleAssertErrors = this.driverMultipleAssertErrors.BuildCompiler()
     this.containerMultipleAssertErrors = await this.driverMultipleAssertErrors.Build()
     await this.containerMultipleAssertErrors.Start()
+
+    const myCapsSkipAssertErrors = {
+      [Capabilities.PROJECTNAME]: 'convo.transcript',
+      [Capabilities.CONTAINERMODE]: echoConnector,
+      [Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]: true,
+      [Capabilities.SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS]: true
+    }
+    this.driverSkipAssertErrors = new BotDriver(myCapsSkipAssertErrors)
+    this.compilerSkipAssertErrors = this.driverSkipAssertErrors.BuildCompiler()
+    this.containerSkipAssertErrors = await this.driverSkipAssertErrors.Build()
+    await this.containerSkipAssertErrors.Start()
   })
   afterEach(async function () {
     await this.container.Stop()
     await this.container.Clean()
     await this.containerMultipleAssertErrors.Stop()
     await this.containerMultipleAssertErrors.Clean()
+    await this.containerSkipAssertErrors.Stop()
+    await this.containerSkipAssertErrors.Clean()
   })
   it('should provide transcript steps on success', async function () {
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '2steps.convo.txt')
@@ -347,4 +360,25 @@ describe('convo.transcript', function () {
     assert.equal(this.compilerMultipleAssertErrors.convos.length, 1)
     await this.compilerMultipleAssertErrors.convos[0].Run(this.containerMultipleAssertErrors)
   })
+  it('should continue on failing assertion', async function () {
+    this.compilerSkipAssertErrors.ReadScript(path.resolve(__dirname, 'convos'), 'continuefailing.convo.txt')
+    assert.equal(this.compilerSkipAssertErrors.convos.length, 1)
+
+    try {
+      await this.compilerSkipAssertErrors.convos[0].Run(this.containerSkipAssertErrors)
+      assert.fail('expected error')
+    } catch (err) {
+      assert.isDefined(err.transcript)
+      assert.equal(err.transcript.steps.length, 6)
+      assert.equal(err.transcript.steps[0].actual.messageText, this.compilerSkipAssertErrors.convos[0].conversation[0].messageText)
+      assert.equal(err.transcript.steps[1].actual.messageText, this.compilerSkipAssertErrors.convos[0].conversation[1].messageText)
+      assert.equal(err.transcript.steps[2].actual.messageText, this.compilerSkipAssertErrors.convos[0].conversation[2].messageText)
+      assert.equal(err.transcript.steps[3].expected.messageText, this.compilerSkipAssertErrors.convos[0].conversation[3].messageText)
+      assert.notEqual(err.transcript.steps[3].actual.messageText, this.compilerSkipAssertErrors.convos[0].conversation[3].messageText)
+      assert.isDefined(err.transcript.steps[3].err)
+      assert.equal(err.transcript.steps[4].expected.messageText, this.compilerSkipAssertErrors.convos[0].conversation[4].messageText)
+      assert.equal(err.transcript.steps[5].expected.messageText, this.compilerSkipAssertErrors.convos[0].conversation[5].messageText)
+      assert.isNull(err.transcript.steps[5].err)
+    }
+  })
 })

package/test/scripting/asserters/convos/text_wildcardexact_all_nok.yml

@@ -0,0 +1,7 @@
+convos:
+  - name: text_wildcardexact_all_nok
+    steps:
+      - me:
+          - Im Joe, my number is 12345, and my ID is id1_123
+      - bot:
+          - TEXT_WILDCARDEXACT_ALL Im Joe, my number is 12345, and my ID is id2_*3|Im Joe, my number is 1*5, and my ID is id1_123

package/test/scripting/asserters/convos/text_wildcardexact_all_ok.yml

@@ -0,0 +1,7 @@
+convos:
+  - name: text_wildcardexact_all_nok
+    steps:
+      - me:
+          - Im Joe, my number is 12345, and my ID is id1_123
+      - bot:
+          - TEXT_WILDCARDEXACT_ALL Im Joe, my number is 12345, and my ID is id1_*3|Im Joe, my number is 1*5, and my ID is id1_123

package/test/scripting/asserters/convos/text_wildcardexact_any_nok.yml

@@ -0,0 +1,7 @@
+convos:
+  - name: text_wildcardexact_any_nok
+    steps:
+      - me:
+          - Im Joe, my number is 12345, and my ID is id1_123
+      - bot:
+          - TEXT_WILDCARDEXACT_ANY Im Joe, my number is 12345, and my ID is id2_*3|Im Joe, my number is 12345, and my ID is id3_*3

package/test/scripting/asserters/convos/text_wildcardexact_any_ok.yml

@@ -0,0 +1,7 @@
+convos:
+  - name: text_wildcardexact_any_ok
+    steps:
+      - me:
+          - Im Joe, my number is 12345, and my ID is id1_123
+      - bot:
+          - TEXT_WILDCARDEXACT_ANY Im Joe, my number is 12345, and my ID is id1_*3|Im Joe, my number is 12345, and my ID is id2_*3

package/test/scripting/asserters/textWildcardExactAllAsserter.spec.js

@@ -0,0 +1,51 @@
+const assert = require('chai').assert
+const path = require('path')
+
+const BotDriver = require('../../..').BotDriver
+const Capabilities = require('../../..').Capabilities
+
+const echoConnector = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: msg.messageText }
+      queueBotSays(botMsg)
+    }
+  }
+}
+
+describe('scripting.asserters.textWildcardExactAllAsserter', function () {
+  beforeEach(async function () {
+    const myCaps = {
+      [Capabilities.PROJECTNAME]: 'scripting.asserters.textWildcardExactAllAsserter',
+      [Capabilities.CONTAINERMODE]: echoConnector
+    }
+    const driver = new BotDriver(myCaps)
+    this.compiler = driver.BuildCompiler()
+    this.container = await driver.Build()
+  })
+  afterEach(async function () {
+    this.container && await this.container.Clean()
+  })
+
+  it('ok', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'text_wildcardexact_all_ok.yml'))
+
+    this.compiler.ExpandScriptingMemoryToConvos()
+    assert.equal(this.compiler.convos.length, 1)
+    await this.compiler.convos[0].Run(this.container)
+  })
+
+  it('nok', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'text_wildcardexact_all_nok.yml'))
+
+    this.compiler.ExpandScriptingMemoryToConvos()
+    assert.equal(this.compiler.convos.length, 1)
+
+    try {
+      await this.compiler.convos[0].Run(this.container)
+      assert.fail('expected error')
+    } catch (err) {
+      assert.equal(err.message, 'text_wildcardexact_all_nok/Line 2: assertion error - Line 2: Expected text(s) in response "Im Joe, my number is 12345, and my ID is id2_*3"')
+    }
+  })
+})