botium-core 1.13.17 → 1.13.19

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/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

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

@@ -0,0 +1,12 @@
+conditional_steps_time_based
+
+#me
+hello
+
+#bot
+hello
+CONDITIONAL_STEP_JSON_PATH_BASED { "jsonPath":"$.messageText", "value": "hello" }
+
+#bot
+fail
+CONDITIONAL_STEP_JSON_PATH_BASED { "jsonPath":"$.messageText", "value": "fail" }

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

@@ -0,0 +1,20 @@
+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
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":false }|G2
+
+#bot
+hello should not assert
+CONDITIONAL_STEP_LOGIC_HOOK { "skip":true }|G2