botium-core 1.13.16 → 1.13.18

package/src/scripting/logichook/asserter/WerAsserter.js

@@ -1,6 +1,6 @@
 // const _ = require('lodash')
 const { BotiumError } = require('../../BotiumError')
-const { calculateWer } = require('../../helper')
+const { calculateWer, toPercent } = require('../../helper')
 
 module.exports = class WerAsserter {
   constructor (context, caps = {}) {
@@ -9,6 +9,55 @@ module.exports = class WerAsserter {
     this.name = 'Word Error Rate Asserter'
   }
 
+  assertNotConvoStep ({ convo, convoStep, args, botMsg }) {
+    if (!args || args.length < 1) {
+      return Promise.reject(new BotiumError(`${convoStep.stepTag}: ${this.name} - no argument given`,
+        {
+          type: 'asserter',
+          subtype: 'wrong parameters',
+          source: this.name,
+          cause: { args }
+        }
+      ))
+    }
+    if (args.length > 2) {
+      return Promise.reject(new BotiumError(`${convoStep.stepTag}: ${this.name} - too many arguments "${args}"`,
+        {
+          type: 'asserter',
+          subtype: 'wrong parameters',
+          source: this.name,
+          cause: { args }
+        }
+      ))
+    }
+
+    const utterance = args[0]
+    const threshold = ([',', '.'].find(p => `${args[1]}`.includes(p)) ? parseFloat(args[1]) : parseInt(args[1]) / 100).toFixed(2)
+
+    const wer = calculateWer(botMsg.messageText, utterance)
+
+    if (wer < threshold) {
+      return Promise.reject(new BotiumError(
+        `${convoStep.stepTag}: Word Error Rate (${toPercent(wer)}) lower than accepted (${toPercent(threshold)})`,
+        {
+          type: 'asserter',
+          source: this.name,
+          context: {
+            params: {
+              args
+            }
+          },
+          cause: {
+            expected: `>=${toPercent(threshold)} (${utterance})`,
+            actual: `${toPercent(wer)} (${botMsg.messageText})`
+          }
+        }
+      ))
+    }
+
+    return Promise.resolve()
+  }
+
   assertConvoStep ({ convo, convoStep, args, botMsg }) {
     if (!args || args.length < 1) {
       return Promise.reject(new BotiumError(`${convoStep.stepTag}: ${this.name} - no argument given`,
@@ -37,10 +86,8 @@ module.exports = class WerAsserter {
     const wer = calculateWer(botMsg.messageText, utterance)
 
     if (wer > threshold) {
-      const _toPercent = (s) => `${(s * 100).toFixed(0)}%`
-
       return Promise.reject(new BotiumError(
-        `${convoStep.stepTag}: Word Error Rate (${_toPercent(wer)}) higher than accepted (${_toPercent(threshold)})`,
+        `${convoStep.stepTag}: Word Error Rate (${toPercent(wer)}) higher than accepted (${toPercent(threshold)})`,
         {
           type: 'asserter',
           source: this.name,
@@ -50,8 +97,8 @@ module.exports = class WerAsserter {
             }
           },
           cause: {
-            expected: `<=${_toPercent(threshold)}`,
-            actual: `${_toPercent(wer)}`
+            expected: `<=${toPercent(threshold)} (${utterance})`,
+            actual: `${toPercent(wer)} (${botMsg.messageText})`
           }
         }
       ))

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

@@ -1,4 +1,3 @@
-
 module.exports = class ClearQueueLogicHook {
   constructor (context, caps = {}) {
     this.context = context

package/test/connectors/logicHook.js

@@ -1,4 +1,3 @@
-
 module.exports = ({ requestOptions, context }) => {
   let counter = 1
   requestOptions.body = { bodyFieldRequestHook: counter++ }

package/test/connectors/simplerest.spec.js

@@ -319,7 +319,6 @@ describe('connectors.simplerest', function () {
       scope2.persist(false)
     })
   })
-
   describe('build', function () {
     it('should build JSON GET url', async function () {
       const myCaps = Object.assign({}, myCapsGet)
@@ -997,7 +996,6 @@ describe('connectors.simplerest', function () {
       assert.deepEqual(values, ['$.1', '$.2', '$.3', '$.4'])
     })
   })
-
   describe('useresponse', function () {
     beforeEach(async function () {
       this.init = async (caps) => {
@@ -1151,7 +1149,6 @@ describe('connectors.simplerest', function () {
       }
     })
   })
-
   describe('inbound', function () {
     it('should accept inbound message with matching jsonpath', async function () {
       const myCaps = Object.assign({}, myCapsGet)
@@ -1249,7 +1246,6 @@ describe('connectors.simplerest', function () {
       return result
     })
   })
-
   describe('polling', function () {
     it('should poll HTTP url', async function () {
       const caps = {
@@ -1313,4 +1309,83 @@ describe('connectors.simplerest', function () {
       scope.persist(false)
     }).timeout(5000)
   })
+  describe('flow', function () {
+    it('should ignore matching message', async function () {
+      const caps = {
+        [Capabilities.CONTAINERMODE]: 'simplerest',
+        [Capabilities.WAITFORBOTTIMEOUT]: 1000,
+        [Capabilities.SIMPLEREST_URL]: 'https://mock.com/flowignore',
+        [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: ['$.text'],
+        [Capabilities.SIMPLEREST_CONTEXT_IGNORE_JSONPATH]: '$.ignore',
+        [Capabilities.SIMPLEREST_CONTEXT_IGNORE_MATCH]: 'Y'
+      }
+      const scope = nock('https://mock.com')
+        .get('/flowignore').reply(200, { text: 'ignore it', ignore: 'Y' })
+
+      const driver = new BotDriver(caps)
+      const container = await driver.Build()
+      await container.Start()
+
+      await container.UserSays({ text: 'hallo' })
+      try {
+        await container.WaitBotSays()
+        assert.fail('expected response to be ignored')
+      } catch (err) {
+        assert.equal(err.message, 'Bot did not respond within 1s')
+      }
+      await container.Stop()
+      await container.Clean()
+      scope.persist(false)
+    })
+    it('should skip matching message', async function () {
+      const caps = {
+        [Capabilities.CONTAINERMODE]: 'simplerest',
+        [Capabilities.SIMPLEREST_URL]: 'https://mock.com/flowskip',
+        [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: ['$.text'],
+        [Capabilities.SIMPLEREST_CONTEXT_SKIP_JSONPATH]: '$.skip',
+        [Capabilities.SIMPLEREST_CONTEXT_SKIP_MATCH]: 'Y'
+      }
+      const scope = nock('https://mock.com')
+        .get('/flowskip').reply(200, { text: 'skip it', skip: 'Y' })
+        .get('/flowskip').reply(200, { text: 'not skip it', skip: 'N' })
+
+      const driver = new BotDriver(caps)
+      const container = await driver.Build()
+      await container.Start()
+
+      await container.UserSays({ text: 'hello' })
+      const botMsg = await container.WaitBotSays()
+      assert.equal(botMsg.messageText, 'not skip it')
+
+      await container.Stop()
+      await container.Clean()
+      scope.persist(false)
+    })
+    it('should continue on matching message', async function () {
+      const caps = {
+        [Capabilities.CONTAINERMODE]: 'simplerest',
+        [Capabilities.SIMPLEREST_URL]: 'https://mock.com/flowcontinue',
+        [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: ['$.text'],
+        [Capabilities.SIMPLEREST_CONTEXT_CONTINUE_JSONPATH]: '$.continue',
+        [Capabilities.SIMPLEREST_CONTEXT_CONTINUE_MATCH]: 'Y'
+      }
+      const scope = nock('https://mock.com')
+        .get('/flowcontinue').reply(200, { text: 'continue it', continue: 'Y' })
+        .get('/flowcontinue').reply(200, { text: 'not continue it', continue: 'N' })
+
+      const driver = new BotDriver(caps)
+      const container = await driver.Build()
+      await container.Start()
+
+      await container.UserSays({ text: 'hello' })
+      const botMsg1 = await container.WaitBotSays()
+      assert.equal(botMsg1.messageText, 'continue it')
+      const botMsg2 = await container.WaitBotSays()
+      assert.equal(botMsg2.messageText, 'not continue it')
+
+      await container.Stop()
+      await container.Clean()
+      scope.persist(false)
+    })
+  })
 })

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

@@ -12,28 +12,36 @@ describe('scripting.asserters.buttonsAsserter', function () {
     })
 
     it('should succeed on existing button', async function () {
+      const payload = {
+        value: 'test'
+      }
       await this.buttonsAsserter.assertConvoStep({
         convoStep: { stepTag: 'test' },
-        args: ['test'],
+        args: ['test', JSON.stringify(payload)],
         botMsg: {
           buttons: [
             {
-              text: 'test'
+              text: 'test',
+              payload
             }
           ]
         }
       })
     })
     it('should succeed on existing card button', async function () {
+      const payload = {
+        value: 'test'
+      }
       await this.buttonsAsserter.assertConvoStep({
         convoStep: { stepTag: 'test' },
-        args: ['test'],
+        args: ['test', JSON.stringify(payload)],
         botMsg: {
           cards: [
             {
               buttons: [
                 {
-                  text: 'test'
+                  text: 'test',
+                  payload
                 }
               ]
             }
@@ -42,42 +50,28 @@ describe('scripting.asserters.buttonsAsserter', function () {
       })
     })
     it('should succeed on existing card buttons', async function () {
+      const payload = {
+        value: 'test'
+      }
+      const payloadCard = {
+        value: 'card'
+      }
       await this.buttonsAsserter.assertConvoStep({
         convoStep: { stepTag: 'test' },
-        args: ['test', 'test1'],
-        botMsg: {
-          buttons: [
-            {
-              text: 'test'
-            }
-          ],
-          cards: [
-            {
-              buttons: [
-                {
-                  text: 'test1'
-                }
-              ]
-            }
-          ]
-        }
-      })
-    })
-    it('should succeed on existing card buttons 2', async function () {
-      await this.buttonsAsserter.assertConvoStep({
-        convoStep: { stepTag: 'test' },
-        args: ['test', 'test1'],
+        args: ['test', 'test1', JSON.stringify(payload), JSON.stringify(payloadCard)],
         botMsg: {
           buttons: [
             {
-              text: 'test'
+              text: 'test',
+              payload
             }
           ],
           cards: [
             {
               buttons: [
                 {
-                  text: 'test1'
+                  text: 'test1',
+                  payload: payloadCard
                 }
               ]
             }
@@ -86,29 +80,36 @@ describe('scripting.asserters.buttonsAsserter', function () {
       })
     })
     it('should succeed on not existing button', async function () {
+      const notPayload = {
+        value: 'test1'
+      }
       await this.buttonsAsserter.assertNotConvoStep({
         convoStep: { stepTag: 'test' },
-        args: ['test1'],
+        args: ['test1', JSON.stringify(notPayload)],
         botMsg: {
           buttons: [
             {
-              text: 'test'
+              text: 'test',
+              payload: {
+                value: 'test'
+              }
             }
           ]
         }
       })
     })
     it('should fail on unexpected button', async function () {
+      const buttons = [
+        {
+          text: 'test'
+        }
+      ]
       try {
         await this.buttonsAsserter.assertNotConvoStep({
           convoStep: { stepTag: 'test' },
           args: ['test', 'test1'],
           botMsg: {
-            buttons: [
-              {
-                text: 'test'
-              }
-            ]
+            buttons
           }
         })
         assert.fail('should have failed')
@@ -119,10 +120,40 @@ describe('scripting.asserters.buttonsAsserter', function () {
         assert.isArray(err.context.cause.expected)
         assert.isTrue(err.context.cause.not)
         assert.deepEqual(err.context.cause.expected, ['test', 'test1'])
-        assert.deepEqual(err.context.cause.actual, ['test'])
+        assert.deepEqual(err.context.cause.actual, JSON.stringify(buttons, null, 2))
         assert.deepEqual(err.context.cause.diff, ['test'])
       }
     })
+    it('should fail on unexpected button payload', async function () {
+      const payload = {
+        value: 'test'
+      }
+      const buttons = [
+        {
+          text: 'test',
+          payload
+        }
+      ]
+      try {
+        await this.buttonsAsserter.assertNotConvoStep({
+          convoStep: { stepTag: 'test' },
+          args: [JSON.stringify(payload)],
+          botMsg: {
+            buttons
+          }
+        })
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf(`Not expected button(s) with text "${JSON.stringify(payload)}"`) > 0)
+        assert.isNotNull(err.context)
+        assert.isNotNull(err.context.cause)
+        assert.isArray(err.context.cause.expected)
+        assert.isTrue(err.context.cause.not)
+        assert.deepEqual(err.context.cause.expected, [JSON.stringify(payload)])
+        assert.deepEqual(err.context.cause.actual, JSON.stringify(buttons, null, 2))
+        assert.deepEqual(err.context.cause.diff, [JSON.stringify(payload)])
+      }
+    })
     it('should succeed on existing button if has no arg', async function () {
       await this.buttonsAsserter.assertConvoStep({
         convoStep: { stepTag: 'test' },
@@ -147,23 +178,24 @@ describe('scripting.asserters.buttonsAsserter', function () {
         assert.isArray(err.context.cause.expected)
         assert.isNotTrue(err.context.cause.not)
         assert.deepEqual(err.context.cause.expected, [])
-        assert.deepEqual(err.context.cause.actual, [])
+        assert.deepEqual(err.context.cause.actual, '[]')
       }
     })
     it('should succeed on not existing button if has no arg and negated', async function () {
       await this.buttonsAsserter.assertNotConvoStep({ convoStep: { stepTag: 'test' } })
     })
     it('should fail on button if has no arg and negated', async function () {
+      const buttons = [
+        {
+          text: 'test'
+        }
+      ]
       try {
         await this.buttonsAsserter.assertNotConvoStep({
           convoStep: { stepTag: 'test' },
           args: [],
           botMsg: {
-            buttons: [
-              {
-                text: 'test'
-              }
-            ]
+            buttons
           }
         })
         assert.fail('should have failed')
@@ -174,7 +206,7 @@ describe('scripting.asserters.buttonsAsserter', function () {
         assert.isArray(err.context.cause.expected)
         assert.isTrue(err.context.cause.not)
         assert.deepEqual(err.context.cause.expected, [])
-        assert.deepEqual(err.context.cause.actual, ['test'])
+        assert.deepEqual(err.context.cause.actual, JSON.stringify(buttons, null, 2))
       }
     })
   })
@@ -302,16 +334,17 @@ describe('scripting.asserters.buttonsAsserter', function () {
     })
 
     it('should fail with normalized text', async function () {
+      const buttons = [
+        {
+          text: '<html><h1>test html header</h1><p>test html text</p>'
+        }
+      ]
       try {
         await this.cardsAsserter.assertConvoStep({
           convoStep: { stepTag: 'test' },
           args: ['Test Html header1      test html text'],
           botMsg: {
-            buttons: [
-              {
-                text: '<html><h1>test html header</h1><p>test html text</p>'
-              }
-            ]
+            buttons
           }
         })
         assert.fail('should have failed')
@@ -321,7 +354,8 @@ describe('scripting.asserters.buttonsAsserter', function () {
         assert.isNotNull(err.context.cause)
         assert.isArray(err.context.cause.expected)
         assert.deepEqual(err.context.cause.expected, ['Test Html header1      test html text'])
-        assert.deepEqual(err.context.cause.actual, ['test html header test html text'])
+        buttons[0].text = 'test html header test html text'
+        assert.deepEqual(err.context.cause.actual, JSON.stringify(buttons, null, 2))
         assert.deepEqual(err.context.cause.diff, ['Test Html header1      test html text'])
       }
     })

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

@@ -0,0 +1,11 @@
+custom embedded
+
+#me
+hello
+
+#bot
+hello fail
+MY-LOGICHOOK-SKIP
+
+#bot
+hello

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

@@ -0,0 +1,11 @@
+custom embedded
+
+#me
+hello
+
+#bot
+hello fail
+MY-LOGICHOOK-SKIP
+
+#me
+hello

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

@@ -0,0 +1,8 @@
+custom embedded
+
+#me
+hello
+
+#bot
+hello fail
+MY-LOGICHOOK-SKIP

package/test/scripting/logichooks/customEmbeddedSkip.json

@@ -0,0 +1,14 @@
+{
+  "LOGIC_HOOKS": [
+    {
+      "ref": "MY-LOGICHOOK-SKIP",
+      "src": {
+        "onBotPrepare": "convoStep.skip = true"
+      },
+      "global": false,
+      "args": {
+        "my-arg-1": "something"
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,58 @@
+const path = require('path')
+const assert = require('chai').assert
+const BotDriver = require('../../..').BotDriver
+const Capabilities = require('../../..').Capabilities
+const myCaps = require('./customEmbeddedSkip')
+
+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.customassertersskip',
+    [Capabilities.CONTAINERMODE]: echoConnector()
+  }, mergeCaps)
+
+  const result = {}
+  result.driver = new BotDriver(myCaps)
+  result.compiler = result.driver.BuildCompiler()
+  result.container = await result.driver.Build()
+  return result
+}
+
+describe('convo.customasserters skip', function () {
+  beforeEach(async function () {
+    const { compiler, container } = await buildDriver(myCaps)
+    this.compiler = compiler
+    this.container = container
+    await this.container.Start()
+  })
+  afterEach(async function () {
+    await this.container.Stop()
+    await this.container.Clean()
+  })
+
+  it('should success followed by another bot message', async function () {
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'custom_embedded_skip.convo.txt')
+    const transript = await this.compiler.convos[0].Run(this.container)
+    assert.equal(transript.steps.length, 2)
+  })
+
+  it('should success followed by me message', async function () {
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'custom_embedded_skip_followed_by_me.convo.txt')
+    const transript = await this.compiler.convos[0].Run(this.container)
+    assert.equal(transript.steps.length, 2)
+  })
+
+  it('should success followed by nothing', async function () {
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'custom_embedded_skip_followed_by_nothing.convo.txt')
+    const transript = await this.compiler.convos[0].Run(this.container)
+    assert.equal(transript.steps.length, 1)
+  })
+})

package/test/security/allowUnsafe.spec.js

@@ -10,13 +10,28 @@ const HookUtils = require('../../src/helpers/HookUtils')
 
 const myCapsSimpleRest = {
   [Capabilities.CONTAINERMODE]: 'simplerest',
-  [Capabilities.SIMPLEREST_URL]: 'http://my-host.com/api/endpoint',
+  [Capabilities.SIMPLEREST_URL]: 'http://my-non-existing-botium-host.com/api/endpoint',
   [Capabilities.SIMPLEREST_METHOD]: 'POST',
   [Capabilities.SECURITY_ALLOW_UNSAFE]: false,
   [Capabilities.SCRIPTING_ENABLE_MEMORY]: true,
   [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: ['$']
 }
 
+const echoConnector = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: `You said: "${msg.messageText}"` }
+      queueBotSays(botMsg)
+    }
+  }
+}
+
+const myCapsEcho = {
+  [Capabilities.CONTAINERMODE]: echoConnector,
+  [Capabilities.SECURITY_ALLOW_UNSAFE]: false,
+  [Capabilities.SCRIPTING_ENABLE_MEMORY]: true
+}
+
 const _getSimpleRestCaps = (caps) => {
   return Object.assign(
     {},
@@ -83,20 +98,15 @@ describe('security.allowUnsafe', function () {
 
   describe('scripting memory', function () {
     it('should not throw security error for using inline function', async function () {
-      const driver = new BotDriver(myCapsSimpleRest)
+      const driver = new BotDriver(myCapsEcho)
       const compiler = driver.BuildCompiler()
       const container = await driver.Build()
       await container.Start()
 
-      try {
-        compiler.ReadScript(path.resolve(__dirname, 'convos'), 'withscriptingmemoryfunction.convo.txt')
-        await compiler.convos[0].Run(container)
-        assert.fail('should have failed')
-      } catch (err) {
-        assert.isFalse(err.message.indexOf('Security Error. Using unsafe scripting memory function $func is not allowed') >= 0)
-      }
+      compiler.ReadScript(path.resolve(__dirname, 'convos'), 'withscriptingmemoryfunction.convo.txt')
+      await compiler.convos[0].Run(container)
       await container.Clean()
-    })
+    }).timeout(50000)
   })
 
   describe('simple rest, scripting memory', function () {

package/test/security/convos/withscriptingmemoryfunction.convo.txt

@@ -2,3 +2,4 @@
 result: $func(1+1)
 
 #bot
+you said: "result: 2"