botium-core 1.13.0 → 1.13.3

package/test/plugins/plugins.spec.js

@@ -2,53 +2,55 @@ const path = require('path')
 const assert = require('chai').assert
 const { BotDriver, Capabilities, Plugins } = require('../../')
 
-describe('plugins.find', function () {
-  it('should return empty list on invalid folder', async () => {
-    const plugins = await Plugins.getPlugins(Plugins.PLUGIN_TYPE_ASSERTER, 'abcd')
-    assert.isEmpty(plugins)
-  })
+describe('plugins.plugins', function () {
+  describe('find', function () {
+    it('should return empty list on invalid folder', async function () {
+      const plugins = await Plugins.getPlugins(Plugins.PLUGIN_TYPE_ASSERTER, 'abcd')
+      assert.isEmpty(plugins)
+    })
 
-  it('should load connector from folder', async () => {
-    const plugins = await Plugins.getPlugins(Plugins.PLUGIN_TYPE_CONNECTOR, path.join(__dirname, 'plugindir', 'fromfolder'))
-    assert.lengthOf(plugins, 1)
-    assert.equal(plugins[0].PluginDesc.name, 'Test Connector FromDir')
-    assert.equal(plugins[0].PluginDesc.src, 'fromdir1')
-  })
+    it('should load connector from folder', async function () {
+      const plugins = await Plugins.getPlugins(Plugins.PLUGIN_TYPE_CONNECTOR, path.join(__dirname, 'plugindir', 'fromfolder'))
+      assert.lengthOf(plugins, 1)
+      assert.equal(plugins[0].PluginDesc.name, 'Test Connector FromDir')
+      assert.equal(plugins[0].PluginDesc.src, 'fromdir1')
+    })
 
-  it('should load connector from file', async () => {
-    const plugins = await Plugins.getPlugins(Plugins.PLUGIN_TYPE_CONNECTOR, path.join(__dirname, 'plugindir', 'fromfile'))
-    assert.lengthOf(plugins, 2)
-    assert.equal(plugins[0].PluginDesc.name, 'Test Connector FromFile 1')
-    assert.equal(plugins[0].PluginDesc.src, 'fromfile1')
-    assert.equal(plugins[1].PluginDesc.name, 'Test Connector FromFile 2')
-    assert.equal(plugins[1].PluginDesc.src, 'fromfile2')
+    it('should load connector from file', async function () {
+      const plugins = await Plugins.getPlugins(Plugins.PLUGIN_TYPE_CONNECTOR, path.join(__dirname, 'plugindir', 'fromfile'))
+      assert.lengthOf(plugins, 2)
+      assert.equal(plugins[0].PluginDesc.name, 'Test Connector FromFile 1')
+      assert.equal(plugins[0].PluginDesc.src, 'fromfile1')
+      assert.equal(plugins[1].PluginDesc.name, 'Test Connector FromFile 2')
+      assert.equal(plugins[1].PluginDesc.src, 'fromfile2')
+    })
   })
-})
 
-describe('plugins.load', function () {
-  it('should map simple function to class', async () => {
-    const myCaps = {
-      [Capabilities.PROJECTNAME]: 'plugins.load',
-      [Capabilities.CONTAINERMODE]: 'fromfile1'
-    }
-    const driver = new BotDriver(myCaps)
-    const container = await driver.Build()
+  describe('load', function () {
+    it('should map simple function to class', async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'plugins.load',
+        [Capabilities.CONTAINERMODE]: 'fromfile1'
+      }
+      const driver = new BotDriver(myCaps)
+      const container = await driver.Build()
 
-    await container.UserSays({ messageText: 'TEST' })
-    const response = await container.WaitBotSays()
-    assert.equal(response.messageText, 'TEST')
-  })
-  it('should use UserSays function as class', async () => {
-    const myCaps = {
-      [Capabilities.PROJECTNAME]: 'plugins.load',
-      [Capabilities.CONTAINERMODE]: 'fromfile2',
-      cap1: 'MYPREFIX'
-    }
-    const driver = new BotDriver(myCaps)
-    const container = await driver.Build()
+      await container.UserSays({ messageText: 'TEST' })
+      const response = await container.WaitBotSays()
+      assert.equal(response.messageText, 'TEST')
+    })
+    it('should use UserSays function as class', async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'plugins.load',
+        [Capabilities.CONTAINERMODE]: 'fromfile2',
+        cap1: 'MYPREFIX'
+      }
+      const driver = new BotDriver(myCaps)
+      const container = await driver.Build()
 
-    await container.UserSays({ messageText: 'TEST' })
-    const response = await container.WaitBotSays()
-    assert.equal(response.messageText, 'MYPREFIX:TEST')
+      await container.UserSays({ messageText: 'TEST' })
+      const response = await container.WaitBotSays()
+      assert.equal(response.messageText, 'MYPREFIX:TEST')
+    })
   })
 })

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

@@ -4,104 +4,91 @@ const ButtonsCountAsserter = require('../../../src/scripting/logichook/asserter/
 const ButtonsCountRecAsserter = require('../../../src/scripting/logichook/asserter/ButtonsCountRecAsserter')
 
 describe('scripting.asserters.buttonsAsserter', function () {
-  beforeEach(async function () {
-    this.buttonsAsserter = new ButtonsAsserter({
-      Match: (botresponse, utterance) => botresponse.toLowerCase().indexOf(utterance.toLowerCase()) >= 0
-    }, {})
-  })
-
-  it('should succeed on existing button', async function () {
-    await this.buttonsAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['test'],
-      botMsg: {
-        buttons: [
-          {
-            text: 'test'
-          }
-        ]
-      }
+  describe('buttonsAsserter', function () {
+    beforeEach(async function () {
+      this.buttonsAsserter = new ButtonsAsserter({
+        Match: (botresponse, utterance) => botresponse.toLowerCase().indexOf(utterance.toLowerCase()) >= 0
+      }, {})
     })
-  })
-  it('should succeed on existing card button', async function () {
-    await this.buttonsAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['test'],
-      botMsg: {
-        cards: [
-          {
-            buttons: [
-              {
-                text: 'test'
-              }
-            ]
-          }
-        ]
-      }
+
+    it('should succeed on existing button', async function () {
+      await this.buttonsAsserter.assertConvoStep({
+        convoStep: { stepTag: 'test' },
+        args: ['test'],
+        botMsg: {
+          buttons: [
+            {
+              text: 'test'
+            }
+          ]
+        }
+      })
     })
-  })
-  it('should succeed on existing card buttons', async function () {
-    await this.buttonsAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['test', 'test1'],
-      botMsg: {
-        buttons: [
-          {
-            text: 'test'
-          }
-        ],
-        cards: [
-          {
-            buttons: [
-              {
-                text: 'test1'
-              }
-            ]
-          }
-        ]
-      }
+    it('should succeed on existing card button', async function () {
+      await this.buttonsAsserter.assertConvoStep({
+        convoStep: { stepTag: 'test' },
+        args: ['test'],
+        botMsg: {
+          cards: [
+            {
+              buttons: [
+                {
+                  text: 'test'
+                }
+              ]
+            }
+          ]
+        }
+      })
     })
-  })
-  it('should succeed on existing card buttons', async function () {
-    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', async function () {
+      await this.buttonsAsserter.assertConvoStep({
+        convoStep: { stepTag: 'test' },
+        args: ['test', 'test1'],
+        botMsg: {
+          buttons: [
+            {
+              text: 'test'
+            }
+          ],
+          cards: [
+            {
+              buttons: [
+                {
+                  text: 'test1'
+                }
+              ]
+            }
+          ]
+        }
+      })
     })
-  })
-  it('should succeed on not existing button', async function () {
-    await this.buttonsAsserter.assertNotConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['test1'],
-      botMsg: {
-        buttons: [
-          {
-            text: 'test'
-          }
-        ]
-      }
+    it('should succeed on existing card buttons 2', async function () {
+      await this.buttonsAsserter.assertConvoStep({
+        convoStep: { stepTag: 'test' },
+        args: ['test', 'test1'],
+        botMsg: {
+          buttons: [
+            {
+              text: 'test'
+            }
+          ],
+          cards: [
+            {
+              buttons: [
+                {
+                  text: 'test1'
+                }
+              ]
+            }
+          ]
+        }
+      })
     })
-  })
-  it('should fail on unexpected button', async function () {
-    try {
+    it('should succeed on not existing button', async function () {
       await this.buttonsAsserter.assertNotConvoStep({
         convoStep: { stepTag: 'test' },
-        args: ['test', 'test1'],
+        args: ['test1'],
         botMsg: {
           buttons: [
             {
@@ -110,51 +97,34 @@ describe('scripting.asserters.buttonsAsserter', function () {
           ]
         }
       })
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Not expected button(s) with text "test"') > 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, ['test', 'test1'])
-      assert.deepEqual(err.context.cause.actual, ['test'])
-      assert.deepEqual(err.context.cause.diff, ['test'])
-    }
-  })
-  it('should succeed on existing button if has no arg', async function () {
-    await this.buttonsAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: [],
-      botMsg: {
-        buttons: [
-          {
-            text: 'test'
+    })
+    it('should fail on unexpected button', async function () {
+      try {
+        await this.buttonsAsserter.assertNotConvoStep({
+          convoStep: { stepTag: 'test' },
+          args: ['test', 'test1'],
+          botMsg: {
+            buttons: [
+              {
+                text: 'test'
+              }
+            ]
           }
-        ]
+        })
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Not expected button(s) with text "test"') > 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, ['test', 'test1'])
+        assert.deepEqual(err.context.cause.actual, ['test'])
+        assert.deepEqual(err.context.cause.diff, ['test'])
       }
     })
-  })
-  it('should fail on no button if has no arg', async function () {
-    try {
-      await this.buttonsAsserter.assertConvoStep({ convoStep: { stepTag: 'test' } })
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Expected some button(s)') > 0)
-      assert.isNotNull(err.context)
-      assert.isNotNull(err.context.cause)
-      assert.isArray(err.context.cause.expected)
-      assert.isNotTrue(err.context.cause.not)
-      assert.deepEqual(err.context.cause.expected, [])
-      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 () {
-    try {
-      await this.buttonsAsserter.assertNotConvoStep({
+    it('should succeed on existing button if has no arg', async function () {
+      await this.buttonsAsserter.assertConvoStep({
         convoStep: { stepTag: 'test' },
         args: [],
         botMsg: {
@@ -165,131 +135,162 @@ describe('scripting.asserters.buttonsAsserter', function () {
           ]
         }
       })
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Not expected button(s) with text "test"') > 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, [])
-      assert.deepEqual(err.context.cause.actual, ['test'])
-    }
-  })
-})
-describe('scripting.asserters.buttonsCountAsserter', function () {
-  beforeEach(async function () {
-    this.buttonsCountAsserter = new ButtonsCountAsserter({}, {})
-    this.buttonsCountRecAsserter = new ButtonsCountRecAsserter({}, {})
-  })
-
-  it('should succeed on no args with one button', async function () {
-    await this.buttonsCountAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: [],
-      botMsg: {
-        buttons: [{ text: 'test.jpg' }]
+    })
+    it('should fail on no button if has no arg', async function () {
+      try {
+        await this.buttonsAsserter.assertConvoStep({ convoStep: { stepTag: 'test' } })
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Expected some button(s)') > 0)
+        assert.isNotNull(err.context)
+        assert.isNotNull(err.context.cause)
+        assert.isArray(err.context.cause.expected)
+        assert.isNotTrue(err.context.cause.not)
+        assert.deepEqual(err.context.cause.expected, [])
+        assert.deepEqual(err.context.cause.actual, [])
       }
     })
-  })
-  it('should succeed on 3 with 3 buttons', async function () {
-    await this.buttonsCountAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['3'],
-      botMsg: {
-        buttons: [{ text: 'test.jpg' }, { text: 'test.jpg' }, { text: 'test.jpg' }],
-        cards: [
-          { buttons: [{ text: 'test.jpg' }], cards: [{ buttons: [{ text: 'test.jpg' }] }] }
-        ]
+    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 () {
+      try {
+        await this.buttonsAsserter.assertNotConvoStep({
+          convoStep: { stepTag: 'test' },
+          args: [],
+          botMsg: {
+            buttons: [
+              {
+                text: 'test'
+              }
+            ]
+          }
+        })
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Not expected button(s) with text "test"') > 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, [])
+        assert.deepEqual(err.context.cause.actual, ['test'])
       }
     })
   })
-  it('should fail on 3 with 4 buttons', async function () {
-    try {
+  describe('buttonsCountAsserter', function () {
+    beforeEach(async function () {
+      this.buttonsCountAsserter = new ButtonsCountAsserter({}, {})
+      this.buttonsCountRecAsserter = new ButtonsCountRecAsserter({}, {})
+    })
+
+    it('should succeed on no args with one button', async function () {
       await this.buttonsCountAsserter.assertConvoStep({
         convoStep: { stepTag: 'test' },
-        args: ['3'],
+        args: [],
         botMsg: {
-          buttons: [{ text: 'test.jpg' }, { text: 'test.jpg' }, { text: 'test.jpg' }, { text: 'test.jpg' }],
-          cards: [
-            { buttons: [{ text: 'test.jpg' }], cards: [{ buttons: [{ text: 'test.jpg' }] }] }
-          ]
+          buttons: [{ text: 'test.jpg' }]
         }
       })
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Expected Buttons count 4 to be 3') >= 0)
-    }
-  })
-  it('should fail on >3 with 3 buttons', async function () {
-    try {
+    })
+    it('should succeed on 3 with 3 buttons', async function () {
       await this.buttonsCountAsserter.assertConvoStep({
         convoStep: { stepTag: 'test' },
-        args: ['>3'],
+        args: ['3'],
         botMsg: {
           buttons: [{ text: 'test.jpg' }, { text: 'test.jpg' }, { text: 'test.jpg' }],
           cards: [
-            { buttons: [{ text: 'test.jpg' }], cards: [{ buttons: [{ text: 'test.jpg' }] }] }
+            {
+              buttons: [{ text: 'test.jpg' }],
+              cards: [{ buttons: [{ text: 'test.jpg' }] }]
+            }
           ]
         }
       })
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Expected Buttons count 3 to be >3') >= 0)
-    }
-  })
-  it('should succeed on >=3 with rec buttons', async function () {
-    await this.buttonsCountRecAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['>=3'],
-      botMsg: {
-        buttons: [{ text: 'test.jpg' }],
-        cards: [
-          { buttons: [{ text: 'test.jpg' }], cards: [{ buttons: [{ text: 'test.jpg' }] }] }
-        ]
-      }
     })
-  })
-  it('should succeed on 3 with rec buttons', async function () {
-    await this.buttonsCountRecAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['3'],
-      botMsg: {
-        buttons: [{ text: 'test.jpg' }],
-        cards: [
-          { buttons: [{ text: 'test.jpg' }], cards: [{ buttons: [{ text: 'test.jpg' }] }] }
-        ]
+    it('should fail on 3 with 4 buttons', async function () {
+      try {
+        await this.buttonsCountAsserter.assertConvoStep({
+          convoStep: { stepTag: 'test' },
+          args: ['3'],
+          botMsg: {
+            buttons: [{ text: 'test.jpg' }, { text: 'test.jpg' }, { text: 'test.jpg' }, { text: 'test.jpg' }],
+            cards: [
+              {
+                buttons: [{ text: 'test.jpg' }],
+                cards: [{ buttons: [{ text: 'test.jpg' }] }]
+              }
+            ]
+          }
+        })
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Expected Buttons count 4 to be 3') >= 0)
       }
     })
-  })
-})
-
-describe('scripting.asserters.buttonsNormalizeAsserter', function () {
-  beforeEach(async function () {
-    this.cardsAsserter = new ButtonsAsserter({
-      Match: (botresponse, utterance) => botresponse.toLowerCase().indexOf(utterance.toLowerCase()) >= 0
-    }, { SCRIPTING_NORMALIZE_TEXT: true })
-  })
-
-  it('should succeed with normalized text', async function () {
-    await this.cardsAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['Test Html header      test html text'],
-      botMsg: {
-        buttons: [
-          {
-            text: '<html><h1>test html header</h1><p>test html text</p>'
+    it('should fail on >3 with 3 buttons', async function () {
+      try {
+        await this.buttonsCountAsserter.assertConvoStep({
+          convoStep: { stepTag: 'test' },
+          args: ['>3'],
+          botMsg: {
+            buttons: [{ text: 'test.jpg' }, { text: 'test.jpg' }, { text: 'test.jpg' }],
+            cards: [
+              {
+                buttons: [{ text: 'test.jpg' }],
+                cards: [{ buttons: [{ text: 'test.jpg' }] }]
+              }
+            ]
           }
-        ]
+        })
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Expected Buttons count 3 to be >3') >= 0)
       }
     })
+    it('should succeed on >=3 with rec buttons', async function () {
+      await this.buttonsCountRecAsserter.assertConvoStep({
+        convoStep: { stepTag: 'test' },
+        args: ['>=3'],
+        botMsg: {
+          buttons: [{ text: 'test.jpg' }],
+          cards: [
+            {
+              buttons: [{ text: 'test.jpg' }],
+              cards: [{ buttons: [{ text: 'test.jpg' }] }]
+            }
+          ]
+        }
+      })
+    })
+    it('should succeed on 3 with rec buttons', async function () {
+      await this.buttonsCountRecAsserter.assertConvoStep({
+        convoStep: { stepTag: 'test' },
+        args: ['3'],
+        botMsg: {
+          buttons: [{ text: 'test.jpg' }],
+          cards: [
+            {
+              buttons: [{ text: 'test.jpg' }],
+              cards: [{ buttons: [{ text: 'test.jpg' }] }]
+            }
+          ]
+        }
+      })
+    })
   })
 
-  it('should fail with normalized text', async function () {
-    try {
+  describe('buttonsNormalizeAsserter', function () {
+    beforeEach(async function () {
+      this.cardsAsserter = new ButtonsAsserter({
+        Match: (botresponse, utterance) => botresponse.toLowerCase().indexOf(utterance.toLowerCase()) >= 0
+      }, { SCRIPTING_NORMALIZE_TEXT: true })
+    })
+
+    it('should succeed with normalized text', async function () {
       await this.cardsAsserter.assertConvoStep({
         convoStep: { stepTag: 'test' },
-        args: ['Test Html header1      test html text'],
+        args: ['Test Html header      test html text'],
         botMsg: {
           buttons: [
             {
@@ -298,15 +299,31 @@ describe('scripting.asserters.buttonsNormalizeAsserter', function () {
           ]
         }
       })
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Expected button(s) with text "Test Html header1      test html text"') > 0)
-      assert.isNotNull(err.context)
-      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'])
-      assert.deepEqual(err.context.cause.diff, ['Test Html header1      test html text'])
-    }
+    })
+
+    it('should fail with normalized text', async function () {
+      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>'
+              }
+            ]
+          }
+        })
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Expected button(s) with text "Test Html header1      test html text"') > 0)
+        assert.isNotNull(err.context)
+        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'])
+        assert.deepEqual(err.context.cause.diff, ['Test Html header1      test html text'])
+      }
+    })
   })
 })