botium-core 1.14.1 → 1.14.3

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/matching/matchingmode.spec.js

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

package/test/scripting/scriptingProvider.spec.js

@@ -5,6 +5,7 @@ const { Convo } = require('../../src/scripting/Convo')
 const ScriptingProvider = require('../../src/scripting/ScriptingProvider')
 const DefaultCapabilities = require('../../src/Defaults').Capabilities
 const Capabilities = require('../../src/Capabilities')
+const { LOGIC_HOOK_EVENTS } = require('../../src/scripting/logichook/LogicHookConsts')
 
 describe('scripting.scriptingProvider', function () {
   describe('ReadScriptsFromDirectory', function () {
@@ -65,7 +66,7 @@ describe('scripting.scriptingProvider', function () {
       assert.equal(tomatch.length, 2)
       assert.equal(tomatch[0], 'TEXT1')
       assert.equal(tomatch[1], 'TEXT2')
-      scriptingContext.scriptingEvents.assertBotResponse('TEXT1', tomatch, 'test1')
+      scriptingContext.scriptingEvents.assertBotResponse('TEXT1', tomatch, 'test1', null, {})
     })
     it('should resolve multiple utterance', async function () {
       const scriptingProvider = new ScriptingProvider(DefaultCapabilities)
@@ -85,7 +86,7 @@ describe('scripting.scriptingProvider', function () {
       assert.equal(tomatchUtt1.length, 2)
       assert.equal(tomatchUtt1[0], 'TEXT1')
       assert.equal(tomatchUtt1[1], 'TEXT2')
-      scriptingContext.scriptingEvents.assertBotResponse('TEXT1', tomatchUtt1, 'test1')
+      scriptingContext.scriptingEvents.assertBotResponse('TEXT1', tomatchUtt1, 'test1', null, {})
       const tomatchUtt2 = scriptingContext.scriptingEvents.resolveUtterance({ utterance: 'utt2' })
       assert.isArray(tomatchUtt2)
       assert.equal(tomatchUtt2.length, 2)
@@ -121,7 +122,7 @@ describe('scripting.scriptingProvider', function () {
       assert.equal(tomatch.length, 1)
       assert.equal(tomatch[0], 'utt2')
       try {
-        scriptingContext.scriptingEvents.assertBotResponse('TEXT1', tomatch, 'test1')
+        scriptingContext.scriptingEvents.assertBotResponse('TEXT1', tomatch, 'test1', null, {})
         assert.fail('expected error')
       } catch (err) {
         assert.isTrue(err.message.indexOf('Bot response') > 0)
@@ -141,7 +142,7 @@ describe('scripting.scriptingProvider', function () {
         utterances: ['TEXT1', 'TEXT2']
       })
       try {
-        scriptingContext.scriptingEvents.assertBotResponse('TEXT1', 'utt1', 'test1')
+        scriptingContext.scriptingEvents.assertBotResponse('TEXT1', 'utt1', 'test1', null, {})
         assert.fail('expected error')
       } catch (err) {
         assert.isTrue(err.message.indexOf('Bot response') > 0)
@@ -166,7 +167,7 @@ describe('scripting.scriptingProvider', function () {
       assert.equal(tomatch.length, 2)
       assert.equal(tomatch[0], 'TEXT1 hello')
       assert.equal(tomatch[1], 'TEXT2 hello')
-      scriptingContext.scriptingEvents.assertBotResponse('TEXT1 hello', tomatch, 'test1')
+      scriptingContext.scriptingEvents.assertBotResponse('TEXT1 hello', tomatch, 'test1', null, {})
     })
     it('should resolve and append utterance args', async function () {
       const scriptingProvider = new ScriptingProvider(DefaultCapabilities)
@@ -182,7 +183,7 @@ describe('scripting.scriptingProvider', function () {
       assert.equal(tomatch.length, 2)
       assert.equal(tomatch[0], 'TEXT1 hello')
       assert.equal(tomatch[1], 'TEXT2 hello')
-      scriptingContext.scriptingEvents.assertBotResponse('TEXT1 hello', tomatch, 'test1')
+      scriptingContext.scriptingEvents.assertBotResponse('TEXT1 hello', tomatch, 'test1', null, {})
     })
 
     describe('should resolve utterance with ambiguous scripting memory variable (with a debug message)', function () {
@@ -909,7 +910,7 @@ describe('scripting.scriptingProvider', function () {
       await scriptingProvider.Build()
       const scriptingContext = scriptingProvider._buildScriptContext()
       try {
-        scriptingContext.scriptingEvents.assertBotResponse('actual', 'expected', 'test1')
+        scriptingContext.scriptingEvents.assertBotResponse('actual', 'expected', 'test1', null, {})
         assert.fail('expected error')
       } catch (err) {
         assert.equal(err.message, 'test1: Bot response "actual" expected to match "expected"')
@@ -920,7 +921,7 @@ describe('scripting.scriptingProvider', function () {
       await scriptingProvider.Build()
       const scriptingContext = scriptingProvider._buildScriptContext()
       try {
-        scriptingContext.scriptingEvents.assertBotResponse(null, 'expected', 'test1')
+        scriptingContext.scriptingEvents.assertBotResponse(null, 'expected', 'test1', null, {})
         assert.fail('expected error')
       } catch (err) {
         assert.equal(err.message, 'test1: Bot response <no response> expected to match "expected"')
@@ -931,7 +932,7 @@ describe('scripting.scriptingProvider', function () {
       await scriptingProvider.Build()
       const scriptingContext = scriptingProvider._buildScriptContext()
       try {
-        scriptingContext.scriptingEvents.assertBotResponse('actual', ['expected1', 'expected2'], 'test1')
+        scriptingContext.scriptingEvents.assertBotResponse('actual', ['expected1', 'expected2'], 'test1', null, {})
         assert.fail('expected error')
       } catch (err) {
         assert.equal(err.message, 'test1: Bot response "actual" expected to match one of "expected1", "expected2"')
@@ -945,7 +946,7 @@ describe('scripting.scriptingProvider', function () {
       await scriptingProvider.Build()
       const scriptingContext = scriptingProvider._buildScriptContext()
       try {
-        scriptingContext.scriptingEvents.assertBotNotResponse('Keine Antwort gefunden!', ['Keine Antwort gefunden'], 'test1')
+        scriptingContext.scriptingEvents.assertBotNotResponse('Keine Antwort gefunden!', ['Keine Antwort gefunden'], 'test1', null, {})
         assert.fail('expected error')
       } catch (err) {
         assert.equal(err.message, 'test1: Bot response "Keine Antwort gefunden!" expected NOT to match "Keine Antwort gefunden"')
@@ -956,7 +957,7 @@ describe('scripting.scriptingProvider', function () {
       await scriptingProvider.Build()
       const scriptingContext = scriptingProvider._buildScriptContext()
       try {
-        scriptingContext.scriptingEvents.assertBotNotResponse('Keine Antwort gefunden!', [''], 'test1')
+        scriptingContext.scriptingEvents.assertBotNotResponse('Keine Antwort gefunden!', [''], 'test1', null, {})
         assert.fail('expected error')
       } catch (err) {
         assert.equal(err.message, 'test1: Bot response "Keine Antwort gefunden!" expected NOT to match <any response>')
@@ -967,11 +968,36 @@ describe('scripting.scriptingProvider', function () {
       await scriptingProvider.Build()
       const scriptingContext = scriptingProvider._buildScriptContext()
       try {
-        scriptingContext.scriptingEvents.assertBotNotResponse('', [''], 'test1')
+        scriptingContext.scriptingEvents.assertBotNotResponse('', [''], 'test1', null, {})
         assert.fail('expected error')
       } catch (err) {
         assert.equal(err.message, 'test1: Bot response <no response> expected NOT to match <any response>')
       }
     })
   })
+
+  describe('should call logichooks and userinputs even if there is no convo (logichook from livechat, and crawler)', function () {
+    LOGIC_HOOK_EVENTS.forEach(async (eventName) => {
+      it(`Logichook, event: ${eventName}`, async function () {
+        const scriptingProvider = new ScriptingProvider(Object.assign({}, DefaultCapabilities, {
+          [Capabilities.LOGIC_HOOKS]: [{
+            ref: 'SET_TEXT_FROM_HOOK',
+            src: {
+              [eventName]: ({ someobject, args }) => {
+                someobject.testAttribute = 'testAttributeValue'
+              }
+            },
+            global: true
+          }]
+        }))
+        await scriptingProvider.Build()
+        const scriptingContext = scriptingProvider._buildScriptContext()
+        const someobject = {}
+        await scriptingContext.scriptingEvents[eventName]({
+          someobject
+        })
+        assert.equal(someobject.testAttribute, 'testAttributeValue')
+      })
+    })
+  })
 })