botium-core 1.14.8 → 1.14.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botium-core",
-  "version": "1.14.8",
+  "version": "1.14.10",
   "description": "The Selenium for Chatbots",
   "main": "index.js",
   "module": "dist/botium-es.js",
@@ -63,6 +63,7 @@
     "socketio-auth": "^0.1.1",
     "swagger-jsdoc": "^6.2.8",
     "swagger-ui-express": "^5.0.0",
+    "tinyglobby": "^0.2.10",
     "uuid": "^9.0.1",
     "word-error-rate": "0.0.7",
     "write-yaml": "^1.0.0",

package/src/scripting/Convo.js

@@ -277,6 +277,10 @@ class Convo {
       let skipTranscriptStep = false
       let conditionalGroupId = null
       let conditionMetInGroup = false
+      let skipOptionalStep = false
+      // If there are optional step(s) in the conversation, and the message from the bot fails on each optional bot step(s) and/or mandatory bot step, then we have an unexpected message.
+      // So in this case an unexpected error should be shown instead of the latest assertion error.
+      let optionalStepAssertionError = false
       let globalConvoStepParameters = container.caps[Capabilities.SCRIPTING_CONVO_STEP_PARAMETERS] || {}
       let retryBotMessageTimeoutEnd = null
       let retryBotMessageConvoId = null
@@ -284,6 +288,13 @@ class Convo {
       for (let i = 0; i < this.conversation.length; i = (retryBotMessageDropBotResponse ? i : i + 1)) {
         retryBotMessageDropBotResponse = false
         const convoStep = this.conversation[i]
+        if (!convoStep.optional) {
+          skipOptionalStep = false
+        }
+        if (convoStep.optional && skipOptionalStep) {
+          // If there are multiple optional steps, and the previous optional step was timeout, then the next optional step should be skipped to prevent too long convo run with multiple timeout.
+          continue
+        }
         const rawConvoStepParameters = convoStep.logicHooks.find(lh => lh.name === 'CONVO_STEP_PARAMETERS')?.args
         let convoStepParameters = {}
         if (rawConvoStepParameters && rawConvoStepParameters.length) {
@@ -416,7 +427,7 @@ class Convo {
               await this.scriptingEvents.onBotStart({ convo: this, convoStep, container, scriptingMemory, transcript, transcriptStep })
               transcriptStep.botBegin = new Date()
               if (!botMsg) {
-                botMsg = await container.WaitBotSays(convoStep.channel)
+                botMsg = await container.WaitBotSays(convoStep.channel, convoStepParameters?.stepTimeout)
               }
               transcriptStep.botEnd = new Date()
               transcriptStep.actual = new BotiumMockMessage(botMsg)
@@ -426,6 +437,11 @@ class Convo {
             } catch (err) {
               transcriptStep.botEnd = new Date()
 
+              if (!(err.message.indexOf('Bot did not respond within') < 0) && convoStep.optional) {
+                skipOptionalStep = true
+                continue
+              }
+
               const failErr = botiumErrorFromErr(`${this.header.name}/${convoStep.stepTag}: error waiting for bot - ${err.message}`, err)
               debug(failErr)
               try {
@@ -508,6 +524,7 @@ class Convo {
                 }
                 waitForBotSays = false
                 skipTranscriptStep = true
+                optionalStepAssertionError = true
                 return true
               } else if (retryOn) {
                 if (!retryBotMessageTimeoutEnd || retryBotMessageConvoId !== convoStep.stepTag) {
@@ -527,9 +544,18 @@ class Convo {
               }
 
               if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]) {
-                assertErrors.push(err)
+                if (optionalStepAssertionError) {
+                  optionalStepAssertionError = false
+                  assertErrors.push(new BotiumError(`${this.header.name}: Unexpected message.`))
+                } else {
+                  assertErrors.push(err)
+                }
                 return false
               } else {
+                if (optionalStepAssertionError) {
+                  optionalStepAssertionError = false
+                  throw new BotiumError(`${this.header.name}: Unexpected message.`)
+                }
                 throw err
               }
             }
@@ -543,6 +569,7 @@ class Convo {
               if (convoStep.not) {
                 try {
                   this.scriptingEvents.assertBotNotResponse(response, tomatch, `${this.header.name}/${convoStep.stepTag}`, lastMeConvoStep, convoStepParameters)
+                  optionalStepAssertionError = false
                 } catch (err) {
                   if (isErrorHandledWithOptionConvoStep(err)) {
                     continue
@@ -551,6 +578,7 @@ class Convo {
               } else {
                 try {
                   this.scriptingEvents.assertBotResponse(response, tomatch, `${this.header.name}/${convoStep.stepTag}`, lastMeConvoStep, convoStepParameters)
+                  optionalStepAssertionError = false
                 } catch (err) {
                   if (isErrorHandledWithOptionConvoStep(err)) {
                     continue
@@ -560,6 +588,7 @@ class Convo {
             } else if (convoStep.sourceData) {
               try {
                 this._compareObject(container, scriptingMemory, convoStep, botMsg.sourceData, convoStep.sourceData, botMsg, convoStepParameters)
+                optionalStepAssertionError = false
               } catch (err) {
                 if (isErrorHandledWithOptionConvoStep(err)) {
                   continue
@@ -570,11 +599,13 @@ class Convo {
             try {
               await this.scriptingEvents.assertConvoStep({ convo: this, convoStep, container, scriptingMemory, botMsg, transcript, transcriptStep })
               await this.scriptingEvents.onBotEnd({ convo: this, convoStep, container, scriptingMemory, botMsg, transcript, transcriptStep })
+              optionalStepAssertionError = false
             } catch (err) {
               const nextConvoStep = this.conversation[i + 1]
               if (convoStep.optional && nextConvoStep && nextConvoStep.sender === 'bot') {
                 waitForBotSays = false
                 skipTranscriptStep = true
+                optionalStepAssertionError = true
                 continue
               }
 
@@ -607,8 +638,17 @@ class Convo {
                 } catch (failErr) {
                 }
                 if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS] && err instanceof BotiumError) {
-                  assertErrors.push(err)
+                  if (optionalStepAssertionError) {
+                    optionalStepAssertionError = false
+                    assertErrors.push(new BotiumError(`${this.header.name}: Unexpected message.`))
+                  } else {
+                    assertErrors.push(err)
+                  }
                 } else {
+                  if (optionalStepAssertionError) {
+                    optionalStepAssertionError = false
+                    throw new BotiumError(`${this.header.name}: Unexpected message.`)
+                  }
                   throw failErr
                 }
               }

package/src/scripting/ScriptingProvider.js

@@ -83,9 +83,9 @@ module.exports = class ScriptingProvider {
     this.utterances = {}
     this.matchFn = null
     this.asserters = {}
-    this.globalAsserter = {}
+    this.globalAsserters = {}
     this.logicHooks = {}
-    this.globalLogicHook = {}
+    this.globalLogicHooks = {}
     this.userInputs = {}
     this.partialConvos = {}
     this.scriptingMemories = []
@@ -319,8 +319,9 @@ module.exports = class ScriptingProvider {
       }
     }
 
-    const convoAsserter = asserters
-      .filter(a => this.asserters[a.name][asserterType])
+    const localAsserters = (asserters || []).filter(a => this.asserters[a.name][asserterType])
+
+    const convoStepPromises = localAsserters
       .map(a => ({
         asserter: a,
         promise: callAsserter(a, this.asserters[a.name], {
@@ -335,8 +336,12 @@ module.exports = class ScriptingProvider {
       }))
       .map(({ promise, asserter }) => updateExceptionContext(promise, asserter))
 
-    const globalAsserter = Object.values(this.globalAsserter)
+    const globalAsserters = Object.keys(this.globalAsserters)
+      .filter(name => localAsserters.map(a => a.name).indexOf(name) < 0)
+      .reduce((agg, name) => [...agg, this.globalAsserters[name]], [])
       .filter(a => a[asserterType])
+
+    const globalPromises = globalAsserters
       .map(a => ({
         asserter: a,
         promise: p(this.retryHelperAsserter, () => a[asserterType]({
@@ -351,7 +356,7 @@ module.exports = class ScriptingProvider {
       }))
       .map(({ promise, asserter }) => updateExceptionContext(promise, asserter))
 
-    const allPromises = [...convoAsserter, ...globalAsserter]
+    const allPromises = [...convoStepPromises, ...globalPromises]
     if (this.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]) {
       return Promise.allSettled(allPromises).then((results) => {
         const rejected = results.filter(result => result.status === 'rejected').map(result => result.reason)
@@ -372,8 +377,7 @@ module.exports = class ScriptingProvider {
       throw Error(`Unknown hookType ${hookType}`)
     }
 
-    const localHooks = (logicHooks || [])
-      .filter(l => this.logicHooks[l.name][hookType])
+    const localHooks = (logicHooks || []).filter(l => this.logicHooks[l.name][hookType])
 
     const convoStepPromises = localHooks
       .map(l => p(this.retryHelperLogicHook, () => this.logicHooks[l.name][hookType]({
@@ -386,7 +390,10 @@ module.exports = class ScriptingProvider {
         ...rest
       })))
 
-    const globalHooks = Object.values(this.globalLogicHook).filter(l => l[hookType])
+    const globalHooks = Object.keys(this.globalLogicHooks)
+      .filter(name => localHooks.map(l => l.name).indexOf(name) < 0)
+      .reduce((agg, name) => [...agg, this.globalLogicHooks[name]], [])
+      .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]
@@ -499,9 +506,9 @@ module.exports = class ScriptingProvider {
 
     const logicHookUtils = new LogicHookUtils({ buildScriptContext: this._buildScriptContext(), caps: this.caps })
     this.asserters = logicHookUtils.asserters
-    this.globalAsserter = logicHookUtils.getGlobalAsserter()
+    this.globalAsserters = logicHookUtils.getGlobalAsserters()
     this.logicHooks = logicHookUtils.logicHooks
-    this.globalLogicHook = logicHookUtils.getGlobalLogicHook()
+    this.globalLogicHooks = logicHookUtils.getGlobalLogicHooks()
     this.userInputs = logicHookUtils.userInputs
   }
 

package/src/scripting/helper.js

@@ -404,13 +404,6 @@ const validateConvo = (convo) => {
       if (optionalSet.size > 1) {
         validationResult.errors.push(new Error(`Step ${i + 1}: Failed to decompile conversation. Mixed optional flag is not allowed inside one step.`))
       }
-
-      if (optionalSet.size === 1 && optionalSet.has(true)) {
-        const nextStep = convo.conversation[i + 1]
-        if (!nextStep || nextStep.sender !== 'bot') {
-          validationResult.errors.push(new Error(`Step ${i + 1}: Optional bot convo step has to be followed by a bot convo step.`))
-        }
-      }
     }
     if (!validateSender(step.sender)) {
       validationResult.errors.push(new Error(`Step ${i + 1}: Sender #${step.sender} is invalid.`))
@@ -456,6 +449,10 @@ const convoStepToLines = (step) => {
   } else {
     if (step.messageText) {
       lines.push((step.optional ? '?' : '') + (step.not ? '!' : '') + step.messageText)
+    } else {
+      if (step.optional) {
+        lines.push('?')
+      }
     }
     if (step.buttons && step.buttons.length > 0) lines.push('BUTTONS' + _formatAppendArgs(step.buttons.filter(b => b.text).map(b => flatString(b.text))))
     if (step.media && step.media.length > 0) lines.push('MEDIA' + _formatAppendArgs(step.media.filter(m => !m.buffer && m.mediaUri).map(m => m.mediaUri)))

package/src/scripting/logichook/LogicHookUtils.js

@@ -24,9 +24,9 @@ const _ = require('lodash')
 module.exports = class LogicHookUtils {
   constructor ({ buildScriptContext, caps }) {
     this.asserters = {}
-    this.globalAsserters = []
+    this.globalAsserterNames = []
     this.logicHooks = {}
-    this.globalLogicHooks = []
+    this.globalLogicHookNames = []
     this.userInputs = {}
     this.buildScriptContext = buildScriptContext
     this.caps = caps
@@ -64,7 +64,7 @@ module.exports = class LogicHookUtils {
         }
         this.asserters[asserter.ref] = this._loadClass(asserter, 'asserter')
         if (asserter.global) {
-          this.globalAsserters.push(asserter.ref)
+          this.globalAsserterNames.push(asserter.ref)
         }
       })
   }
@@ -77,7 +77,7 @@ module.exports = class LogicHookUtils {
         }
         this.logicHooks[logicHook.ref] = this._loadClass(logicHook, 'logichook')
         if (logicHook.global) {
-          this.globalLogicHooks.push(logicHook.ref)
+          this.globalLogicHookNames.push(logicHook.ref)
         }
       })
   }
@@ -92,14 +92,12 @@ module.exports = class LogicHookUtils {
       })
   }
 
-  getGlobalAsserter () {
-    return this.globalAsserters
-      .map(name => this.asserters[name])
+  getGlobalAsserters () {
+    return this.globalAsserterNames.reduce((agg, name) => ({ ...agg, [name]: this.asserters[name] }), {})
   }
 
-  getGlobalLogicHook () {
-    return this.globalLogicHooks
-      .map(name => this.logicHooks[name])
+  getGlobalLogicHooks () {
+    return this.globalLogicHookNames.reduce((agg, name) => ({ ...agg, [name]: this.logicHooks[name] }), {})
   }
 
   _loadClass ({ src, ref, args }, hookType) {

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

@@ -1,6 +1,6 @@
 const fs = require('fs')
 const path = require('path')
-const globby = require('globby')
+const globSync = require('tinyglobby').globSync
 const request = require('request')
 const mime = require('mime-types')
 const url = require('url')
@@ -161,7 +161,7 @@ module.exports = class MediaInput {
       const baseDir = this._getBaseDir(convo)
       return args.reduce((e, arg) => {
         if (this._isWildcard(arg)) {
-          const mediaFiles = globby.sync(arg, { cwd: baseDir, gitignore: true })
+          const mediaFiles = globSync(arg, { cwd: baseDir })
           mediaFiles.forEach(mf => {
             e.push({
               name: 'MEDIA',

package/test/convo/convos/welcome_multiple_botsteps_opt.convo.txt

@@ -0,0 +1,22 @@
+welcome multiple botsteps opt
+
+#me
+Welcome
+
+#bot
+Welcome
+
+#bot
+?Select an option:
+CONVO_STEP_PARAMETERS {"stepTimeout": 300}
+
+#bot
+?
+?BUTTONS First Button|Second Button
+CONVO_STEP_PARAMETERS {"stepTimeout": 300}
+
+#me
+Thanks
+
+#bot
+Thanks

package/test/convo/transcript.spec.js

@@ -21,6 +21,85 @@ const echoConnector = ({ queueBotSays }) => {
   }
 }
 
+const echoConnectorMultipleBotMessages = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: msg.messageText }
+      if (msg.messageText === 'Welcome') {
+        botMsg.messageText = 'Welcome'
+        queueBotSays(botMsg)
+
+        setTimeout(() => {
+          botMsg.messageText = 'Select an option:'
+          queueBotSays(botMsg)
+        }, 200)
+
+        setTimeout(() => {
+          botMsg.messageText = ''
+          botMsg.buttons = [
+            { text: 'First Button' },
+            { text: 'Second Button' }
+          ]
+          queueBotSays(botMsg)
+        }, 200)
+      } else {
+        queueBotSays(botMsg)
+      }
+    }
+  }
+}
+
+const echoConnectorMultipleBotMessagesSkipAnOptional = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: msg.messageText }
+      if (msg.messageText === 'Welcome') {
+        botMsg.messageText = 'Welcome'
+        queueBotSays(botMsg)
+
+        setTimeout(() => {
+          botMsg.messageText = ''
+          botMsg.buttons = [
+            { text: 'First Button' },
+            { text: 'Second Button' }
+          ]
+          queueBotSays(botMsg)
+        }, 200)
+      } else {
+        queueBotSays(botMsg)
+      }
+    }
+  }
+}
+
+const echoConnectorMultipleBotMessagesAssertionFailOnOptional = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: msg.messageText }
+      if (msg.messageText === 'Welcome') {
+        botMsg.messageText = 'Welcome'
+        queueBotSays(botMsg)
+
+        setTimeout(() => {
+          botMsg.messageText = 'Fail on this:'
+          queueBotSays(botMsg)
+        }, 200)
+
+        setTimeout(() => {
+          botMsg.messageText = ''
+          botMsg.buttons = [
+            { text: 'First Button' },
+            { text: 'Second Button' }
+          ]
+          queueBotSays(botMsg)
+        }, 200)
+      } else {
+        queueBotSays(botMsg)
+      }
+    }
+  }
+}
+
 describe('convo.transcript', function () {
   beforeEach(async function () {
     const myCaps = {
@@ -54,6 +133,36 @@ describe('convo.transcript', function () {
     this.compilerSkipAssertErrors = this.driverSkipAssertErrors.BuildCompiler()
     this.containerSkipAssertErrors = await this.driverSkipAssertErrors.Build()
     await this.containerSkipAssertErrors.Start()
+
+    const myCapsMultipleBotMessages = {
+      [Capabilities.PROJECTNAME]: 'convo.transcript',
+      [Capabilities.CONTAINERMODE]: echoConnectorMultipleBotMessages,
+      [Capabilities.SCRIPTING_FORCE_BOT_CONSUMED]: true
+    }
+    this.driverMultipleBotmessages = new BotDriver(myCapsMultipleBotMessages)
+    this.compilerMultipleBotmessages = this.driverMultipleBotmessages.BuildCompiler()
+    this.containerMultipleBotmessages = await this.driverMultipleBotmessages.Build()
+    await this.containerMultipleBotmessages.Start()
+
+    const myCapsMultipleBotMessagesSkipAnOptional = {
+      [Capabilities.PROJECTNAME]: 'convo.transcript',
+      [Capabilities.CONTAINERMODE]: echoConnectorMultipleBotMessagesSkipAnOptional,
+      [Capabilities.SCRIPTING_FORCE_BOT_CONSUMED]: true
+    }
+    this.driverMultipleBotmessagesSkipAnOptional = new BotDriver(myCapsMultipleBotMessagesSkipAnOptional)
+    this.compilerMultipleBotmessagesSkipAnOptional = this.driverMultipleBotmessagesSkipAnOptional.BuildCompiler()
+    this.containerMultipleBotmessagesSkipAnOptional = await this.driverMultipleBotmessagesSkipAnOptional.Build()
+    await this.containerMultipleBotmessagesSkipAnOptional.Start()
+
+    const myCapsMultipleBotMessagesAssertionFailOnOptional = {
+      [Capabilities.PROJECTNAME]: 'convo.transcript',
+      [Capabilities.CONTAINERMODE]: echoConnectorMultipleBotMessagesAssertionFailOnOptional,
+      [Capabilities.SCRIPTING_FORCE_BOT_CONSUMED]: true
+    }
+    this.driverMultipleBotmessagesAssertionFailOnOptional = new BotDriver(myCapsMultipleBotMessagesAssertionFailOnOptional)
+    this.compilerMultipleBotmessagesAssertionFailOnOptional = this.driverMultipleBotmessagesAssertionFailOnOptional.BuildCompiler()
+    this.containerMultipleBotmessagesAssertionFailOnOptional = await this.driverMultipleBotmessagesAssertionFailOnOptional.Build()
+    await this.containerMultipleBotmessagesAssertionFailOnOptional.Start()
   })
   afterEach(async function () {
     await this.container.Stop()
@@ -143,6 +252,43 @@ describe('convo.transcript', function () {
     assert.isDefined(transcript)
     assert.equal(transcript.steps.length, 2)
   })
+  it('should provide transcript optional multiple bot steps on getting all bot messages', async function () {
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'welcome_multiple_botsteps_opt.convo.txt')
+    assert.equal(this.compiler.convos.length, 1)
+
+    const transcript = await this.compiler.convos[0].Run(this.containerMultipleBotmessages)
+    assert.isDefined(transcript)
+    assert.equal(transcript.steps.length, 6)
+  })
+  it('should provide transcript optional multiple bot steps on skip an optional bot messages', async function () {
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'welcome_multiple_botsteps_opt.convo.txt')
+    assert.equal(this.compiler.convos.length, 1)
+
+    const transcript = await this.compiler.convos[0].Run(this.containerMultipleBotmessagesSkipAnOptional)
+    assert.isDefined(transcript)
+    assert.equal(transcript.steps.length, 5)
+  })
+  it('should provide transcript optional multiple bot steps assertion fail on optional bot messages', async function () {
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'welcome_multiple_botsteps_opt.convo.txt')
+    assert.equal(this.compiler.convos.length, 1)
+
+    try {
+      await this.compiler.convos[0].Run(this.containerMultipleBotmessagesAssertionFailOnOptional)
+      assert.fail('expected error')
+    } catch (err) {
+      assert.isDefined(err.transcript)
+      assert.equal(err.transcript.steps.length, 3)
+      assert.isTrue(err.message.includes('Unexpected message'))
+    }
+  })
+  it('should provide transcript optional multiple bot steps on not getting all bot messages', async function () {
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'welcome_multiple_botsteps_opt.convo.txt')
+    assert.equal(this.compiler.convos.length, 1)
+
+    const transcript = await this.compiler.convos[0].Run(this.container)
+    assert.isDefined(transcript)
+    assert.equal(transcript.steps.length, 5)
+  })
   it('should include pause in transcript steps', async function () {
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '2stepsWithPause.convo.txt')
     assert.equal(this.compiler.convos.length, 1)

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

@@ -84,6 +84,12 @@ describe('scripting.asserters.convoStepParametersForAssert', function () {
 
       await this.compiler.convos[0].Run(this.container)
     })
+    it('should skip optional bot message', async function () {
+      this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convo_step_parameter_optional_with_timeout.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)

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

@@ -0,0 +1,16 @@
+convo_step_parameter_retry_main_good
+
+#me
+Hello
+
+#bot
+You said Hello
+
+#bot
+?Wrong answer
+
+#me
+Hello2
+
+#bot
+You said Hello2

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

@@ -0,0 +1,105 @@
+const Constants = require('../../../src/scripting/Constants')
+const assert = require('chai').assert
+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)
+    }
+  }
+}
+
+const buildDriver = async (mergeCaps) => {
+  const myCaps = Object.assign({
+    [Capabilities.PROJECTNAME]: 'convo.localvsglobal',
+    [Capabilities.CONTAINERMODE]: echoConnector()
+  }, mergeCaps)
+
+  const result = {}
+  result.driver = new BotDriver(myCaps)
+  result.compiler = result.driver.BuildCompiler()
+  result.container = await result.driver.Build()
+  return result
+}
+
+const convoScriptAsserters = `
+LOCALVSGLOBAL
+
+#me
+hello
+
+#bot
+
+#me
+hello 2
+
+#bot
+MYASSERTER
+`
+
+const convoScriptHooks = `
+LOCALVSGLOBAL
+
+#me
+hello
+
+#bot
+
+#me
+hello 2
+
+#bot
+MYHOOK
+`
+
+describe('Using local and global hooks together', function () {
+  it('should use local and global asserter', async function () {
+    let localAssertionCount = 0
+    let globalAssertionCount = 0
+
+    const { compiler, container } = await buildDriver({
+      [Capabilities.ASSERTERS]: [{
+        ref: 'MYASSERTER',
+        src: {
+          assertConvoStep: ({ isGlobal }) => {
+            if (isGlobal) globalAssertionCount++
+            else localAssertionCount++
+            return Promise.resolve()
+          }
+        },
+        global: true
+      }]
+    })
+
+    compiler.ReadScriptFromBuffer(Buffer.from(convoScriptAsserters), Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_CONVO)
+    await compiler.convos[0].Run(container)
+    assert.equal(localAssertionCount, 1)
+    assert.equal(globalAssertionCount, 1)
+  })
+  it('should use local and global logic hooks', async function () {
+    let localHookCount = 0
+    let globalHookCount = 0
+
+    const { compiler, container } = await buildDriver({
+      [Capabilities.LOGIC_HOOKS]: [{
+        ref: 'MYHOOK',
+        src: {
+          onBotEnd: ({ isGlobal }) => {
+            if (isGlobal) globalHookCount++
+            else localHookCount++
+            return Promise.resolve()
+          }
+        },
+        global: true
+      }]
+    })
+
+    compiler.ReadScriptFromBuffer(Buffer.from(convoScriptHooks), Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_CONVO)
+    await compiler.convos[0].Run(container)
+    assert.equal(localHookCount, 1)
+    assert.equal(globalHookCount, 1)
+  })
+})

package/test/scripting/txt/decompile.spec.js

@@ -126,31 +126,6 @@ botText2
 `
     )
   })
-  it('should fail decompile convo with optional step not followed bot step', async function () {
-    const scriptingProvider = new ScriptingProvider(DefaultCapabilities)
-    await scriptingProvider.Build()
-
-    const convo = {
-      header: {
-        name: 'test convo'
-      },
-      conversation: [
-        {
-          sender: 'bot',
-          messageText: 'botText',
-          not: true,
-          optional: true
-        }
-      ]
-    }
-
-    try {
-      scriptingProvider.Decompile([convo], 'SCRIPTING_FORMAT_TXT')
-      assert.fail('expected error')
-    } catch (err) {
-      assert.equal(err.message, 'Step 1: Optional bot convo step has to be followed by a bot convo step.')
-    }
-  })
   it('should fail decompile convo with mixed optional step', async function () {
     const scriptingProvider = new ScriptingProvider(DefaultCapabilities)
     await scriptingProvider.Build()