botium-core 1.14.0 → 1.14.3

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/ConditionalBusinessHoursLogicHook.js

@@ -51,6 +51,6 @@ module.exports = class ConditionalBusinessHoursLogicHook {
     }
     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}`)
+    debug(`ConditionalBusinessHoursLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${util.inspect(convoStep.conditional)}`)
   }
 }

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

@@ -32,6 +32,6 @@ module.exports = class ConditionalCapabilityValueBasedLogicHook {
       conditionGroupId
     }
     convoStep.conditional.skip = !this._isCapabilityValueEqual(params)
-    debug(`ConditionalCapabilityValueBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+    debug(`ConditionalCapabilityValueBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${util.inspect(convoStep.conditional)}`)
   }
 }

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

@@ -26,6 +26,6 @@ module.exports = class ConditionalJsonPathBasedLogicHook {
       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}`)
+    debug(`ConditionalJsonPathBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${util.inspect(convoStep.conditional)}`)
   }
 }

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

@@ -41,6 +41,6 @@ module.exports = class ConditionalTimeBasedLogicHook {
     }
     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}`)
+    debug(`ConditionalTimeBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${util.inspect(convoStep.conditional)}`)
   }
 }

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/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,140 @@
+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)
+      }
+    })
+  })
+
+  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"}

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

@@ -0,0 +1,9 @@
+convo_step_parameter_retry_asserters_good
+
+#me
+Hello
+Button
+
+#bot
+BUTTONS button1|button2
+CONVO_STEP_PARAMETERS {"ignoreNotMatchedBotResponses": {"timeout": 200, "allAsserters": true}}

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

@@ -0,0 +1,9 @@
+convo_step_parameter_retry_asserters_good
+
+#me
+Hello
+Button
+
+#bot
+BUTTONS button1|buttonXXXXXX
+CONVO_STEP_PARAMETERS {"ignoreNotMatchedBotResponses": {"timeout": 200, "asserters": ["BUTTONS"]}}

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

@@ -0,0 +1,9 @@
+convo_step_parameter_retry_asserters_good
+
+#me
+Hello
+Button
+
+#bot
+BUTTONS button1|button2
+CONVO_STEP_PARAMETERS {"ignoreNotMatchedBotResponses": {"timeout": 200, "asserters": ["BUTTONS"]}}

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

@@ -0,0 +1,9 @@
+convo_step_parameter_retry_asserters_good_global
+
+
+#me
+Hello1
+Intent
+
+#bot
+INTENT someIntent

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

@@ -0,0 +1,10 @@
+convo_step_parameter_retry_main_and_asserter
+
+#me
+Butt
+Button
+
+#bot
+You said Butt
+BUTTONS button1|button2
+CONVO_STEP_PARAMETERS {"ignoreNotMatchedBotResponses": {"timeout": 200, "mainAsserter": true, "allAsserters": true}}

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

@@ -0,0 +1,9 @@
+convo_step_parameter_retry_main_botium_timeout
+
+#me
+Hello1
+Hello2
+
+#bot
+You said Hello3
+CONVO_STEP_PARAMETERS {"ignoreNotMatchedBotResponses": {"timeout": 200, "mainAsserter": true}}

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

@@ -0,0 +1,10 @@
+convo_step_parameter_retry_main_but_no_button
+
+#me
+Hello1
+Hello2
+
+#bot
+You said Hello2
+BUTTONS some not existing button
+CONVO_STEP_PARAMETERS {"ignoreNotMatchedBotResponses": {"timeout": 200, "mainAsserter": true}}

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

@@ -0,0 +1,9 @@
+convo_step_parameter_retry_main_good
+
+#me
+Hello1
+Hello2
+
+#bot
+You said Hello2
+CONVO_STEP_PARAMETERS {"ignoreNotMatchedBotResponses": {"timeout": 201, "mainAsserter": true}}

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

@@ -0,0 +1,11 @@
+convo_step_parameter_retry_main_good_begin
+
+#begin
+CONVO_STEP_PARAMETERS {"ignoreNotMatchedBotResponses": {"timeout": 200, "mainAsserter": true}}
+
+#me
+Hello1
+Hello2
+
+#bot
+You said Hello2

package/test/scripting/logichooks/convos/conditional_steps_multiple_condition_groups_no_assertion.convo.txt

@@ -4,17 +4,17 @@ custom embedded
 hello
 
 #bot
-hello should not assert
-CONDITIONAL_STEP_LOGIC_HOOK { "skip":true }|G1
+hello
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":false }|G1
 
 #bot
 hello should not assert
-CONDITIONAL_STEP_LOGIC_HOOK { "skip":true }|G1
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":false }|G1
 
 #bot
-hello should not assert
-CONDITIONAL_STEP_LOGIC_HOOK { "skip":true }|G2
+hello
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":false }|G2
 
 #bot
 hello should not assert
-CONDITIONAL_STEP_LOGIC_HOOK { "skip":true }|G2
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":false }|G2

package/test/scripting/logichooks/convos/conditional_steps_multiple_mandatory_condition_groups.convo.txt

@@ -0,0 +1,20 @@
+custom embedded
+
+#me
+hello
+
+#bot
+hello should not assert
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":true }|G1
+
+#bot
+hello
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":false }|G1
+
+#bot
+hello should not assert
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":true }|G2
+
+#bot
+hello should not assert
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":true }|G2

package/test/scripting/logichooks/convos/conditional_steps_multiple_optional_condition_groups.convo.txt

@@ -0,0 +1,20 @@
+custom embedded
+
+#me
+hello
+
+#bot
+?hello
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":false }|G1
+
+#bot
+?hello should not assert
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":false }|G1
+
+#bot
+?hello 2
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":false }|G2
+
+#bot
+?hello should not assert
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":true }|G2

package/test/scripting/logichooks/customConditionalStepLogicHook.spec.js

@@ -101,5 +101,21 @@ describe('convo with custom conditional logichook', function () {
       const transript = await this.compiler.convos[0].Run(this.container)
       assert.equal(transript.steps.length, 3)
     })
+
+    it('should fail mandatory condition group if no condition met', async function () {
+      try {
+        this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'conditional_steps_multiple_mandatory_condition_groups.convo.txt')
+        await this.compiler.convos[0].Run(this.container)
+        assert.fail('it should have failed')
+      } catch (e) {
+        assert.equal(e.message, 'custom embedded/Line 18: Non of the conditions are met in \'G2\' condition group')
+      }
+    })
+
+    it('should not fail optional condition group if no condition met', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'conditional_steps_multiple_optional_condition_groups.convo.txt')
+      const transript = await this.compiler.convos[0].Run(this.container)
+      assert.equal(transript.steps.length, 2)
+    })
   })
 })

package/test/scripting/matching/matchingmode.spec.js

@@ -207,7 +207,10 @@ describe('scripting.matching.matchingmode', function () {
         'umm',
         'interesting',
         'really?'
-      ], 'test')
+      ],
+      'test',
+      null,
+      {})
     })
   })