botium-core 1.14.9 → 1.14.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botium-core",
-  "version": "1.14.9",
+  "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) {
@@ -426,7 +437,8 @@ class Convo {
             } catch (err) {
               transcriptStep.botEnd = new Date()
 
-              if (convoStep.optional) {
+              if (!(err.message.indexOf('Bot did not respond within') < 0) && convoStep.optional) {
+                skipOptionalStep = true
                 continue
               }
 
@@ -512,6 +524,7 @@ class Convo {
                 }
                 waitForBotSays = false
                 skipTranscriptStep = true
+                optionalStepAssertionError = true
                 return true
               } else if (retryOn) {
                 if (!retryBotMessageTimeoutEnd || retryBotMessageConvoId !== convoStep.stepTag) {
@@ -531,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
               }
             }
@@ -547,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
@@ -555,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
@@ -564,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
@@ -574,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
               }
 
@@ -611,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/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/transcript.spec.js

@@ -49,6 +49,57 @@ const echoConnectorMultipleBotMessages = ({ queueBotSays }) => {
   }
 }
 
+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 = {
@@ -92,6 +143,26 @@ describe('convo.transcript', function () {
     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()
@@ -189,13 +260,34 @@ describe('convo.transcript', function () {
     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, 6)
+    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')

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)
+  })
+})