botium-core 1.13.18 → 1.13.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botium-core",
-  "version": "1.13.18",
+  "version": "1.13.19",
   "description": "The Selenium for Chatbots",
   "main": "index.js",
   "module": "dist/botium-es.js",
@@ -51,6 +51,7 @@
     "mime-types": "^2.1.35",
     "mkdirp": "^3.0.1",
     "moment": "^2.29.4",
+    "moment-timezone": "^0.5.43",
     "mustache": "^4.2.0",
     "promise-retry": "^2.0.1",
     "promise.allsettled": "^1.0.6",

package/src/scripting/Convo.js

@@ -356,6 +356,7 @@ class Convo {
               throw failErr
             }
           } else if (convoStep.sender === 'bot') {
+            const previousWaitForBotSays = waitForBotSays
             if (waitForBotSays) {
               botMsg = null
             } else {
@@ -404,13 +405,24 @@ class Convo {
               throw failErr
             }
 
-            if (convoStep.skip === true) {
-              skipTranscriptStep = true
+            if (convoStep.conditional) {
               const nextConvoStep = this.conversation[i + 1]
-              if (nextConvoStep && nextConvoStep.sender === 'bot') {
-                waitForBotSays = false
+
+              if (!previousWaitForBotSays) {
+                skipTranscriptStep = true
+              }
+              waitForBotSays = false
+              if (!nextConvoStep || nextConvoStep.sender !== 'bot' || !nextConvoStep.logicHooks || !nextConvoStep.logicHooks.some(lh => lh.name.toUpperCase().startsWith('CONDITIONAL_STEP'))) {
+                waitForBotSays = true
+              } else {
+                const conditionalLogicHook = convoStep.logicHooks.find(lh => lh.name.startsWith('CONDITIONAL_STEP'))
+                const nextConditionalLogicHook = nextConvoStep.logicHooks.find(lh => lh.name.startsWith('CONDITIONAL_STEP'))
+                waitForBotSays = conditionalLogicHook.args[1] !== nextConditionalLogicHook.args[1]
+              }
+
+              if (convoStep.conditional.skip) {
+                continue
               }
-              continue
             }
 
             if (!botMsg || (!botMsg.messageText && !botMsg.media && !botMsg.buttons && !botMsg.cards && !botMsg.sourceData && !botMsg.nlp)) {

package/src/scripting/logichook/LogicHookConsts.js

@@ -57,7 +57,11 @@ module.exports = {
     { name: 'ASSIGN_SCRIPTING_MEMORY', className: 'AssignScriptingMemoryLogicHook' },
     { name: 'UPDATE_CUSTOM', className: 'UpdateCustomLogicHook' },
     { name: 'SKIP_BOT_UNCONSUMED', className: 'ClearQueueLogicHook' },
-    { name: LOGIC_HOOK_INCLUDE, className: 'IncludeLogicHook' }
+    { name: LOGIC_HOOK_INCLUDE, className: 'IncludeLogicHook' },
+    { name: 'CONDITIONAL_STEP_TIME_BASED', className: 'ConditionalTimeBasedLogicHook' },
+    { name: 'CONDITIONAL_STEP_BUSINESS_HOURS', className: 'ConditionalBusinessHoursLogicHook' },
+    { name: 'CONDITIONAL_STEP_CAPABILITY_VALUE_BASED', className: 'ConditionalCapabilityValueBasedLogicHook' },
+    { name: 'CONDITIONAL_STEP_JSON_PATH_BASED', className: 'ConditionalJsonPathBasedLogicHook.js' }
   ],
   DEFAULT_USER_INPUTS: [
     { name: 'BUTTON', className: 'ButtonInput' },

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

@@ -18,19 +18,19 @@ module.exports = class ButtonsAsserter {
     }
     const buttonsNotFound = []
     const buttonsFound = []
-    const parsePayload = (payload) => {
+    const stringifyPayload = (payload) => {
       if (_.isNil(payload)) {
-        return undefined
+        return ''
       }
       try {
-        return JSON.parse(payload)
+        return JSON.stringify(JSON.parse(payload))
       } catch (e) {
-        return payload
+        return JSON.stringify(payload)
       }
     }
     for (let i = 0; i < (args || []).length; i++) {
       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])))
+      const matchByPayload = allButtons.some(b => this.context.Match(stringifyPayload(b.payload), normalizeText(args[i], !!this.caps[SCRIPTING_NORMALIZE_TEXT])))
       if (matchByText || matchByPayload) {
         buttonsFound.push(args[i])
       } else {

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

@@ -0,0 +1,56 @@
+const util = require('util')
+const moment = require('moment-timezone')
+const debug = require('debug')('botium-core-ConditionalTimeBasedLogicHook')
+
+module.exports = class ConditionalBusinessHoursLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  _isBetween ({ now, start, end, days, timeZone }) {
+    if ((!start || !end) && (!days || days.length === 0)) {
+      throw new Error('ConditionalBusinessHoursLogicHook: Either start and end time or days array needs to be specified in params')
+    }
+    now.tz(timeZone)
+    if (days && days.length > 0 && !days.includes(now.format('dddd'))) {
+      return false
+    }
+
+    if (!start && !end && days && days.length > 0 && days.includes(now.format('dddd'))) {
+      return true
+    }
+
+    const momentStartTime = moment(start, 'HH:mm')
+    const startTime = now.clone().set({ hour: momentStartTime.hour(), minute: momentStartTime.minute() })
+    startTime.tz(timeZone)
+    const momentEndTime = moment(end, 'HH:mm')
+    const endTime = now.clone().set({ hour: momentEndTime.hour(), minute: momentEndTime.minute() })
+    endTime.tz(timeZone)
+    if (startTime.isSameOrAfter(endTime)) {
+      if (now.isSameOrAfter(startTime)) {
+        endTime.add(1, 'days')
+      } else {
+        startTime.add(-1, 'days')
+      }
+    }
+    return now.isBetween(startTime, endTime, 'minutes', '[]')
+  }
+
+  onBotPrepare ({ convo, convoStep, args }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalBusinessHoursLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    params.now = moment()
+    convoStep.conditional.skip = !this._isBetween(params)
+    debug(`ConditionalBusinessHoursLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+  }
+}

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

@@ -0,0 +1,37 @@
+const util = require('util')
+const jp = require('jsonpath')
+const _ = require('lodash')
+const debug = require('debug')('botium-core-ConditionalCapabilityValueBasedLogicHook')
+
+module.exports = class ConditionalCapabilityValueBasedLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  _isCapabilityValueEqual ({ capabilityName, jsonPath, value }) {
+    if (jsonPath) {
+      const capabilityObject = _.isObject(this.caps[capabilityName]) ? this.caps[capabilityName] : JSON.parse(this.caps[capabilityName])
+      const values = jp.query(capabilityObject, jsonPath)
+      return !!(values && values.length > 0 && values.includes(value))
+    } else {
+      return this.caps[capabilityName] === value
+    }
+  }
+
+  onBotPrepare ({ convo, convoStep, args }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalCapabilityValueBasedLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    convoStep.conditional.skip = !this._isCapabilityValueEqual(params)
+    debug(`ConditionalCapabilityValueBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+  }
+}

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

@@ -0,0 +1,31 @@
+const util = require('util')
+const jp = require('jsonpath')
+const debug = require('debug')('botium-core-ConditionalJsonPathBasedLogicHook')
+
+module.exports = class ConditionalJsonPathBasedLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  onBotPrepare ({ convo, convoStep, args, botMsg }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalJsonPathBasedLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    let skip = true
+    if (params.jsonPath) {
+      const values = jp.query(botMsg, params.jsonPath)
+      skip = !(values && values.length > 0 && values.includes(params.value))
+    }
+    convoStep.conditional.skip = skip
+    debug(`ConditionalJsonPathBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+  }
+}

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

@@ -0,0 +1,46 @@
+const util = require('util')
+const moment = require('moment-timezone')
+const debug = require('debug')('botium-core-ConditionalTimeBasedLogicHook')
+
+module.exports = class ConditionalTimeBasedLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  _isBetween ({ now, start, end, timeZone }) {
+    now.tz(timeZone)
+    const momentStartTime = moment(start, 'HH:mm')
+    const startTime = now.clone().set({ hour: momentStartTime.hour(), minute: momentStartTime.minute() })
+    startTime.tz(timeZone)
+    const momentEndTime = moment(end, 'HH:mm')
+    const endTime = now.clone().set({ hour: momentEndTime.hour(), minute: momentEndTime.minute() })
+    endTime.tz(timeZone)
+
+    if (startTime.isSameOrAfter(endTime)) {
+      if (now.isSameOrAfter(startTime)) {
+        endTime.add(1, 'days')
+      } else {
+        startTime.add(-1, 'days')
+      }
+    }
+    return now.isBetween(startTime, endTime, 'minutes', '[]')
+  }
+
+  onBotPrepare ({ convo, convoStep, args }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalTimeBasedLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    params.now = moment()
+    convoStep.conditional.skip = !this._isBetween(params)
+    debug(`ConditionalTimeBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+  }
+}

package/test/scripting/logichooks/CustomConditionalLogicHook.js

@@ -0,0 +1,21 @@
+module.exports = class ConditionalLogicHook {
+  constructor (context, caps, globalArgs) {
+    this.context = context
+    this.caps = caps
+    this.globalArgs = globalArgs
+  }
+
+  onBotPrepare ({ convo, convoStep, args }) {
+    const conditionGroupId = args[1]
+    let params
+    try {
+      params = JSON.parse(args[0])
+    } catch (e) {
+      throw new Error(`ConditionalCapabilityValueLogicHook: No parsable JSON object found in params: ${e}`)
+    }
+    convoStep.conditional = {
+      conditionGroupId
+    }
+    convoStep.conditional.skip = params.skip
+  }
+}

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

@@ -0,0 +1,130 @@
+const path = require('path')
+const moment = require('moment/moment')
+const assert = require('chai').assert
+const BotDriver = require('../../../index').BotDriver
+const Capabilities = require('../../../index').Capabilities
+const ConditionalBusinessHoursLogicHook = require('../../../src/scripting/logichook/logichooks/ConditionalBusinessHoursLogicHook')
+
+const echoConnector = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const now = moment()
+      const start = moment('8:00', [moment.ISO_8601, 'HH:mm'])
+      const end = moment('16:30', [moment.ISO_8601, 'HH:mm'])
+      if (start.isSameOrAfter(end)) {
+        if (now.isSameOrAfter(start)) {
+          end.add(1, 'days')
+        } else {
+          start.add(-1, 'days')
+        }
+      }
+      const businessHoursText = ['Saturday', 'Sunday'].includes(now.format('dddd'))
+        ? 'it\'s non-business hours'
+        : now.isBetween(start, end, 'minutes', '[]')
+          ? 'it\'s business hours'
+          : 'it\'s non-business hours'
+      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: `Hello, ${businessHoursText}` }
+      queueBotSays(botMsg)
+    }
+  }
+}
+
+describe('convo with business hours conditional logichook', function () {
+  beforeEach(async function () {
+    const myCaps = {
+      [Capabilities.PROJECTNAME]: 'scripting.logichooks',
+      [Capabilities.CONTAINERMODE]: echoConnector,
+      [Capabilities.SCRIPTING_ENABLE_MEMORY]: true
+    }
+    const driver = new BotDriver(myCaps)
+    this.compiler = driver.BuildCompiler()
+    this.container = await driver.Build()
+  })
+
+  afterEach(async function () {
+    this.container && await this.container.Clean()
+  })
+
+  it('should success', async function () {
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'conditional_steps_business_hours.convo.txt')
+    await this.compiler.convos[0].Run(this.container)
+  })
+
+  it('is between Monday-Friday 8:00-16:00', async function () {
+    const clh = new ConditionalBusinessHoursLogicHook()
+    const params = {
+      days: ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'],
+      start: '8:00',
+      end: '16:00'
+    }
+    // Monday 10:00
+    params.now = moment('2023-08-21T10:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 08:00
+    params.now = moment('2023-08-21T08:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 16:00
+    params.now = moment('2023-08-21T16:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 16:01
+    params.now = moment('2023-08-21T16:01:00')
+    assert.isFalse(clh._isBetween(params))
+    // Sunday 10:00
+    params.now = moment('2023-08-20T10:00:00')
+    assert.isFalse(clh._isBetween(params))
+    // Friday 16:01
+    params.now = moment('2023-08-25T16:01:00')
+    assert.isFalse(clh._isBetween(params))
+  })
+
+  it('is between Monday-Friday 16:01-7:59', async function () {
+    const clh = new ConditionalBusinessHoursLogicHook()
+    const params = {
+      days: ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'],
+      start: '16:01',
+      end: '7:59'
+    }
+
+    // Monday 17:00
+    params.now = moment('2023-08-21T17:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 05:00
+    params.now = moment('2023-08-21T05:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 16:01
+    params.now = moment('2023-08-21T16:01:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 07:59
+    params.now = moment('2023-08-21T07:59:00')
+    assert.isTrue(clh._isBetween(params))
+    // Friday 23:00
+    params.now = moment('2023-08-25T23:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 16:00
+    params.now = moment('2023-08-21T16:00:00')
+    assert.isFalse(clh._isBetween(params))
+    // Sunday 23:00
+    params.now = moment('2023-08-20T23:00:00')
+    assert.isFalse(clh._isBetween(params))
+  })
+
+  it('is on Saturday or Sunday', async function () {
+    const clh = new ConditionalBusinessHoursLogicHook()
+    const params = {
+      days: ['Saturday', 'Sunday']
+    }
+
+    // Sunday 17:00
+    params.now = moment('2023-08-20T17:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Saturday 05:00
+    params.now = moment('2023-08-19T05:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 16:01
+    params.now = moment('2023-08-21T16:01:00')
+    assert.isFalse(clh._isBetween(params))
+    // Friday 23:00
+    params.now = moment('2023-08-25T23:00:00')
+    assert.isFalse(clh._isBetween(params))
+  })
+})

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

@@ -0,0 +1,35 @@
+const path = require('path')
+const BotDriver = require('../../../index').BotDriver
+const Capabilities = require('../../../index').Capabilities
+
+const echoConnector = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: msg.messageText }
+      queueBotSays(botMsg)
+    }
+  }
+}
+
+describe('convo with capablility value based conditional logichook', function () {
+  beforeEach(async function () {
+    const myCaps = {
+      [Capabilities.PROJECTNAME]: 'scripting.logichooks',
+      [Capabilities.CONTAINERMODE]: echoConnector,
+      [Capabilities.SCRIPTING_ENABLE_MEMORY]: true,
+      SIMPLE_TEXT: 'echo1'
+    }
+    const driver = new BotDriver(myCaps)
+    this.compiler = driver.BuildCompiler()
+    this.container = await driver.Build()
+  })
+
+  afterEach(async function () {
+    this.container && await this.container.Clean()
+  })
+
+  it('should success', async function () {
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'conditional_steps_cap_value_based.convo.txt')
+    await this.compiler.convos[0].Run(this.container)
+  })
+})

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

@@ -0,0 +1,35 @@
+const path = require('path')
+const BotDriver = require('../../../index').BotDriver
+const Capabilities = require('../../../index').Capabilities
+
+const echoConnector = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: msg.messageText }
+      queueBotSays(botMsg)
+    }
+  }
+}
+
+describe('convo with capablility value based conditional logichook', function () {
+  beforeEach(async function () {
+    const myCaps = {
+      [Capabilities.PROJECTNAME]: 'scripting.logichooks',
+      [Capabilities.CONTAINERMODE]: echoConnector,
+      [Capabilities.SCRIPTING_ENABLE_MEMORY]: true,
+      SIMPLE_TEXT: 'echo1'
+    }
+    const driver = new BotDriver(myCaps)
+    this.compiler = driver.BuildCompiler()
+    this.container = await driver.Build()
+  })
+
+  afterEach(async function () {
+    this.container && await this.container.Clean()
+  })
+
+  it('should success', async function () {
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'conditional_steps_json_path_based.convo.txt.convo.txt')
+    await this.compiler.convos[0].Run(this.container)
+  })
+})

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

