botium-core 1.13.0 → 1.13.3

package/test/convo/retryconvo.spec.js

@@ -0,0 +1,134 @@
+const path = require('path')
+const assert = require('chai').assert
+const BotDriver = require('../../').BotDriver
+const Capabilities = require('../../').Capabilities
+
+const echoConnector = (numErrors, errorText) => ({ queueBotSays }) => {
+  let errors = 0
+  return {
+    UserSays (msg) {
+      if (errors >= numErrors) {
+        const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: msg.messageText }
+        queueBotSays(botMsg)
+      } else {
+        errors++
+        return Promise.reject(errorText)
+      }
+    }
+  }
+}
+
+describe('convo.retries', function () {
+  beforeEach(async function () {
+    this.init = async (numErrors, errorText, errorPatterns, numRetries) => {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'convo.retry',
+        [Capabilities.CONTAINERMODE]: echoConnector(numErrors, errorText),
+        RETRY_CONVO_MINTIMEOUT: 10,
+        RETRY_CONVO_ONERROR_REGEXP: errorPatterns
+      }
+      if (!isNaN(numRetries)) {
+        myCaps.RETRY_CONVO_NUMRETRIES = numRetries
+      }
+      this.driver = new BotDriver(myCaps)
+      this.compiler = this.driver.BuildCompiler()
+      this.container = await this.driver.Build()
+      await this.container.Start()
+    }
+  })
+  afterEach(async function () {
+    await this.container.Stop()
+    await this.container.Clean()
+  })
+
+  it('should fail without retry', async function () {
+    await this.init(1, 'myerror')
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '1step.convo.txt')
+    try {
+      await this.compiler.convos[0].Run(this.container)
+    } catch (err) {
+      assert.isTrue(err.message.indexOf('myerror') >= 0)
+      return
+    }
+    assert.fail('should have failed without retry')
+  })
+  it('should succeed after one retry with default numRetries', async function () {
+    await this.init(1, 'myerror', 'myerror')
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '1step.convo.txt')
+    await this.compiler.convos[0].Run(this.container)
+  })
+  it('should succeed after one retry with joker regex', async function () {
+    await this.init(1, 'myerror', null, 1)
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '1step.convo.txt')
+    await this.compiler.convos[0].Run(this.container)
+  })
+  it('should fail after one retry with default settings', async function () {
+    await this.init(2, 'myerror', 'myerror')
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '1step.convo.txt')
+    try {
+      await this.compiler.convos[0].Run(this.container)
+    } catch (err) {
+      assert.isTrue(err.message.indexOf('myerror') >= 0)
+      return
+    }
+    assert.fail('should have failed after first retry')
+  })
+  it('should succeed after many retries', async function () {
+    await this.init(5, 'myerror', 'myerror', 5)
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '1step.convo.txt')
+    await this.compiler.convos[0].Run(this.container)
+  })
+  it('should succeed after too less retries', async function () {
+    await this.init(5, 'myerror', 'myerror', 4)
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '1step.convo.txt')
+    try {
+      await this.compiler.convos[0].Run(this.container)
+    } catch (err) {
+      assert.isTrue(err.message.indexOf('myerror') >= 0)
+      return
+    }
+    assert.fail('should have failed after four retries')
+  })
+  it('should succeed after one retry with regexp pattern', async function () {
+    await this.init(1, 'myerror', /myeRRor/i)
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '1step.convo.txt')
+    await this.compiler.convos[0].Run(this.container)
+  })
+  it('should fail after one retry with unmatched regexp pattern', async function () {
+    await this.init(1, 'myerror', /myeRRor1/i)
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '1step.convo.txt')
+    try {
+      await this.compiler.convos[0].Run(this.container)
+    } catch (err) {
+      assert.isTrue(err.message.indexOf('myerror') >= 0)
+      return
+    }
+    assert.fail('should have failed with unmatched retry pattern')
+  })
+  it('should succeed after one retry with regexp pattern array', async function () {
+    await this.init(1, 'myerror', [/myeRRor/i, /myeRRor1/i])
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '1step.convo.txt')
+    await this.compiler.convos[0].Run(this.container)
+  })
+  it('should fail after one retry with unmatched regexp pattern array', async function () {
+    await this.init(1, 'myerror', [/myeRRor1/i, /myeRRor2/i])
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '1step.convo.txt')
+    try {
+      await this.compiler.convos[0].Run(this.container)
+    } catch (err) {
+      assert.isTrue(err.message.indexOf('myerror') >= 0)
+      return
+    }
+    assert.fail('should have failed with unmatched retry pattern')
+  })
+})

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 - Unexpected end of input'))
-    }
   })
-})
 
-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)
   })
 })