botium-core 1.13.2 → 1.13.3

package/test/scripting/scriptingmemory/useScriptingMemoryForAssertion.spec.js

@@ -7,7 +7,11 @@ const echoAssertConnector = ({ queueBotSays }) => {
   return {
     UserSays (msg) {
       const response = `${msg.messageText.replace('forcereplace1', 'OUTPUT1').replace('forcereplace2', 'OUTPUT2')}`
-      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: response }
+      const botMsg = {
+        sender: 'bot',
+        sourceData: msg.sourceData,
+        messageText: response
+      }
       queueBotSays(botMsg)
     }
   }
@@ -21,7 +25,11 @@ const echoShopConnector = ({ queueBotSays }) => {
       } else if (msg.messageText.startsWith('Ok, then send me some')) {
         response = `Added ${msg.messageText.substr(21).trim()} to the shopping cart`
       }
-      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: response }
+      const botMsg = {
+        sender: 'bot',
+        sourceData: msg.sourceData,
+        messageText: response
+      }
       queueBotSays(botMsg)
     }
   }
@@ -31,99 +39,105 @@ const multipleVariableEntriesConnector = ({ queueBotSays }) => {
   return {
     UserSays (msg) {
       const response = 'I\'d like to have Schnitzel and one more Schnitzel'
-      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: response }
+      const botMsg = {
+        sender: 'bot',
+        sourceData: msg.sourceData,
+        messageText: response
+      }
       queueBotSays(botMsg)
     }
   }
 }
 