@@ -0,0 +1,91 @@
+const path = require('path')
+const moment = require('moment/moment')
+const assert = require('chai').assert
+const BotDriver = require('../../../index').BotDriver
+const Capabilities = require('../../../index').Capabilities
+const ConditionalTimeBasedLogicHook = require('../../../src/scripting/logichook/logichooks/ConditionalTimeBasedLogicHook')
+
+const echoConnector = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const now = moment()
+      const start = moment('8:00', [moment.ISO_8601, 'HH:mm'])
+      const end = moment('16:30', [moment.ISO_8601, 'HH:mm'])
+      if (start.isSameOrAfter(end)) {
+        if (now.isSameOrAfter(start)) {
+          end.add(1, 'days')
+        } else {
+          start.add(-1, 'days')
+        }
+      }
+      const businessHoursText = now.isBetween(start, end, 'minutes', '[]') ? 'we are open' : 'we are closed'
+      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: `Hello, ${businessHoursText}` }
+      queueBotSays(botMsg)
+    }
+  }
+}
+
+describe('convo with time based conditional logichook', function () {
+  beforeEach(async function () {
+    const myCaps = {
+      [Capabilities.PROJECTNAME]: 'scripting.logichooks',
+      [Capabilities.CONTAINERMODE]: echoConnector,
+      [Capabilities.SCRIPTING_ENABLE_MEMORY]: true
+    }
+    const driver = new BotDriver(myCaps)
+    this.compiler = driver.BuildCompiler()
+    this.container = await driver.Build()
+  })
+
+  afterEach(async function () {
+    this.container && await this.container.Clean()
+  })
+
+  it('should success', async function () {
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'conditional_steps_time_based.convo.txt')
+    await this.compiler.convos[0].Run(this.container)
+  })
+
+  it('is between 8:00-16:00', async function () {
+    const clh = new ConditionalTimeBasedLogicHook()
+    const params = {
+      start: '8:00',
+      end: '16:00'
+    }
+    // Monday 10:00
+    params.now = moment('2023-08-21T10:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 08:00
+    params.now = moment('2023-08-21T08:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 16:00
+    params.now = moment('2023-08-21T16:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 16:01
+    params.now = moment('2023-08-21T16:01:00')
+    assert.isFalse(clh._isBetween(params))
+  })
+
+  it('is between 16:01-7:59', async function () {
+    const clh = new ConditionalTimeBasedLogicHook()
+    const params = {
+      start: '16:01',
+      end: '7:59'
+    }
+    // Monday 17:00
+    params.now = moment('2023-08-21T17:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 05:00
+    params.now = moment('2023-08-21T05:00:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 16:01
+    params.now = moment('2023-08-21T16:01:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 07:59
+    params.now = moment('2023-08-21T07:59:00')
+    assert.isTrue(clh._isBetween(params))
+    // Monday 16:00
+    params.now = moment('2023-08-21T16:00:00')
+    assert.isFalse(clh._isBetween(params))
+  })
+})

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

@@ -0,0 +1,12 @@
+custom embedded
+
+#me
+hello
+
+#bot
+hello should not assert
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":true }|G1
+
+#bot
+hello
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":false }|G1

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

@@ -0,0 +1,16 @@
+conditional_steps_time_based
+
+#me
+hello
+
+#bot
+hello, it's business hours
+CONDITIONAL_STEP_BUSINESS_HOURS { "days": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"], "start":"8:00", "end": "16:30" }
+
+#bot
+hello, it's non-business hours
+CONDITIONAL_STEP_BUSINESS_HOURS { "days": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"], "start":"16:31", "end": "7:59" }
+
+#bot
+hello, it's non-business hours
+CONDITIONAL_STEP_BUSINESS_HOURS { "days": ["Saturday", "Sunday"] }

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

@@ -0,0 +1,12 @@
+conditional_steps_time_based
+
+#me
+hello
+
+#bot
+hello
+CONDITIONAL_STEP_CAPABILITY_VALUE_BASED { "capabilityName":"SIMPLE_TEXT", "value": "echo1" }
+
+#bot
+fail
+CONDITIONAL_STEP_CAPABILITY_VALUE_BASED { "capabilityName":"SIMPLE_TEXT", "value": "echo2" }

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

@@ -0,0 +1,15 @@
+custom embedded
+
+#me
+hello
+
+#bot
+hello should not assert
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":true }|G1
+
+#bot
+hello
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":false }|G1
+
+#bot
+hello Duplicate

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

@@ -0,0 +1,18 @@
+custom embedded
+
+#me
+hello
+
+#bot
+hello should not assert
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":true }|G1
+
+#bot
+hello
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":false }|G1
+
+#me
+hello
+
+#bot
+hello