botium-core 1.13.2 → 1.13.3

package/test/driver/capabilities.spec.js

@@ -3,162 +3,167 @@ const BotDriver = require('../../').BotDriver
 const Capabilities = require('../../').Capabilities
 const DefaultCapabilities = require('../../src/Defaults').Capabilities
 
-describe('driver.fetchConfigFromFiles', function () {
-  it('fetch capabilities from files', function () {
-    const driver = new BotDriver()
-    const result = driver._fetchConfigFromFiles(['test/driver/configFiles/config1.json'])
-    assert.isArray(result)
-    assert.lengthOf(result, 1)
-  })
-  it('fetch capabilities from non existing files', function () {
-    const driver = new BotDriver()
-    const result = driver._fetchConfigFromFiles(['test/driver/configFiles/configNotExists.json'])
-    assert.isArray(result)
-    assert.lengthOf(result, 0)
-  })
-  it('fetch capabilities from multiple files', function () {
-    const driver = new BotDriver()
-    const result = driver._fetchConfigFromFiles(['test/driver/configFiles/config1.json', 'test/driver/configFiles/config2.json'])
-    assert.isArray(result)
-    assert.lengthOf(result, 2)
-  })
-  it('fetch capabilities from multiple files and check if overwritten', function () {
-    const driver = new BotDriver()
-    driver._fetchConfigFromFiles(['test/driver/configFiles/config1.json', 'test/driver/configFiles/config2.json'])
-    assert.equal(driver.caps.PROJECTNAME, 'Botium Example 2')
-    assert.equal(driver.sources.GITURL, 'https://github.com/codeforequity-at/botium-bindings')
-    assert.equal(driver.envs.IS_BOTIUM_CONTAINER, true)
+describe('driver.capabilities', function () {
+  describe('fetchConfigFromFiles', function () {
+    it('fetch capabilities from files', function () {
+      const driver = new BotDriver()
+      const result = driver._fetchConfigFromFiles(['test/driver/configFiles/config1.json'])
+      assert.isArray(result)
+      assert.lengthOf(result, 1)
+    })
+    it('fetch capabilities from non existing files', function () {
+      const driver = new BotDriver()
+      const result = driver._fetchConfigFromFiles(['test/driver/configFiles/configNotExists.json'])
+      assert.isArray(result)
+      assert.lengthOf(result, 0)
+    })
+    it('fetch capabilities from multiple files', function () {
+      const driver = new BotDriver()
+      const result = driver._fetchConfigFromFiles(['test/driver/configFiles/config1.json', 'test/driver/configFiles/config2.json'])
+      assert.isArray(result)
+      assert.lengthOf(result, 2)
+    })
+    it('fetch capabilities from multiple files and check if overwritten', function () {
+      const driver = new BotDriver()
+      driver._fetchConfigFromFiles(['test/driver/configFiles/config1.json', 'test/driver/configFiles/config2.json'])
+      assert.equal(driver.caps.PROJECTNAME, 'Botium Example 2')
+      assert.equal(driver.sources.GITURL, 'https://github.com/codeforequity-at/botium-bindings')
+      assert.equal(driver.envs.IS_BOTIUM_CONTAINER, true)
+    })
   })
-})
 
-describe('driver.loadConfigFile', function () {
-  it('load Config from file', function () {
-    const driver = new BotDriver()
-    const result = driver._loadConfigFile('test/driver/configFiles/config1.json')
-    assert.isTrue(result)
+  describe('loadConfigFile', function () {
+    it('load Config from file', function () {
+      const driver = new BotDriver()
+      const result = driver._loadConfigFile('test/driver/configFiles/config1.json')
+      assert.isTrue(result)
+    })
+    it('load Config from non existing file', function () {
+      const driver = new BotDriver()
+      assert.throws(() => driver._loadConfigFile('test/driver/configFiles/configNonExisting.json'))
+    })
+    it('load Config from file only once', function () {
+      const driver = new BotDriver()
+      driver._fetchConfigFromFiles(['test/driver/configFiles/config1.json', 'test/driver/configFiles/config1.json', 'test/driver/configFiles/config1.json'])
+      assert.lengthOf(driver._fetchedConfigFiles, 1)
+      assert.lengthOf(driver.caps.ARR_CAP, 2)
+    })
+    it('should make unique array', function () {
+      const driver = new BotDriver()
+      driver._fetchConfigFromFiles(['test/driver/configFiles/config1.json', 'test/driver/configFiles/config2.json'])
+      assert.lengthOf(driver._fetchedConfigFiles, 2)
+      assert.lengthOf(driver.caps.ARR_CAP, 3)
+      assert.deepEqual(driver.caps.ARR_CAP, ['val1', 'val2', 'val3'])
+    })
   })
-  it('load Config from non existing file', function () {
-    const driver = new BotDriver()
-    assert.throws(() => driver._loadConfigFile('test/driver/configFiles/configNonExisting.json'))
-  })
-  it('load Config from file only once', function () {
-    const driver = new BotDriver()
-    driver._fetchConfigFromFiles(['test/driver/configFiles/config1.json', 'test/driver/configFiles/config1.json', 'test/driver/configFiles/config1.json'])
-    assert.lengthOf(driver._fetchedConfigFiles, 1)
-    assert.lengthOf(driver.caps.ARR_CAP, 2)
-  })
-  it('should make unique array', function () {
-    const driver = new BotDriver()
-    driver._fetchConfigFromFiles(['test/driver/configFiles/config1.json', 'test/driver/configFiles/config2.json'])
-    assert.lengthOf(driver._fetchedConfigFiles, 2)
-    assert.lengthOf(driver.caps.ARR_CAP, 3)
-    assert.deepEqual(driver.caps.ARR_CAP, ['val1', 'val2', 'val3'])
-  })
-})
 
-describe('driver.capabilities', function () {
-  it('should merge boolean caps', function () {
-    const myCaps = {
-      [Capabilities.SIMULATE_WRITING_SPEED]: 'YES'
-    }
-    const driver = new BotDriver(myCaps)
-    assert.isBoolean(driver.caps[Capabilities.SIMULATE_WRITING_SPEED])
-    assert.isTrue(driver.caps[Capabilities.SIMULATE_WRITING_SPEED])
+  describe('capabilities', function () {
+    it('should merge boolean caps', function () {
+      const myCaps = {
+        [Capabilities.SIMULATE_WRITING_SPEED]: 'YES'
+      }
+      const driver = new BotDriver(myCaps)
+      assert.isBoolean(driver.caps[Capabilities.SIMULATE_WRITING_SPEED])
+      assert.isTrue(driver.caps[Capabilities.SIMULATE_WRITING_SPEED])
+    })
+    it('should merge string caps', function () {
+      const myCaps = {
+        CAP_STRING_1: 'Test',
+        CAP_STRING_2: '12345'
+      }
+      const driver = new BotDriver(myCaps)
+      assert.isString(driver.caps.CAP_STRING_1)
+      assert.isString(driver.caps.CAP_STRING_2)
+    })
+    it('should merge boolean envs', function () {
+      process.env.BOTIUM_SIMULATE_WRITING_SPEED = 'NO'
+      const driver = new BotDriver()
+      delete process.env.BOTIUM_SIMULATE_WRITING_SPEED
+      assert.isBoolean(driver.caps[Capabilities.SIMULATE_WRITING_SPEED])
+      assert.isFalse(driver.caps[Capabilities.SIMULATE_WRITING_SPEED])
+    })
+    it('should parse array caps', function () {
+      DefaultCapabilities.MYCAP = []
+      const myCaps = {
+        MYCAP: '[{"KEY":"VALUE"},{"KEY":"VALUE1"}]'
+      }
+      const driver = new BotDriver(myCaps)
+      assert.isArray(driver.caps.MYCAP)
+      assert.lengthOf(driver.caps.MYCAP, 2)
+    })
+    it('should merge array caps', function () {
+      DefaultCapabilities.MYCAP = [{
+        id: 'id1',
+        key: 'VALUE'
+      }]
+      const myCaps = {
+        MYCAP: '[{"id":"id1", "key1": "VALUE1"},{"key":"VALUE1"}]'
+      }
+      const driver = new BotDriver(myCaps)
+      assert.isArray(driver.caps.MYCAP)
+      assert.lengthOf(driver.caps.MYCAP, 2)
+      assert.equal(driver.caps.MYCAP[0].key, 'VALUE')
+      assert.equal(driver.caps.MYCAP[0].key1, 'VALUE1')
+      assert.isUndefined(driver.caps.MYCAP[1].id)
+      assert.equal(driver.caps.MYCAP[1].key, 'VALUE1')
+    })
+    it('should parse object caps', function () {
+      DefaultCapabilities.MYCAP = { KEY: 'VALUE' }
+      const myCaps = {
+        MYCAP: '{"KEY":"VALUE1"}'
+      }
+      const driver = new BotDriver(myCaps)
+      assert.isObject(driver.caps.MYCAP)
+      assert.equal(driver.caps.MYCAP.KEY, 'VALUE1')
+    })
+    it('should merge object caps', function () {
+      DefaultCapabilities.MYCAP = { KEY: 'VALUE' }
+      const myCaps = {
+        MYCAP: '{"KEY1":"VALUE1"}'
+      }
+      const driver = new BotDriver(myCaps)
+      assert.isObject(driver.caps.MYCAP)
+      assert.equal(driver.caps.MYCAP.KEY, 'VALUE')
+      assert.equal(driver.caps.MYCAP.KEY1, 'VALUE1')
+    })
+    it('should not parse JSON caps', function () {
+      const myCaps = {
+        MYJSONCAP: '{"KEY":"VALUE1"}'
+      }
+      const driver = new BotDriver(myCaps)
+      assert.isObject(driver.caps.MYJSONCAP)
+      assert.equal(driver.caps.MYJSONCAP.KEY, 'VALUE1')
+    })
+    it('should override not matching object caps', function () {
+      DefaultCapabilities.MYCAP = { KEY: 'VALUE' }
+      const myCaps = {
+        MYCAP: 'SIMPLESTRING'
+      }
+      const driver = new BotDriver(myCaps)
+      assert.isString(driver.caps.MYCAP)
+      assert.equal(driver.caps.MYCAP, 'SIMPLESTRING')
+    })
+    it('should override not matching array caps', function () {
+      DefaultCapabilities.MYCAP = ['VAL1', 'VAL2']
+      const myCaps = {
+        MYCAP: { VAL1: 'VALUE1' }
+      }
+      const driver = new BotDriver(myCaps)
+      assert.isObject(driver.caps.MYCAP)
+      assert.equal(driver.caps.MYCAP.VAL1, 'VALUE1')
+    })
   })
-  it('should merge string caps', function () {
-    const myCaps = {
-      CAP_STRING_1: 'Test',
-      CAP_STRING_2: '12345'
-    }
-    const driver = new BotDriver(myCaps)
-    assert.isString(driver.caps.CAP_STRING_1)
-    assert.isString(driver.caps.CAP_STRING_2)
-  })
-  it('should merge boolean envs', function () {
-    process.env.BOTIUM_SIMULATE_WRITING_SPEED = 'NO'
-    const driver = new BotDriver()
-    delete process.env.BOTIUM_SIMULATE_WRITING_SPEED
-    assert.isBoolean(driver.caps[Capabilities.SIMULATE_WRITING_SPEED])
-    assert.isFalse(driver.caps[Capabilities.SIMULATE_WRITING_SPEED])
-  })
-  it('should parse array caps', function () {
-    DefaultCapabilities.MYCAP = []
-    const myCaps = {
-      MYCAP: '[{"KEY":"VALUE"},{"KEY":"VALUE1"}]'
-    }
-    const driver = new BotDriver(myCaps)
-    assert.isArray(driver.caps.MYCAP)
-    assert.lengthOf(driver.caps.MYCAP, 2)
-  })
-  it('should merge array caps', function () {
-    DefaultCapabilities.MYCAP = [{ id: 'id1', key: 'VALUE' }]
-    const myCaps = {
-      MYCAP: '[{"id":"id1", "key1": "VALUE1"},{"key":"VALUE1"}]'
-    }
-    const driver = new BotDriver(myCaps)
-    assert.isArray(driver.caps.MYCAP)
-    assert.lengthOf(driver.caps.MYCAP, 2)
-    assert.equal(driver.caps.MYCAP[0].key, 'VALUE')
-    assert.equal(driver.caps.MYCAP[0].key1, 'VALUE1')
-    assert.isUndefined(driver.caps.MYCAP[1].id)
-    assert.equal(driver.caps.MYCAP[1].key, 'VALUE1')
-  })
-  it('should parse object caps', function () {
-    DefaultCapabilities.MYCAP = { KEY: 'VALUE' }
-    const myCaps = {
-      MYCAP: '{"KEY":"VALUE1"}'
-    }
-    const driver = new BotDriver(myCaps)
-    assert.isObject(driver.caps.MYCAP)
-    assert.equal(driver.caps.MYCAP.KEY, 'VALUE1')
-  })
-  it('should merge object caps', function () {
-    DefaultCapabilities.MYCAP = { KEY: 'VALUE' }
-    const myCaps = {
-      MYCAP: '{"KEY1":"VALUE1"}'
-    }
-    const driver = new BotDriver(myCaps)
-    assert.isObject(driver.caps.MYCAP)
-    assert.equal(driver.caps.MYCAP.KEY, 'VALUE')
-    assert.equal(driver.caps.MYCAP.KEY1, 'VALUE1')
-  })
-  it('should not parse JSON caps', function () {
-    const myCaps = {
-      MYJSONCAP: '{"KEY":"VALUE1"}'
-    }
-    const driver = new BotDriver(myCaps)
-    assert.isObject(driver.caps.MYJSONCAP)
-    assert.equal(driver.caps.MYJSONCAP.KEY, 'VALUE1')
-  })
-  it('should override not matching object caps', function () {
-    DefaultCapabilities.MYCAP = { KEY: 'VALUE' }
-    const myCaps = {
-      MYCAP: 'SIMPLESTRING'
-    }
-    const driver = new BotDriver(myCaps)
-    assert.isString(driver.caps.MYCAP)
-    assert.equal(driver.caps.MYCAP, 'SIMPLESTRING')
-  })
-  it('should override not matching array caps', function () {
-    DefaultCapabilities.MYCAP = ['VAL1', 'VAL2']
-    const myCaps = {
-      MYCAP: { VAL1: 'VALUE1' }
-    }
-    const driver = new BotDriver(myCaps)
-    assert.isObject(driver.caps.MYCAP)
-    assert.equal(driver.caps.MYCAP.VAL1, 'VALUE1')
-  })
-})
 
-describe('driver.constructor', function () {
-  it('should deep copy caps', function () {
-    const myCaps = {
-      ASSERTERS: [{ name: 'ASSERTER1' }]
-    }
-    const driver = new BotDriver(myCaps)
-    assert.isArray(driver.caps.ASSERTERS)
-    assert.lengthOf(driver.caps.ASSERTERS, 1)
-    assert.isArray(DefaultCapabilities.ASSERTERS)
-    assert.lengthOf(DefaultCapabilities.ASSERTERS, 0)
+  describe('constructor', function () {
+    it('should deep copy caps', function () {
+      const myCaps = {
+        ASSERTERS: [{ name: 'ASSERTER1' }]
+      }
+      const driver = new BotDriver(myCaps)
+      assert.isArray(driver.caps.ASSERTERS)
+      assert.lengthOf(driver.caps.ASSERTERS, 1)
+      assert.isArray(DefaultCapabilities.ASSERTERS)
+      assert.lengthOf(DefaultCapabilities.ASSERTERS, 0)
+    })
   })
 })

package/test/logichooks/hookfromsrc.spec.js

@@ -6,7 +6,11 @@ const Capabilities = require('../../').Capabilities
 const echoConnector = ({ queueBotSays }) => {
   return {
     UserSays (msg) {
-      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: msg.messageText }
+      const botMsg = {
+        sender: 'bot',
+        sourceData: msg.sourceData,
+        messageText: msg.messageText
+      }
       queueBotSays(botMsg)
     }
   }
@@ -26,86 +30,88 @@ const buildDriver = async (mergeCaps) => {
 }
 
 describe('logichooks.hookfromsrc', function () {
-  it('should succeed with asserter from code', async function () {
-    const { compiler, container } = await buildDriver({
-      [Capabilities.ASSERTERS]: [{
-        ref: 'CUSTOMASSERTER',
-        src: {
-          assertConvoStep: 'if (botMsg.messageText === "Hello") result=Promise.resolve(); else result=Promise.reject(new Error("expected Hello"))'
-        }
-      }]
+  describe('hookfromsrc', function () {
+    it('should succeed with asserter from code', async function () {
+      const { compiler, container } = await buildDriver({
+        [Capabilities.ASSERTERS]: [{
+          ref: 'CUSTOMASSERTER',
+          src: {
+            assertConvoStep: 'if (botMsg.messageText === "Hello") result=Promise.resolve(); else result=Promise.reject(new Error("expected Hello"))'
+          }
+        }]
+      })
+      compiler.ReadScript(path.resolve(__dirname, 'convos'), 'HOOKFROMSRC.convo.txt')
+      await compiler.convos[0].Run(container)
     })
-    compiler.ReadScript(path.resolve(__dirname, 'convos'), 'HOOKFROMSRC.convo.txt')
-    await compiler.convos[0].Run(container)
-  })
-  it('should fail with asserter from code', async function () {
-    const { compiler, container } = await buildDriver({
-      [Capabilities.ASSERTERS]: [{
-        ref: 'CUSTOMASSERTER',
-        src: {
-          assertConvoStep: 'if (botMsg.messageText === "Hello1") module.exports=Promise.resolve(); else module.exports=Promise.reject(new Error("expected Hello1"))'
-        }
-      }]
+    it('should fail with asserter from code', async function () {
+      const { compiler, container } = await buildDriver({
+        [Capabilities.ASSERTERS]: [{
+          ref: 'CUSTOMASSERTER',
+          src: {
+            assertConvoStep: 'if (botMsg.messageText === "Hello1") module.exports=Promise.resolve(); else module.exports=Promise.reject(new Error("expected Hello1"))'
+          }
+        }]
+      })
+      compiler.ReadScript(path.resolve(__dirname, 'convos'), 'HOOKFROMSRC.convo.txt')
+      try {
+        await compiler.convos[0].Run(container)
+        assert.fail('it should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.includes('Line 6: assertion error - expected Hello1'))
+      }
     })
-    compiler.ReadScript(path.resolve(__dirname, 'convos'), 'HOOKFROMSRC.convo.txt')
-    try {
-      await compiler.convos[0].Run(container)
-      assert.fail('it should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.includes('Line 6: assertion error - expected Hello1'))
-    }
-  })
-  it('should fail with asserter with invalid script', async function () {
-    const { compiler, container } = await buildDriver({
-      [Capabilities.ASSERTERS]: [{
-        ref: 'CUSTOMASSERTER',
-        src: {
-          assertConvoStep: '!'
-        }
-      }]
+    it('should fail with asserter with invalid script', async function () {
+      const { compiler, container } = await buildDriver({
+        [Capabilities.ASSERTERS]: [{
+          ref: 'CUSTOMASSERTER',
+          src: {
+            assertConvoStep: '!'
+          }
+        }]
+      })
+      compiler.ReadScript(path.resolve(__dirname, 'convos'), 'HOOKFROMSRC.convo.txt')
+      try {
+        await compiler.convos[0].Run(container)
+        assert.fail('it should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.includes('Line 6: assertion error - Script assertConvoStep is not valid'))
+      }
     })
-    compiler.ReadScript(path.resolve(__dirname, 'convos'), 'HOOKFROMSRC.convo.txt')
-    try {
-      await compiler.convos[0].Run(container)
-      assert.fail('it should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.includes('Line 6: assertion error - Script assertConvoStep is not valid'))
-    }
   })
-})
 
-const buildDriverFromFile = async (mergeCaps) => {
-  const myCaps = Object.assign({
-    [Capabilities.PROJECTNAME]: 'logichooks.hookfromsrc',
-    [Capabilities.CONTAINERMODE]: path.join(__dirname, 'botium-connector-fromfile')
-  }, mergeCaps)
+  const buildDriverFromFile = async (mergeCaps) => {
+    const myCaps = Object.assign({
+      [Capabilities.PROJECTNAME]: 'logichooks.hookfromsrc',
+      [Capabilities.CONTAINERMODE]: path.join(__dirname, 'botium-connector-fromfile')
+    }, mergeCaps)
 
-  const result = {}
-  result.driver = new BotDriver(myCaps)
-  result.compiler = result.driver.BuildCompiler()
-  result.container = await result.driver.Build()
-  return result
-}
+    const result = {}
+    result.driver = new BotDriver(myCaps)
+    result.compiler = result.driver.BuildCompiler()
+    result.container = await result.driver.Build()
+    return result
+  }
 
-describe('logichooks.hookfromconnector', function () {
-  it('should succeed with asserter from connector', async function () {
-    const { compiler, container } = await buildDriverFromFile({
-      [Capabilities.ASSERTERS]: [{
-        ref: 'CUSTOMASSERTER',
-        src: path.join(__dirname, 'botium-connector-fromfile.js/MyCustomAsserter')
-      }]
+  describe('hookfromconnector', function () {
+    it('should succeed with asserter from connector', async function () {
+      const { compiler, container } = await buildDriverFromFile({
+        [Capabilities.ASSERTERS]: [{
+          ref: 'CUSTOMASSERTER',
+          src: path.join(__dirname, 'botium-connector-fromfile.js/MyCustomAsserter')
+        }]
+      })
+      compiler.ReadScript(path.resolve(__dirname, 'convos'), 'HOOKFROMSRC.convo.txt')
+      await compiler.convos[0].Run(container)
     })
-    compiler.ReadScript(path.resolve(__dirname, 'convos'), 'HOOKFROMSRC.convo.txt')
-    await compiler.convos[0].Run(container)
-  })
-  it('should succeed with asserter from asserter module file', async function () {
-    const { compiler, container } = await buildDriverFromFile({
-      [Capabilities.ASSERTERS]: [{
-        ref: 'CUSTOMASSERTER',
-        src: path.join(__dirname, 'botium-asserter-fromfile.js')
-      }]
+    it('should succeed with asserter from asserter module file', async function () {
+      const { compiler, container } = await buildDriverFromFile({
+        [Capabilities.ASSERTERS]: [{
+          ref: 'CUSTOMASSERTER',
+          src: path.join(__dirname, 'botium-asserter-fromfile.js')
+        }]
+      })
+      compiler.ReadScript(path.resolve(__dirname, 'convos'), 'HOOKFROMSRC.convo.txt')
+      await compiler.convos[0].Run(container)
     })
-    compiler.ReadScript(path.resolve(__dirname, 'convos'), 'HOOKFROMSRC.convo.txt')
-    await compiler.convos[0].Run(container)
   })
 })

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')
+    })
   })
 })