-describe('scripting.useScriptingMemoryForAssertion.simpleassertion', function () {
-  beforeEach(async function () {
-    const myCaps = {
-      [Capabilities.PROJECTNAME]: 'scripting.scriptingmemory',
-      [Capabilities.CONTAINERMODE]: echoAssertConnector,
-      [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()
-  })
+describe('scripting.scriptingmemory.useScriptingMemoryForAssertion', function () {
+  describe('simpleassertion', function () {
+    beforeEach(async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'scripting.scriptingmemory',
+        [Capabilities.CONTAINERMODE]: echoAssertConnector,
+        [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 use scripting memory for assertion', async function () {
-    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convosAssertion'))
-    this.compiler.ExpandScriptingMemoryToConvos()
+    it('should use scripting memory for assertion', async function () {
+      this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convosAssertion'))
+      this.compiler.ExpandScriptingMemoryToConvos()
 
-    try {
-      await this.compiler.convos[0].Run(this.container)
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Bot response (on Line 3: #me - $productName $customer) "OUTPUT1 OUTPUT2" expected to match "forcereplace1 forcereplace2"') >= 0)
-    }
+      try {
+        await this.compiler.convos[0].Run(this.container)
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Bot response (on Line 3: #me - $productName $customer) "OUTPUT1 OUTPUT2" expected to match "forcereplace1 forcereplace2"') >= 0)
+      }
+    })
   })
-})
 
-describe('scripting.useScriptingMemoryForAssertion.multiplefiles', function () {
-  beforeEach(async function () {
-    const myCaps = {
-      [Capabilities.PROJECTNAME]: 'scripting.scriptingmemory',
-      [Capabilities.CONTAINERMODE]: echoShopConnector,
-      [Capabilities.SCRIPTING_ENABLE_MEMORY]: true,
-      [Capabilities.SCRIPTING_MEMORY_MATCHING_MODE]: 'joker'
-    }
-    const driver = new BotDriver(myCaps)
-    this.compiler = driver.BuildCompiler()
-    this.container = await driver.Build()
-  })
-  afterEach(async function () {
-    this.container && await this.container.Clean()
-  })
+  describe('multiplefiles', function () {
+    beforeEach(async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'scripting.scriptingmemory',
+        [Capabilities.CONTAINERMODE]: echoShopConnector,
+        [Capabilities.SCRIPTING_ENABLE_MEMORY]: true,
+        [Capabilities.SCRIPTING_MEMORY_MATCHING_MODE]: 'joker'
+      }
+      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 use scripting memory for assertion', async function () {
-    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convosMultiMemory', 'convos'))
-    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convosMultiMemory', 'memory1'))
-    this.compiler.ExpandScriptingMemoryToConvos()
-    assert.lengthOf(this.compiler.convos, 2)
+    it('should use scripting memory for assertion', async function () {
+      this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convosMultiMemory', 'convos'))
+      this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convosMultiMemory', 'memory1'))
+      this.compiler.ExpandScriptingMemoryToConvos()
+      assert.lengthOf(this.compiler.convos, 2)
 
-    const transcript0 = await this.compiler.convos[0].Run(this.container)
-    assert.lengthOf(transcript0.steps, 4)
-    assert.equal(transcript0.steps[0].scriptingMemory.$available_products, 'Bread, Beer, Eggs')
-    assert.equal(transcript0.steps[0].scriptingMemory.$productName, 'Bread')
+      const transcript0 = await this.compiler.convos[0].Run(this.container)
+      assert.lengthOf(transcript0.steps, 4)
+      assert.equal(transcript0.steps[0].scriptingMemory.$available_products, 'Bread, Beer, Eggs')
+      assert.equal(transcript0.steps[0].scriptingMemory.$productName, 'Bread')
 
-    const transcript1 = await this.compiler.convos[1].Run(this.container)
-    assert.lengthOf(transcript1.steps, 4)
-    assert.equal(transcript1.steps[0].scriptingMemory.$available_products, 'Bread, Beer, Eggs')
-    assert.equal(transcript1.steps[0].scriptingMemory.$productName, 'Beer')
+      const transcript1 = await this.compiler.convos[1].Run(this.container)
+      assert.lengthOf(transcript1.steps, 4)
+      assert.equal(transcript1.steps[0].scriptingMemory.$available_products, 'Bread, Beer, Eggs')
+      assert.equal(transcript1.steps[0].scriptingMemory.$productName, 'Beer')
+    })
   })
-})
 
-describe('scripting.useScriptingMemoryForAssertion.multipleVariableEntries', function () {
-  beforeEach(async function () {
-    const myCaps = {
-      [Capabilities.PROJECTNAME]: 'scripting.scriptingmemory',
-      [Capabilities.CONTAINERMODE]: multipleVariableEntriesConnector,
-      [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()
-  })
+  describe('multipleVariableEntries', function () {
+    beforeEach(async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'scripting.scriptingmemory',
+        [Capabilities.CONTAINERMODE]: multipleVariableEntriesConnector,
+        [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 use scripting memory for assertion several variables entries', async function () {
-    // scripting variables replaced in every entry
-    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'scriptingVariablesSeveralEntries'))
-    assert.equal(this.compiler.convos.length, 1)
+    it('should use scripting memory for assertion several variables entries', async function () {
+      // scripting variables replaced in every entry
+      this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'scriptingVariablesSeveralEntries'))
+      assert.equal(this.compiler.convos.length, 1)
 
-    try {
-      await this.compiler.convos[0].Run(this.container)
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Bot response (on Line 6: #me - What would you like to eat?) "I\'d like to have Schnitzel and one more Schnitzel" expected to match "I\'d like to have a Schnitzel and one more Schnitzel"') >= 0)
-    }
+      try {
+        await this.compiler.convos[0].Run(this.container)
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Bot response (on Line 6: #me - What would you like to eat?) "I\'d like to have Schnitzel and one more Schnitzel" expected to match "I\'d like to have a Schnitzel and one more Schnitzel"') >= 0)
+      }
+    })
   })
 })

package/test/scripting/userinputs/defaultUserInputs.spec.js

@@ -7,147 +7,253 @@ const convoStep = {
   stepTag: 'MYSTEPTAG'
 }
 
-describe('UserInputs.defaults.buttonInput', function () {
-  it('correct number of args', async function () {
-    const bi = new ButtonInput()
-    await bi.setUserInput({ convoStep, args: ['Test1'], meMsg: {} })
-  })
-  it('wrong number of args', async function () {
-    const bi = new ButtonInput()
-    try {
-      await bi.setUserInput({ convoStep, args: ['Test1', 'Test2'], meMsg: {} })
-      assert.fail('expected error')
-    } catch (err) {
-      assert.isDefined(err)
-      assert.instanceOf(err, Error)
-    }
-  })
-  it('empty argument list', async function () {
-    const bi = new ButtonInput()
-    try {
-      await bi.setUserInput({ convoStep, meMsg: {} })
-      assert.fail('expected error')
-    } catch (err) {
-      assert.isDefined(err)
-      assert.instanceOf(err, Error)
-    }
-  })
-  it('should set button in message as payload', async function () {
-    const bi = new ButtonInput()
-
-    const meMsg = {}
-    await bi.setUserInput({ convoStep, args: ['Test1'], meMsg })
-    assert.isArray(meMsg.buttons)
-    assert.lengthOf(meMsg.buttons, 1)
-    assert.equal(meMsg.buttons[0].payload, 'Test1')
-  })
-})
-
-describe('UserInputs.defaults.mediaInput', function () {
-  it('correct number of args', async function () {
-    const mi = new MediaInput({}, { SECURITY_ALLOW_UNSAFE: true })
-    await mi.setUserInput({ convoStep, args: ['Test1'], meMsg: {}, convo: { sourceTag: { filename: '' } } })
-  })
-  it('correct number of args with buffer', async function () {
-    const mi = new MediaInput()
-    await mi.setUserInput({ convoStep, args: ['Test1', Buffer.from('hello')], meMsg: {}, convo: { sourceTag: { filename: '' } } })
-  })
-  it('wrong number of args', async function () {
-    const mi = new MediaInput()
-    return mi.setUserInput({ convoStep, args: ['Test1', 'Test2'], meMsg: {} })
-      .then(() => assert.fail('expected error'))
-      .catch((err) => {
+describe('scripting.userinputs.defaultUserInputs', function () {
+  describe('buttonInput', function () {
+    it('correct number of args', async function () {
+      const bi = new ButtonInput()
+      await bi.setUserInput({
+        convoStep,
+        args: ['Test1'],
+        meMsg: {}
+      })
+    })
+    it('wrong number of args', async function () {
+      const bi = new ButtonInput()
+      try {
+        await bi.setUserInput({
+          convoStep,
+          args: ['Test1', 'Test2'],
+          meMsg: {}
+        })
+        assert.fail('expected error')
+      } catch (err) {
         assert.isDefined(err)
         assert.instanceOf(err, Error)
-      })
-  })
-  it('empty argument list', async function () {
-    const mi = new MediaInput()
-    return mi.setUserInput({ convoStep, meMsg: {} })
-      .then(() => assert.fail('expected error'))
-      .catch((err) => {
+      }
+    })
+    it('empty argument list', async function () {
+      const bi = new ButtonInput()
+      try {
+        await bi.setUserInput({
+          convoStep,
+          meMsg: {}
+        })
+        assert.fail('expected error')
+      } catch (err) {
         assert.isDefined(err)
         assert.instanceOf(err, Error)
+      }
+    })
+    it('should set button in message as payload', async function () {
+      const bi = new ButtonInput()
+
+      const meMsg = {}
+      await bi.setUserInput({
+        convoStep,
+        args: ['Test1'],
+        meMsg
       })
+      assert.isArray(meMsg.buttons)
+      assert.lengthOf(meMsg.buttons, 1)
+      assert.equal(meMsg.buttons[0].payload, 'Test1')
+    })
   })
-  it('should set media in message', async function () {
-    const mi = new MediaInput({}, { SECURITY_ALLOW_UNSAFE: true })
 
-    const meMsg = {}
-    await mi.setUserInput({ convoStep, args: ['Test1'], meMsg, convo: { sourceTag: { convoDir: 'mydir', filename: 'myfile.convo.txt' } } })
-    assert.isArray(meMsg.media)
-    assert.lengthOf(meMsg.media, 1)
-    assert.isTrue(meMsg.media[0].downloadUri.endsWith('mydir/Test1'))
-  })
-})
+  describe('mediaInput', function () {
+    it('correct number of args', async function () {
+      const mi = new MediaInput({}, { SECURITY_ALLOW_UNSAFE: true })
+      await mi.setUserInput({
+        convoStep,
+        args: ['Test1'],
+        meMsg: {},
+        convo: { sourceTag: { filename: '' } }
+      })
+    })
+    it('correct number of args with buffer', async function () {
+      const mi = new MediaInput()
+      await mi.setUserInput({
+        convoStep,
+        args: ['Test1', Buffer.from('hello')],
+        meMsg: {},
+        convo: { sourceTag: { filename: '' } }
+      })
+    })
+    it('wrong number of args', async function () {
+      const mi = new MediaInput()
+      return mi.setUserInput({
+        convoStep,
+        args: ['Test1', 'Test2'],
+        meMsg: {}
+      })
+        .then(() => assert.fail('expected error'))
+        .catch((err) => {
+          assert.isDefined(err)
+          assert.instanceOf(err, Error)
+        })
+    })
+    it('empty argument list', async function () {
+      const mi = new MediaInput()
+      return mi.setUserInput({
+        convoStep,
+        meMsg: {}
+      })
+        .then(() => assert.fail('expected error'))
+        .catch((err) => {
+          assert.isDefined(err)
+          assert.instanceOf(err, Error)
+        })
+    })
+    it('should set media in message', async function () {
+      const mi = new MediaInput({}, { SECURITY_ALLOW_UNSAFE: true })
 
-describe('UserInputs.defaults.formInput', function () {
-  it('correct number of args', async function () {
-    const mi = new FormInput()
-    await mi.setUserInput({ convoStep, args: ['NAME1', 'VALUE1'], meMsg: {}, convo: { sourceTag: { filename: '' } } })
-  })
-  it('wrong number of args', async function () {
-    const mi = new FormInput()
-    return mi.setUserInput({ convoStep, args: [], meMsg: {} })
-      .then(() => assert.fail('expected error'))
-      .catch((err) => {
-        assert.isDefined(err)
-        assert.instanceOf(err, Error)
+      const meMsg = {}
+      await mi.setUserInput({
+        convoStep,
+        args: ['Test1'],
+        meMsg,
+        convo: {
+          sourceTag: {
+            convoDir: 'mydir',
+            filename: 'myfile.convo.txt'
+          }
+        }
       })
+      assert.isArray(meMsg.media)
+      assert.lengthOf(meMsg.media, 1)
+      assert.isTrue(meMsg.media[0].downloadUri.endsWith('mydir/Test1'))
+    })
   })
-  it('empty argument list', async function () {
-    const mi = new FormInput()
-    return mi.setUserInput({ convoStep, meMsg: {} })
-      .then(() => assert.fail('expected error'))
-      .catch((err) => {
-        assert.isDefined(err)
-        assert.instanceOf(err, Error)
+
+  describe('formInput', function () {
+    it('correct number of args', async function () {
+      const mi = new FormInput()
+      await mi.setUserInput({
+        convoStep,
+        args: ['NAME1', 'VALUE1'],
+        meMsg: {},
+        convo: { sourceTag: { filename: '' } }
       })
-  })
-  it('should set form boolean in message', async function () {
-    const mi = new FormInput()
+    })
+    it('wrong number of args', async function () {
+      const mi = new FormInput()
+      return mi.setUserInput({
+        convoStep,
+        args: [],
+        meMsg: {}
+      })
+        .then(() => assert.fail('expected error'))
+        .catch((err) => {
+          assert.isDefined(err)
+          assert.instanceOf(err, Error)
+        })
+    })
+    it('empty argument list', async function () {
+      const mi = new FormInput()
+      return mi.setUserInput({
+        convoStep,
+        meMsg: {}
+      })
+        .then(() => assert.fail('expected error'))
+        .catch((err) => {
+          assert.isDefined(err)
+          assert.instanceOf(err, Error)
+        })
+    })
+    it('should set form boolean in message', async function () {
+      const mi = new FormInput()
 
-    const meMsg = {}
-    await mi.setUserInput({ convoStep, args: ['NAME1'], meMsg, convo: { sourceTag: { convoDir: 'mydir', filename: 'myfile.convo.txt' } } })
-    assert.isArray(meMsg.forms)
-    assert.lengthOf(meMsg.forms, 1)
-    assert.equal(meMsg.forms[0].name, 'NAME1')
-    assert.isTrue(meMsg.forms[0].value)
-  })
-  it('should set form value in message', async function () {
-    const mi = new FormInput()
+      const meMsg = {}
+      await mi.setUserInput({
+        convoStep,
+        args: ['NAME1'],
+        meMsg,
+        convo: {
+          sourceTag: {
+            convoDir: 'mydir',
+            filename: 'myfile.convo.txt'
+          }
+        }
+      })
+      assert.isArray(meMsg.forms)
+      assert.lengthOf(meMsg.forms, 1)
+      assert.equal(meMsg.forms[0].name, 'NAME1')
+      assert.isTrue(meMsg.forms[0].value)
+    })
+    it('should set form value in message', async function () {
+      const mi = new FormInput()
 
-    const meMsg = {}
-    await mi.setUserInput({ convoStep, args: ['NAME1', 'VALUE1'], meMsg, convo: { sourceTag: { convoDir: 'mydir', filename: 'myfile.convo.txt' } } })
-    assert.isArray(meMsg.forms)
-    assert.lengthOf(meMsg.forms, 1)
-    assert.equal(meMsg.forms[0].name, 'NAME1')
-    assert.equal(meMsg.forms[0].value, 'VALUE1')
-  })
-  it('should set form values in message', async function () {
-    const mi = new FormInput()
+      const meMsg = {}
+      await mi.setUserInput({
+        convoStep,
+        args: ['NAME1', 'VALUE1'],
+        meMsg,
+        convo: {
+          sourceTag: {
+            convoDir: 'mydir',
+            filename: 'myfile.convo.txt'
+          }
+        }
+      })
+      assert.isArray(meMsg.forms)
+      assert.lengthOf(meMsg.forms, 1)
+      assert.equal(meMsg.forms[0].name, 'NAME1')
+      assert.equal(meMsg.forms[0].value, 'VALUE1')
+    })
+    it('should set form values in message', async function () {
+      const mi = new FormInput()
 
-    const meMsg = {}
-    await mi.setUserInput({ convoStep, args: ['NAME1', 'VALUE1', 'VALUE2'], meMsg, convo: { sourceTag: { convoDir: 'mydir', filename: 'myfile.convo.txt' } } })
-    assert.isArray(meMsg.forms)
-    assert.lengthOf(meMsg.forms, 1)
-    assert.equal(meMsg.forms[0].name, 'NAME1')
-    assert.isArray(meMsg.forms[0].value)
-    assert.lengthOf(meMsg.forms[0].value, 2)
-    assert.equal(meMsg.forms[0].value[0], 'VALUE1')
-    assert.equal(meMsg.forms[0].value[1], 'VALUE2')
-  })
-  it('should set multiple form value in message', async function () {
-    const mi = new FormInput()
+      const meMsg = {}
+      await mi.setUserInput({
+        convoStep,
+        args: ['NAME1', 'VALUE1', 'VALUE2'],
+        meMsg,
+        convo: {
+          sourceTag: {
+            convoDir: 'mydir',
+            filename: 'myfile.convo.txt'
+          }
+        }
+      })
+      assert.isArray(meMsg.forms)
+      assert.lengthOf(meMsg.forms, 1)
+      assert.equal(meMsg.forms[0].name, 'NAME1')
+      assert.isArray(meMsg.forms[0].value)
+      assert.lengthOf(meMsg.forms[0].value, 2)
+      assert.equal(meMsg.forms[0].value[0], 'VALUE1')
+      assert.equal(meMsg.forms[0].value[1], 'VALUE2')
+    })
+    it('should set multiple form value in message', async function () {
+      const mi = new FormInput()
 
-    const meMsg = {}
-    await mi.setUserInput({ convoStep, args: ['NAME1', 'VALUE1'], meMsg, convo: { sourceTag: { convoDir: 'mydir', filename: 'myfile.convo.txt' } } })
-    await mi.setUserInput({ convoStep, args: ['NAME2', 'VALUE2'], meMsg, convo: { sourceTag: { convoDir: 'mydir', filename: 'myfile.convo.txt' } } })
-    assert.isArray(meMsg.forms)
-    assert.lengthOf(meMsg.forms, 2)
-    assert.equal(meMsg.forms[0].name, 'NAME1')
-    assert.equal(meMsg.forms[0].value, 'VALUE1')
-    assert.equal(meMsg.forms[1].name, 'NAME2')
-    assert.equal(meMsg.forms[1].value, 'VALUE2')
+      const meMsg = {}
+      await mi.setUserInput({
+        convoStep,
+        args: ['NAME1', 'VALUE1'],
+        meMsg,
+        convo: {
+          sourceTag: {
+            convoDir: 'mydir',
+            filename: 'myfile.convo.txt'
+          }
+        }
+      })
+      await mi.setUserInput({
+        convoStep,
+        args: ['NAME2', 'VALUE2'],
+        meMsg,
+        convo: {
+          sourceTag: {
+            convoDir: 'mydir',
+            filename: 'myfile.convo.txt'
+          }
+        }
+      })
+      assert.isArray(meMsg.forms)
+      assert.lengthOf(meMsg.forms, 2)
+      assert.equal(meMsg.forms[0].name, 'NAME1')
+      assert.equal(meMsg.forms[0].value, 'VALUE1')
+      assert.equal(meMsg.forms[1].name, 'NAME2')
+      assert.equal(meMsg.forms[1].value, 'VALUE2')
+    })
   })
 })