botium-core 1.13.17 → 1.13.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botium-core",
-  "version": "1.13.17",
+  "version": "1.13.18",
   "description": "The Selenium for Chatbots",
   "main": "index.js",
   "module": "dist/botium-es.js",

package/src/BotDriver.js

@@ -3,7 +3,7 @@ const fs = require('fs')
 const path = require('path')
 const async = require('async')
 const { rimraf } = require('rimraf')
-const { mkdirpSync } = require('mkdirp')
+const mkdirp = require('mkdirp')
 const sanitize = require('sanitize-filename')
 const moment = require('moment')
 const randomize = require('randomatic')
@@ -130,7 +130,7 @@ module.exports = class BotDriver {
         (tempDirectoryCreated) => {
           tempDirectory = path.resolve(process.cwd(), this.caps[Capabilities.TEMPDIR], sanitize(`${this.caps[Capabilities.PROJECTNAME]} ${moment().format('YYYYMMDD HHmmss')} ${randomize('Aa0', 5)}`))
           try {
-            mkdirpSync(tempDirectory)
+            mkdirp.sync(tempDirectory)
             tempDirectoryCreated()
           } catch (err) {
             tempDirectoryCreated(new Error(`Unable to create temp directory ${tempDirectory}: ${err.message}`))

package/src/Capabilities.js

@@ -68,6 +68,12 @@ module.exports = {
   SIMPLEREST_POLL_INTERVAL: 'SIMPLEREST_POLL_INTERVAL',
   SIMPLEREST_POLL_TIMEOUT: 'SIMPLEREST_PING_TIMEOUT',
   SIMPLEREST_POLL_UPDATE_CONTEXT: 'SIMPLEREST_POLL_UPDATE_CONTEXT',
+  SIMPLEREST_CONTEXT_IGNORE_JSONPATH: 'SIMPLEREST_CONTEXT_IGNORE_JSONPATH',
+  SIMPLEREST_CONTEXT_IGNORE_MATCH: 'SIMPLEREST_CONTEXT_IGNORE_MATCH',
+  SIMPLEREST_CONTEXT_SKIP_JSONPATH: 'SIMPLEREST_CONTEXT_SKIP_JSONPATH',
+  SIMPLEREST_CONTEXT_SKIP_MATCH: 'SIMPLEREST_CONTEXT_SKIP_MATCH',
+  SIMPLEREST_CONTEXT_CONTINUE_JSONPATH: 'SIMPLEREST_CONTEXT_CONTINUE_JSONPATH',
+  SIMPLEREST_CONTEXT_CONTINUE_MATCH: 'SIMPLEREST_CONTEXT_CONTINUE_MATCH',
   SIMPLEREST_BODY_JSONPATH: 'SIMPLEREST_BODY_JSONPATH',
   SIMPLEREST_RESPONSE_JSONPATH: 'SIMPLEREST_RESPONSE_JSONPATH',
   SIMPLEREST_RESPONSE_HOOK: 'SIMPLEREST_RESPONSE_HOOK',

package/src/containers/BaseContainer.js

@@ -1,6 +1,6 @@
 const util = require('util')
 const async = require('async')
-const { rimraf } = require('rimraf')
+const rimraf = require('rimraf')
 const Bottleneck = require('bottleneck')
 const _ = require('lodash')
 const request = require('request')
@@ -173,9 +173,12 @@ module.exports = class BaseContainer {
         (rimraffed) => {
           if (this.caps[Capabilities.CLEANUPTEMPDIR]) {
             debug(`Cleanup rimrafing temp dir ${this.tempDirectory}`)
-            rimraf(this.tempDirectory)
-              .catch((err) => debug(`Cleanup temp dir ${this.tempDirectory} failed: ${util.inspect(err)}`))
-              .finally(() => rimraffed())
+            try {
+              rimraf.sync(this.tempDirectory)
+              rimraffed()
+            } catch (err) {
+              rimraffed(new Error(`Cleanup temp directory ${this.tempDirectory} failed: ${util.inspect(err)}`))
+            }
           } else {
             rimraffed()
           }

package/src/containers/plugins/SimpleRestContainer.js

@@ -293,6 +293,47 @@ module.exports = class SimpleRestContainer {
       debug(`current session context: ${util.inspect(this.view.context)}`)
     }
 
+    const _isAnyContextJsonPathMatch = (capName, capNameMatch) => {
+      const jsonPaths = getAllCapValues(capName, this.caps)
+      if (jsonPaths.length > 0) {
+        const jsonPathsMatch = getAllCapValues(capNameMatch, this.caps)
+        for (const [index, jsonPath] of jsonPaths.entries()) {
+          const contextNodes = jp.query(this.view.context, jsonPath)
+          if (_.isArray(contextNodes) && contextNodes.length > 0) {
+            if (jsonPathsMatch[index]) {
+              if (contextNodes[0] === jsonPathsMatch[index]) {
+                return {
+                  jsonPath,
+                  match: contextNodes[0]
+                }
+              }
+            } else {
+              return {
+                jsonPath
+              }
+            }
+          }
+        }
+      }
+      return null
+    }
+
+    const ignoreMatch = _isAnyContextJsonPathMatch(Capabilities.SIMPLEREST_CONTEXT_IGNORE_JSONPATH, Capabilities.SIMPLEREST_CONTEXT_IGNORE_MATCH)
+    if (ignoreMatch) {
+      if (ignoreMatch.match) debug(`ignoring response for context match: ${ignoreMatch.jsonPath} = ${ignoreMatch.match}`)
+      else debug(`ignoring response for context: ${ignoreMatch.jsonPath}`)
+      return
+    }
+
+    const skipMatch = _isAnyContextJsonPathMatch(Capabilities.SIMPLEREST_CONTEXT_SKIP_JSONPATH, Capabilities.SIMPLEREST_CONTEXT_SKIP_MATCH)
+    if (skipMatch) {
+      if (skipMatch.match) debug(`skipping response for context match: ${skipMatch.jsonPath} = ${skipMatch.match}`)
+      else debug(`skipping response for context: ${skipMatch.jsonPath}`)
+
+      setTimeout(() => this._doRequest({ messageText: '' }, true, true), 0)
+      return
+    }
+
     const result = []
     if (isFromUser) {
       const _extractFrom = (root, jsonPaths) => {
@@ -442,6 +483,14 @@ module.exports = class SimpleRestContainer {
         }
       }
     }
+
+    const continueMatch = _isAnyContextJsonPathMatch(Capabilities.SIMPLEREST_CONTEXT_CONTINUE_JSONPATH, Capabilities.SIMPLEREST_CONTEXT_CONTINUE_MATCH)
+    if (continueMatch) {
+      if (continueMatch.match) debug(`continue with next response for context match: ${continueMatch.jsonPath} = ${continueMatch.match}`)
+      else debug(`continue with next response for context: ${continueMatch.jsonPath}`)
+
+      setTimeout(() => this._doRequest({ messageText: '' }, true, true), 0)
+    }
     return result
   }
 

package/src/scripting/Convo.js

@@ -404,6 +404,15 @@ class Convo {
               throw failErr
             }
 
+            if (convoStep.skip === true) {
+              skipTranscriptStep = true
+              const nextConvoStep = this.conversation[i + 1]
+              if (nextConvoStep && nextConvoStep.sender === 'bot') {
+                waitForBotSays = false
+              }
+              continue
+            }
+
             if (!botMsg || (!botMsg.messageText && !botMsg.media && !botMsg.buttons && !botMsg.cards && !botMsg.sourceData && !botMsg.nlp)) {
               const failErr = new BotiumError(`${this.header.name}/${convoStep.stepTag}: bot says nothing`)
               debug(failErr)

package/src/scripting/ScriptingProvider.js

@@ -940,10 +940,16 @@ module.exports = class ScriptingProvider {
       convoFilter: null
     }, options)
     const expandedConvos = []
+    // The globalContext is going to keep the data even if the Object.assign which happening to create the myContext in _expandConvo function
+    const context = {
+      globalContext: {
+        totalConvoCount: 0
+      }
+    }
     debug(`ExpandConvos - Using utterances expansion mode: ${this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE]}`)
     this.convos.forEach((convo) => {
       convo.expandPartialConvos()
-      for (const expanded of this._expandConvo(convo, options, {})) {
+      for (const expanded of this._expandConvo(convo, options, context)) {
         expanded.header.assertionCount = this.GetAssertionCount(expanded)
         if (options.justHeader) {
           const ConvoWithOnlyHeader = {
@@ -959,6 +965,7 @@ module.exports = class ScriptingProvider {
       }
     })
     this.convos = expandedConvos
+    this.totalConvoCount = context.globalContext.totalConvoCount
     if (!options.justHeader) {
       this._sortConvos()
     } else {
@@ -971,17 +978,24 @@ module.exports = class ScriptingProvider {
       // drop unwanted convos
       convoFilter: null
     }, options)
+    // The globalContext is going to keep the data even if the Object.assign which happening to create the myContext in _expandConvo function
+    const context = {
+      globalContext: {
+        totalConvoCount: 0
+      }
+    }
     debug(`ExpandConvos - Using utterances expansion mode: ${this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE]}`)
     // creating a nested generator, calling the other.
     // We hope this.convos does not changes while this iterator is used
     const _convosIterable = function * (options) {
       for (const convo of this.convos) {
         convo.expandPartialConvos()
-        yield * this._expandConvo(convo, options, {})
+        yield * this._expandConvo(convo, options, context)
       }
     }.bind(this)
 
     this.convosIterable = _convosIterable(options)
+    this.totalConvoCount = context.globalContext.totalConvoCount
   }
 
   /**
@@ -1173,6 +1187,9 @@ module.exports = class ScriptingProvider {
       }
     } else {
       const expanded = Object.assign(_.cloneDeep(currentConvo), { conversation: _.cloneDeep(convoStepsStack) })
+      if (!_.isNil(_.get(context, 'globalContext.totalConvoCount'))) {
+        context.globalContext.totalConvoCount++
+      }
       if (!options.convoFilter || options.convoFilter(expanded)) {
         yield expanded
       }

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

@@ -1,3 +1,4 @@
+const _ = require('lodash')
 const { SCRIPTING_NORMALIZE_TEXT } = require('../../../Capabilities')
 const { BotiumError } = require('../../BotiumError')
 const { buttonsFromMsg } = require('../helpers')
@@ -11,17 +12,29 @@ module.exports = class ButtonsAsserter {
   }
 
   _evalButtons (args, botMsg) {
-    const allButtons = buttonsFromMsg(botMsg, true).map(b => b.text).filter(b => b).map(b => normalizeText(b, !!this.caps[SCRIPTING_NORMALIZE_TEXT]))
+    const allButtons = buttonsFromMsg(botMsg, true).map(b => ({ text: b.text, payload: b.payload })).filter(b => b).map(b => ({ text: normalizeText(b.text, !!this.caps[SCRIPTING_NORMALIZE_TEXT]), payload: b.payload }))
     if (!args || args.length === 0) {
-      return { allButtons, buttonsNotFound: [], buttonsFound: allButtons }
+      return { allButtons, buttonsNotFound: [], buttonsFound: allButtons.map(b => b.text) }
     }
     const buttonsNotFound = []
     const buttonsFound = []
+    const parsePayload = (payload) => {
+      if (_.isNil(payload)) {
+        return undefined
+      }
+      try {
+        return JSON.parse(payload)
+      } catch (e) {
+        return payload
+      }
+    }
     for (let i = 0; i < (args || []).length; i++) {
-      if (allButtons.findIndex(b => this.context.Match(b, normalizeText(args[i], !!this.caps[SCRIPTING_NORMALIZE_TEXT]))) < 0) {
-        buttonsNotFound.push(args[i])
-      } else {
+      const matchByText = allButtons.some(b => this.context.Match(b.text, normalizeText(args[i], !!this.caps[SCRIPTING_NORMALIZE_TEXT])))
+      const matchByPayload = allButtons.some(b => _.isEqual(parsePayload(b.payload), parsePayload(args[i])))
+      if (matchByText || matchByPayload) {
         buttonsFound.push(args[i])
+      } else {
+        buttonsNotFound.push(args[i])
       }
     }
     return { allButtons, buttonsNotFound, buttonsFound }
@@ -42,7 +55,7 @@ module.exports = class ButtonsAsserter {
           cause: {
             not: true,
             expected: args,
-            actual: allButtons,
+            actual: JSON.stringify(allButtons, null, 2),
             diff: buttonsFound
           }
         }
@@ -67,7 +80,7 @@ module.exports = class ButtonsAsserter {
             cause: {
               not: false,
               expected: args,
-              actual: allButtons,
+              actual: JSON.stringify(allButtons, null, 2),
               diff: buttonsNotFound
             }
           }
@@ -85,7 +98,7 @@ module.exports = class ButtonsAsserter {
             cause: {
               not: false,
               expected: args,
-              actual: allButtons,
+              actual: JSON.stringify(allButtons, null, 2),
               diff: buttonsNotFound
             }
           }

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