botium-core 1.14.1 → 1.14.4

package/src/scripting/ScriptingProvider.js

@@ -92,37 +92,37 @@ module.exports = class ScriptingProvider {
 
     this.scriptingEvents = {
       onConvoBegin: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onConvoBegin', logicHooks: (convo.beginLogicHook || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onConvoBegin', logicHooks: (convo?.beginLogicHook || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onConvoEnd: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onConvoEnd', logicHooks: (convo.endLogicHook || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onConvoEnd', logicHooks: (convo?.endLogicHook || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onMeStart: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onMeStart', logicHooks: (convoStep.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onMeStart', logicHooks: (convoStep?.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onMePrepare: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onMePrepare', logicHooks: (convoStep.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onMePrepare', logicHooks: (convoStep?.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onMeEnd: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onMeEnd', logicHooks: (convoStep.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onMeEnd', logicHooks: (convoStep?.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onBotStart: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onBotStart', logicHooks: (convoStep.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onBotStart', logicHooks: (convoStep?.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onBotPrepare: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onBotPrepare', logicHooks: (convoStep.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onBotPrepare', logicHooks: (convoStep?.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
       },
       onBotEnd: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createLogicHookPromises({ hookType: 'onBotEnd', logicHooks: (convoStep.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createLogicHookPromises({ hookType: 'onBotEnd', logicHooks: (convoStep?.logicHooks || []), convo, convoStep, scriptingMemory, ...rest })
       },
       assertConvoBegin: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createAsserterPromises({ asserterType: 'assertConvoBegin', asserters: (convo.beginAsserter || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createAsserterPromises({ asserterType: 'assertConvoBegin', asserters: (convo?.beginAsserter || []), convo, convoStep, scriptingMemory, ...rest })
       },
       assertConvoStep: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createAsserterPromises({ asserterType: 'assertConvoStep', asserters: (convoStep.asserters || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createAsserterPromises({ asserterType: 'assertConvoStep', asserters: (convoStep?.asserters || []), convo, convoStep, scriptingMemory, ...rest })
       },
       assertConvoEnd: ({ convo, convoStep, scriptingMemory, ...rest }) => {
-        return this._createAsserterPromises({ asserterType: 'assertConvoEnd', asserters: (convo.endAsserter || []), convo, convoStep, scriptingMemory, ...rest })
+        return this._createAsserterPromises({ asserterType: 'assertConvoEnd', asserters: (convo?.endAsserter || []), convo, convoStep, scriptingMemory, ...rest })
       },
       setUserInput: ({ convo, convoStep, scriptingMemory, ...rest }) => {
         return this._createUserInputPromises({ convo, convoStep, scriptingMemory, ...rest })
@@ -130,18 +130,20 @@ module.exports = class ScriptingProvider {
       resolveUtterance: ({ utterance, resolveEmptyIfUnknown }) => {
         return this._resolveUtterance({ utterance, resolveEmptyIfUnknown })
       },
-      assertBotResponse: (botresponse, tomatch, stepTag, meMsg) => {
+      assertBotResponse: (botresponse, tomatch, stepTag, meMsg, convoStepParameters = {}) => {
         if (!_.isArray(tomatch)) {
           tomatch = [tomatch]
         }
         debug(`assertBotResponse ${stepTag} ${meMsg ? `(${meMsg}) ` : ''}BOT: ${botresponse} = ${tomatch} ...`)
-        const found = _.find(tomatch, (utt) => this.matchFn(botresponse, utt, this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS]))
+        const matchFn = convoStepParameters.matchingMode ? (getMatchFunction(convoStepParameters.matchingMode) || this.matchFn) : this.matchFn
+        const found = _.find(tomatch, (utt) => matchFn(botresponse, utt, this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS], convoStepParameters))
         const asserterType = this.caps[Capabilities.SCRIPTING_MATCHING_MODE] === 'wer' ? 'Word Error Rate Asserter' : 'Text Match Asserter'
         if (_.isNil(found)) {
-          if (this.caps[Capabilities.SCRIPTING_MATCHING_MODE] === 'wer') {
+          const matchingMode = convoStepParameters.matchingMode || this.caps[Capabilities.SCRIPTING_MATCHING_MODE]
+          if (matchingMode === 'wer') {
             const wer = calculateWer(botresponse, tomatch[0])
             const werArgs = this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS]
-            const threshold = ([',', '.'].find(p => `${werArgs[0]}`.includes(p)) ? parseFloat(werArgs[0]) : parseInt(werArgs[0]) / 100)
+            const threshold = !_.isNil(convoStepParameters.matchingModeWer) ? (convoStepParameters.matchingModeWer / 100) : ([',', '.'].find(p => `${werArgs[0]}`.includes(p)) ? parseFloat(werArgs[0]) : parseInt(werArgs[0]) / 100)
             const message = `${stepTag}: Word Error Rate (${toPercent(wer)}) higher than accepted (${toPercent(threshold)})`
             throw new BotiumError(
               message,
@@ -149,7 +151,7 @@ module.exports = class ScriptingProvider {
                 type: 'asserter',
                 source: asserterType,
                 params: {
-                  matchingMode: this.caps[Capabilities.SCRIPTING_MATCHING_MODE],
+                  matchingMode,
                   args: this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS] || null
                 },
                 context: {
@@ -191,18 +193,20 @@ module.exports = class ScriptingProvider {
           }
         }
       },
-      assertBotNotResponse: (botresponse, nottomatch, stepTag, meMsg) => {
+      assertBotNotResponse: (botresponse, nottomatch, stepTag, meMsg, convoStepParameters = {}) => {
         if (!_.isArray(nottomatch)) {
           nottomatch = [nottomatch]
         }
         debug(`assertBotNotResponse ${stepTag} ${meMsg ? `(${meMsg}) ` : ''}BOT: ${botresponse} != ${nottomatch} ...`)
-        const found = _.find(nottomatch, (utt) => this.matchFn(botresponse, utt, this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS]))
+        const matchFn = convoStepParameters.matchingMode ? (getMatchFunction(convoStepParameters.matchingMode) || this.matchFn) : this.matchFn
+        const found = _.find(nottomatch, (utt) => matchFn(botresponse, utt, this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS], convoStepParameters))
         const asserterType = this.caps[Capabilities.SCRIPTING_MATCHING_MODE] === 'wer' ? 'Word Error Rate Asserter' : 'Text Match Asserter'
         if (!_.isNil(found)) {
-          if (this.caps[Capabilities.SCRIPTING_MATCHING_MODE] === 'wer') {
+          const matchingMode = convoStepParameters.matchingMode || this.caps[Capabilities.SCRIPTING_MATCHING_MODE]
+          if (matchingMode === 'wer') {
             const wer = calculateWer(botresponse, nottomatch[0])
             const werArgs = this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS]
-            const threshold = ([',', '.'].find(p => `${werArgs[0]}`.includes(p)) ? parseFloat(werArgs[0]) : parseInt(werArgs[0]) / 100)
+            const threshold = !_.isNil(convoStepParameters.matchingModeWer) ? (convoStepParameters.matchingModeWer / 100) : ([',', '.'].find(p => `${werArgs[0]}`.includes(p)) ? parseFloat(werArgs[0]) : parseInt(werArgs[0]) / 100)
             const message = `${stepTag}: Word Error Rate (${toPercent(wer)}) lower than accepted (${toPercent(threshold)})`
             throw new BotiumError(
               message,
@@ -210,7 +214,7 @@ module.exports = class ScriptingProvider {
                 type: 'asserter',
                 source: asserterType,
                 params: {
-                  matchingMode: this.caps[Capabilities.SCRIPTING_MATCHING_MODE],
+                  matchingMode,
                   args: this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS] || null
                 },
                 context: {
@@ -270,6 +274,22 @@ module.exports = class ScriptingProvider {
       assertConvoStep: 'assertNotConvoStep',
       assertConvoEnd: 'assertNotConvoEnd'
     }
+    const updateExceptionContext = (promise, asserter) => {
+      const updateError = (err) => {
+        if (err instanceof BotiumError) {
+          if (!err.context) {
+            err.context = {}
+          }
+
+          err.context.asserter = asserter.name
+
+          throw err
+        } else {
+          throw botiumErrorFromErr(_.isString(err) ? err : err.message, err, { asserter: asserter.name })
+        }
+      }
+      return promise.catch(err => updateError(err))
+    }
     const callAsserter = (asserterSpec, asserter, params) => {
       if (asserterSpec.not) {
         const notAsserterType = mapNot[asserterType]
@@ -301,18 +321,35 @@ module.exports = class ScriptingProvider {
 
     const convoAsserter = asserters
       .filter(a => this.asserters[a.name][asserterType])
-      .map(a => callAsserter(a, this.asserters[a.name], {
-        convo,
-        convoStep,
-        scriptingMemory,
-        container,
-        args: ScriptingMemory.applyToArgs(a.args, scriptingMemory, container.caps, rest.botMsg),
-        isGlobal: false,
-        ...rest
+      .map(a => ({
+        asserter: a,
+        promise: callAsserter(a, this.asserters[a.name], {
+          convo,
+          convoStep,
+          scriptingMemory,
+          container,
+          args: ScriptingMemory.applyToArgs(a.args, scriptingMemory, container.caps, rest.botMsg),
+          isGlobal: false,
+          ...rest
+        })
       }))
+      .map(({ promise, asserter }) => updateExceptionContext(promise, asserter))
+
     const globalAsserter = Object.values(this.globalAsserter)
       .filter(a => a[asserterType])
-      .map(a => p(this.retryHelperAsserter, () => a[asserterType]({ convo, convoStep, scriptingMemory, container, args: [], isGlobal: true, ...rest })))
+      .map(a => ({
+        asserter: a,
+        promise: p(this.retryHelperAsserter, () => a[asserterType]({
+          convo,
+          convoStep,
+          scriptingMemory,
+          container,
+          args: [],
+          isGlobal: true,
+          ...rest
+        }))
+      }))
+      .map(({ promise, asserter }) => updateExceptionContext(promise, asserter))
 
     const allPromises = [...convoAsserter, ...globalAsserter]
     if (this.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]) {
@@ -335,8 +372,10 @@ module.exports = class ScriptingProvider {
       throw Error(`Unknown hookType ${hookType}`)
     }
 
-    const convoStepPromises = (logicHooks || [])
+    const localHooks = (logicHooks || [])
       .filter(l => this.logicHooks[l.name][hookType])
+
+    const convoStepPromises = localHooks
       .map(l => p(this.retryHelperLogicHook, () => this.logicHooks[l.name][hookType]({
         convo,
         convoStep,
@@ -347,17 +386,24 @@ module.exports = class ScriptingProvider {
         ...rest
       })))
 
-    const globalPromises = Object.values(this.globalLogicHook)
-      .filter(l => l[hookType])
-      .map(l => p(this.retryHelperLogicHook, () => l[hookType]({ convo, convoStep, scriptingMemory, container, args: [], isGlobal: true, ...rest })))
+    const globalHooks = Object.values(this.globalLogicHook).filter(l => l[hookType])
+    const globalPromises = globalHooks.map(l => p(this.retryHelperLogicHook, () => l[hookType]({ convo, convoStep, scriptingMemory, container, args: [], isGlobal: true, ...rest })))
 
     const allPromises = [...convoStepPromises, ...globalPromises]
-    if (allPromises.length > 0) return Promise.all(allPromises).then(() => true)
+
+    if (allPromises.length > 0) {
+      return Promise.all(allPromises).then(() => {
+        return {
+          // just returning some humanreadable
+          hooks: [...localHooks, ...globalHooks].map(h => h.name || h.context?.ref || JSON.stringify(h))
+        }
+      })
+    }
     return Promise.resolve(false)
   }
 
   _createUserInputPromises ({ convo, convoStep, scriptingMemory, container, ...rest }) {
-    const convoStepPromises = (convoStep.userInputs || [])
+    const convoStepPromises = (convoStep?.userInputs || [])
       .filter(ui => this.userInputs[ui.name])
       .map(ui => p(this.retryHelperUserInput, () => this.userInputs[ui.name].setUserInput({
         convo,
@@ -424,6 +470,11 @@ module.exports = class ScriptingProvider {
     }
   }
 
+  // Livechat, and crawler using logichooks too. So they need script context
+  BuildScriptContext () {
+    return this._buildScriptContext()
+  }
+
   Build () {
     const CompilerXlsx = require('./CompilerXlsx')
     this.compilers[Constants.SCRIPTING_FORMAT_XSLX] = new CompilerXlsx(this._buildScriptContext(), this.caps)

package/src/scripting/helper.js

@@ -4,6 +4,7 @@ const speechScorer = require('word-error-rate')
 const debug = require('debug')('botium-core-scripting-helper')
 
 const { E_SCRIPTING_MEMORY_COLUMN_MODE } = require('../Enums')
+const WHITE_SPACES_EXCEPT_SPACE_CHAR_AT_THE_END = /[\n\t\r]+$/
 
 const normalizeText = (str, doCleanup) => {
   if (str && _.isArray(str)) {
@@ -247,7 +248,7 @@ const linesToConvoStep = (lines, sender, context, eol, singleLineMode = false) =
         if (eol === null) {
           throw new Error('eol cant be null')
         }
-        convoStep.messageText = textLines.join(eol).trim()
+        convoStep.messageText = textLines.join(eol).replace(WHITE_SPACES_EXCEPT_SPACE_CHAR_AT_THE_END, '')
       }
     }
   } else {
@@ -473,7 +474,7 @@ const convoStepToLines = (step) => {
       lines.push(logicHook.name + _formatAppendArgs(logicHook.args))
     })
   }
-  return lines.map(l => l.trim())
+  return lines
 }
 
 const linesToScriptingMemories = (lines, columnMode = null) => {

package/src/scripting/logichook/LogicHookConsts.js

@@ -61,11 +61,14 @@ module.exports = {
     { 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' }
+    { name: 'CONDITIONAL_STEP_JSON_PATH_BASED', className: 'ConditionalJsonPathBasedLogicHook.js' },
+    { name: 'CONVO_STEP_PARAMETERS', className: 'ConvoStepParametersLogicHook.js' },
+    { name: 'ORDERED_LIST_TO_BUTTON', className: 'OrderedListToButtonLogicHook' }
   ],
   DEFAULT_USER_INPUTS: [
     { name: 'BUTTON', className: 'ButtonInput' },
     { name: 'MEDIA', className: 'MediaInput' },
     { name: 'FORM', className: 'FormInput' }
-  ]
+  ],
+  LOGIC_HOOK_EVENTS: ['onConvoBegin', 'onMeStart', 'onMePrepare', 'onMeEnd', 'onBotStart', 'onBotEnd', 'onBotPrepare', 'onConvoEnd']
 }

package/src/scripting/logichook/LogicHookUtils.js

@@ -147,19 +147,21 @@ module.exports = class LogicHookUtils {
       }
     }
 
+    const typeAsText = hookType === 'asserter' ? 'Asserter' : hookType === 'logichook' ? 'Logic Hook' : hookType === 'userinput' ? 'User Input' : 'Unknown'
+
     if (isClass(src)) {
       try {
         const CheckClass = src
         return new CheckClass({ ref, ...this.buildScriptContext }, this.caps, args)
       } catch (err) {
-        throw new Error(`Logic Hook specification ${ref} from class invalid: ${err.message}`)
+        throw new Error(`${typeAsText} specification ${ref} from class invalid: ${err.message}`)
       }
     }
     if (_.isFunction(src)) {
       try {
         return src({ ref, ...this.buildScriptContext }, this.caps, args)
       } catch (err) {
-        throw new Error(`Logic Hook specification ${ref} from function invalid: ${err.message}`)
+        throw new Error(`${typeAsText} specification ${ref} from function invalid: ${err.message}`)
       }
     }
     if (_.isObject(src) && !_.isString(src)) {
@@ -177,7 +179,7 @@ module.exports = class LogicHookUtils {
         }, {})
         return hookObject
       } catch (err) {
-        throw new Error(`Logic Hook specification ${ref} ${hookType} from provided src (${util.inspect(src)}) invalid: ${err.message}`)
+        throw new Error(`${typeAsText} specification ${ref} ${hookType} from provided src (${util.inspect(src)}) invalid: ${err.message}`)
       }
     }
 
@@ -230,7 +232,7 @@ module.exports = class LogicHookUtils {
               try {
                 return tryLoadFromSource(tryLoadFile, tryLoad.tryLoadAsserterByName)
               } catch (err) {
-                loadErr.push(`Logic Hook specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `)
+                loadErr.push(`${typeAsText} specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `)
               }
             }
           }
@@ -239,13 +241,13 @@ module.exports = class LogicHookUtils {
           try {
             return tryLoadFromSource(tryLoad.tryLoadPackageName, tryLoad.tryLoadAsserterByName)
           } catch (err) {
-            loadErr.push(`Logic Hook specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `)
+            loadErr.push(`${typeAsText} specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `)
           }
         }
       }
 
       loadErr.forEach(debug)
     }
-    throw new Error(`Logic Hook specification ${ref} ${hookType} from "${util.inspect(src)}" invalid : no loader available`)
+    throw new Error(`${typeAsText} specification ${ref} ${hookType} from "${util.inspect(src)}" invalid : no loader available`)
   }
 }

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

@@ -0,0 +1,6 @@
+/**
+ * This LogicHook is just a marker. It is used Convo Step parameters
+ * @type {module.ConvoStepParametersLogicHook}
+ */
+module.exports = class ConvoStepParametersLogicHook {
+}

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

@@ -0,0 +1,37 @@
+const _ = require('lodash')
+const PATTERN = '^\\s*(\\d+)\\.'
+const debug = require('debug')('botium-core-OrderedListToButtonLogicHook')
+
+module.exports = class OrderedListToButtonLogicHook {
+  constructor (context, caps = {}, globalArgs = {}) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  onBotPrepare ({ botMsg, args }) {
+    const pattern = args?.[0] || this.globalArgs?.pattern || PATTERN
+    let regexp
+    try {
+      regexp = new RegExp(pattern, 'gm')
+    } catch (err) {
+      throw new Error(`OrderedListToButtonLogicHook: regex is not valid: ${pattern} ${err.messageText}`)
+    }
+    const buttons = []
+    if (botMsg.messageText && _.isString(botMsg.messageText)) {
+      const matches = botMsg.messageText.matchAll(regexp)
+
+      for (const match of matches) {
+        if (match && match[1]) {
+          buttons.push({ text: match[1], payload: match[1] })
+        }
+      }
+    } else {
+      debug(`ConditionalBusinessHoursLogicHook onBotPrepare, msg has no messageText to check ${JSON.stringify(botMsg)}`)
+    }
+
+    if (buttons.length) {
+      botMsg.buttons = [...(botMsg.buttons || []), ...buttons]
+    }
+  }
+}

package/test/compiler/compilermarkdown.spec.js

@@ -161,7 +161,7 @@ describe('compiler.compilermarkdown', function () {
       const compiler = new Compiler(context, Object.assign({}, DefaultCapabilities, caps))
 
       compiler.Compile(scriptBuffer, 'SCRIPTING_TYPE_CONVO')
-      assert.equal(context.convos[0].conversation[1].messageText, 'hello meat bag \n!hello2')
+      assert.equal(context.convos[0].conversation[1].messageText, 'hello meat bag\n!hello2')
       assert.equal(context.convos[0].conversation[1].not, true)
     })
   })
@@ -191,7 +191,7 @@ describe('compiler.compilermarkdown', function () {
         compiler.Compile(scriptBuffer, 'SCRIPTING_TYPE_CONVO')
         assert.fail('expected error')
       } catch (err) {
-        assert.equal(err.message, 'Failed to parse conversation. All element in convo step has to be optional or not optional: ["?hello meat bag ","BUTTONS checkbutton|checkbutton2 "]')
+        assert.equal(err.message, 'Failed to parse conversation. All element in convo step has to be optional or not optional: ["?hello meat bag","BUTTONS checkbutton|checkbutton2"]')
       }
     })
     it('should read ?? as ?', async function () {
@@ -225,7 +225,7 @@ describe('compiler.compilermarkdown', function () {
       const compiler = new Compiler(context, Object.assign({}, DefaultCapabilities, caps))
 
       compiler.Compile(scriptBuffer, 'SCRIPTING_TYPE_CONVO')
-      assert.equal(context.convos[0].conversation[1].messageText, 'hello meat bag \n?hello2')
+      assert.equal(context.convos[0].conversation[1].messageText, 'hello meat bag\n?hello2')
       assert.equal(context.convos[0].conversation[1].optional, true)
     })
   })

package/test/compiler/compilertxt.spec.js

@@ -236,7 +236,7 @@ describe('compiler.compilertxt', function () {
     assert.equal(convo.conversation.length, 2)
     assert.equal(convo.conversation[0].messageText, '')
     assert.equal(convo.conversation[0].logicHooks.length, 0)
-    assert.equal(convo.conversation[1].messageText, 'Hi')
+    assert.equal(convo.conversation[1].messageText, 'Hi ')
   })
   it('should read nothing if there is nothing (even no separator)', async function () {
     const scriptBuffer = fs.readFileSync(path.resolve(__dirname, CONVOS_DIR, 'convos_emptyrow_no_separator_row.convo.txt'))

package/test/compiler/convos/txt/convos_emptyrow_just_emptyrow.convo.txt

@@ -2,6 +2,6 @@
 
 
 #bot
-Hi
+Hi 
 
 

package/test/convo/fillAndApplyScriptingMemory.spec.js

@@ -817,6 +817,17 @@ describe('convo.fillAndApplyScriptingMemory', function () {
 
         assert.equal(result, moment().subtract(1, 'month').format('YYYY.MM.DD'))
       })
+      it('date_add_dynamic', async function () {
+        const result = ScriptingMemory.apply(
+          { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
+          {
+            days: 2
+          },
+          '$date_add($days, "day", YYYY.MM.DD)'
+        )
+
+        assert.equal(result, moment().add(2, 'day').format('YYYY.MM.DD'))
+      })
 
       it('random', async function () {
         const result = ScriptingMemory.apply(

package/test/logichooks/orderedListToButton.spec.js

@@ -0,0 +1,35 @@
+const assert = require('chai').assert
+
+const OrderedListToButtonLogicHook = require('../../src/scripting/logichook/logichooks/OrderedListToButtonLogicHook')
+
+describe('logichooks.orderedListToButton', function () {
+  it('should convert ordered list to buttons', async function () {
+    const orderedListToButtonLogicHook = new OrderedListToButtonLogicHook()
+    const botMsg = {
+      messageText: `0. sometext.
+1.
+ 2.
+ 3.sdfdsf
+ 4. 3 days per week
+ 5.2.2
+ 6. 2.dfsdf
+ 7777.
+ 88euro
+ `,
+
+      buttons: [{ payload: 'existingButtonPayload', text: 'existingButtonText' }]
+    }
+
+    orderedListToButtonLogicHook.onBotPrepare({ botMsg })
+    assert.equal(botMsg.buttons?.length, 9)
+    assert.deepEqual(botMsg.buttons[0], { payload: 'existingButtonPayload', text: 'existingButtonText' })
+    assert.deepEqual(botMsg.buttons[1], { payload: '0', text: '0' })
+    assert.deepEqual(botMsg.buttons[2], { payload: '1', text: '1' })
+    assert.deepEqual(botMsg.buttons[3], { payload: '2', text: '2' })
+    assert.deepEqual(botMsg.buttons[4], { payload: '3', text: '3' })
+    assert.deepEqual(botMsg.buttons[5], { payload: '4', text: '4' })
+    assert.deepEqual(botMsg.buttons[6], { payload: '5', text: '5' })
+    assert.deepEqual(botMsg.buttons[7], { payload: '6', text: '6' })
+    assert.deepEqual(botMsg.buttons[8], { payload: '7777', text: '7777' })
+  })
+})

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

@@ -0,0 +1,151 @@
+const path = require('path')
+const assert = require('chai').assert
+const BotDriver = require('../../../index').BotDriver
+const Capabilities = require('../../../index').Capabilities
+const debug = require('debug')('botium-test-logichooks-waitforbot')
+const util = require('util')
+
+const createEchoConnector = () => ({ queueBotSays, caps }) => {
+  return {
+    UserSays (msg) {
+      const _send = (msg, timeout) => {
+        const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: `You said ${msg}` }
+        if (msg.toLowerCase().indexOf('button') >= 0) {
+          botMsg.buttons = [{ text: 'button1' }, { text: 'button2' }]
+        }
+        if (msg.toLowerCase().indexOf('intent') >= 0) {
+          botMsg.nlp = { intent: { name: 'someIntent', confidence: 0.5 } }
+        }
+        setTimeout(() => {
+          debug(`${prefix} Connector is sending message ${util.inspect(botMsg)}`)
+          return queueBotSays(botMsg)
+        }, timeout)
+      }
+
+      const prefix = `Testcase "${caps[Capabilities.PROJECTNAME]}"`
+      debug(`${prefix} Connector got message ${util.inspect(msg)}`)
+      if (msg.messageText) {
+        msg.messageText.split('\n').forEach((msgPart, i) => {
+          if (msgPart) {
+            _send(msgPart, i * 50)
+          }
+        })
+      }
+    }
+  }
+}
+describe('scripting.asserters.convoStepParametersForAssert', function () {
+  beforeEach(async function () {
+    const myCaps = {
+      [Capabilities.PROJECTNAME]: 'asserters.text',
+      [Capabilities.CONTAINERMODE]: createEchoConnector(),
+      [Capabilities.WAITFORBOTTIMEOUT]: 1000,
+      [Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]: true,
+      [Capabilities.SCRIPTING_CONVO_STEP_PARAMETERS]: '{"ignoreNotMatchedBotResponses": {"timeout": 200, "asserters": ["INTENT"]}}'
+    }
+    const driver = new BotDriver(myCaps)
+    this.compiler = driver.BuildCompiler()
+    this.container = await driver.Build()
+  })
+  afterEach(async function () {
+    await this.container.Stop()
+    await this.container.Clean()
+  })
+
+  describe('scripting.asserters.convoStepParametersForAssert.matchmode', function () {
+    it('should not accept bad chatbot response on exact match defined on step', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convo_step_parameter_matchmode_failed.convo.txt')
+      assert.equal(this.compiler.convos.length, 1)
+
+      try {
+        await this.compiler.convos[0].Run(this.container)
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('"You said Hello" expected to match "Hello"') >= 0)
+      }
+    })
+    it('should not accept bad chatbot response on exact match defined on step even with WER asserter', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convo_step_parameter_matchmode_failed_wer.convo.txt')
+      assert.equal(this.compiler.convos.length, 1)
+
+      try {
+        await this.compiler.convos[0].Run(this.container)
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Word Error Rate (50%) higher than accepted (25%)') >= 0)
+      }
+    })
+  })
+
+  describe('scripting.asserters.convoStepParametersForAssert.retry', function () {
+    it('should retry until succesful main', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convo_step_parameter_retry_main_good.convo.txt')
+      assert.equal(this.compiler.convos.length, 1)
+
+      await this.compiler.convos[0].Run(this.container)
+    })
+    it('should retry until succesful asserters', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convo_step_parameter_retry_asserters_good.convo.txt')
+      assert.equal(this.compiler.convos.length, 1)
+
+      await this.compiler.convos[0].Run(this.container)
+    })
+    it('should retry until succesful asserters all', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convo_step_parameter_retry_asserters_all_good.convo.txt')
+      assert.equal(this.compiler.convos.length, 1)
+
+      await this.compiler.convos[0].Run(this.container)
+    })
+    it('should retry until succesful main, configured in begin', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convo_step_parameter_retry_main_good_begin.convo.txt')
+      assert.equal(this.compiler.convos.length, 1)
+
+      await this.compiler.convos[0].Run(this.container)
+    })
+    it('should retry until succesful asserters, configured by cap', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convo_step_parameter_retry_asserters_good_global.convo.txt')
+      assert.equal(this.compiler.convos.length, 1)
+
+      await this.compiler.convos[0].Run(this.container)
+    })
+    it('should retry until timeout main', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convo_step_parameter_retry_main_botium_timeout.convo.txt')
+      assert.equal(this.compiler.convos.length, 1)
+
+      try {
+        await this.compiler.convos[0].Run(this.container)
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('error waiting for bot - Bot did not respond within 1s') >= 0)
+      }
+    })
+    it('should retry until timeout asserter', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convo_step_parameter_retry_asserters_botium_timeout.convo.txt')
+      assert.equal(this.compiler.convos.length, 1)
+
+      try {
+        await this.compiler.convos[0].Run(this.container)
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('error waiting for bot - Bot did not respond within 1s') >= 0)
+      }
+    })
+    it('should not retry on not retriable error', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convo_step_parameter_retry_main_but_no_button.convo.txt')
+      assert.equal(this.compiler.convos.length, 1)
+
+      try {
+        await this.compiler.convos[0].Run(this.container)
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Expected button(s) with text "some not existing button"') >= 0)
+      }
+    })
+    it('should retry until every retriable is succesful', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convo_step_parameter_retry_main_and_asserter.convo.txt')
+      assert.equal(this.compiler.convos.length, 1)
+
+      await this.compiler.convos[0].Run(this.container)
+    })
+  })
+})

package/test/scripting/asserters/convos/TEXT_GOOD.convo.txt

@@ -0,0 +1,6 @@
+TEXT_GOOD
+#me
+Hello1
+
+#bot
+TEXT You said Hello1

package/test/scripting/asserters/convos/convo_step_parameter_matchmode_failed.convo.txt

@@ -0,0 +1,8 @@
+convo_step_parameter_matchmode_failed
+
+#me
+Hello
+
+#bot
+Hello
+CONVO_STEP_PARAMETERS {"matchingMode":"equals"}