botium-core 1.12.5 → 1.13.1

package/test/compiler/convos/csv/utterances_singlecolumn.csv

@@ -0,0 +1,3 @@
+singlecolumn
+hello
+hi

package/test/compiler/convos/csv/utterances_variable_row_len.csv

@@ -0,0 +1,3 @@
+variable_row_len,goodbye, sdf, sdf, sdf,
+hello,goodbye
+hi,,sd,fs d,f ,sdf ,ds, fsd,f ,sdf, sd,f sd, f,sd f,

package/test/compiler/convos/txt/convos_args_escape.convo.txt

@@ -0,0 +1,2 @@
+#bot
+BUTTONS Test\|1|Test\|2

package/test/convo/convos/continuefailing_timeout.convo.txt

@@ -0,0 +1,16 @@
+continuefailing
+
+#me
+Hello
+
+#bot
+Hello
+
+#me
+Hello again!
+
+#bot
+Hello again FAILING!
+
+#bot
+working again

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/convo/transcript.spec.js

@@ -47,7 +47,8 @@ describe('convo.transcript', function () {
       [Capabilities.PROJECTNAME]: 'convo.transcript',
       [Capabilities.CONTAINERMODE]: echoConnector,
       [Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]: true,
-      [Capabilities.SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS]: true
+      [Capabilities.SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS]: true,
+      [Capabilities.WAITFORBOTTIMEOUT]: 500
     }
     this.driverSkipAssertErrors = new BotDriver(myCapsSkipAssertErrors)
     this.compilerSkipAssertErrors = this.driverSkipAssertErrors.BuildCompiler()
@@ -381,4 +382,20 @@ describe('convo.transcript', function () {
       assert.isNull(err.transcript.steps[5].err)
     }
   })
+  it('should continue on failing assertion with timeout', async function () {
+    this.compilerSkipAssertErrors.ReadScript(path.resolve(__dirname, 'convos'), 'continuefailing_timeout.convo.txt')
+    assert.equal(this.compilerSkipAssertErrors.convos.length, 1)
+
+    try {
+      await this.compilerSkipAssertErrors.convos[0].Run(this.containerSkipAssertErrors)
+      assert.fail('expected error')
+    } catch (err) {
+      assert.isDefined(err.cause)
+      assert.equal(err.cause.message, 'continuefailing/Line 12: Bot response (on Line 9: #me - Hello again!) "Hello again!" expected to match "Hello again FAILING!",\ncontinuefailing/Line 15: error waiting for bot - Bot did not respond within 500ms')
+      assert.equal(err.cause.context.errors.length, 2)
+
+      assert.isDefined(err.transcript)
+      assert.equal(err.transcript.steps.length, 5)
+    }
+  })
 })

package/test/logichooks/hookfromsrc.spec.js

@@ -69,7 +69,7 @@ describe('logichooks.hookfromsrc', function () {
       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'))
+      assert.isTrue(err.message.includes('Line 6: assertion error - Script assertConvoStep is not valid'))
     }
   })
 })

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

@@ -263,3 +263,50 @@ describe('scripting.asserters.buttonsCountAsserter', function () {
     })
   })
 })
+
+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 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'])
+    }
+  })
+})

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

@@ -243,3 +243,42 @@ describe('scripting.asserters.cardsCountAsserter', function () {
     })
   })
 })
+
+describe('scripting.asserters.cardsNormalizeAsserter', function () {
+  beforeEach(async function () {
+    this.cardsAsserter = new CardsAsserter({
+      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: {
+        cards: [{ text: '<html><h1>test html header</h1><p>test html text</p>' }]
+      }
+    })
+  })
+
+  it('should fail with normalized text', async function () {
+    try {
+      await this.cardsAsserter.assertConvoStep({
+        convoStep: { stepTag: 'test' },
+        args: ['Test Html header1      test html text'],
+        botMsg: {
+          cards: [{ 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 card(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'])
+    }
+  })
+})

package/test/scripting/txt/decompile.spec.js

@@ -634,6 +634,30 @@ CARDS text of card2
 #me
 some text
 CUSTOMINPUT arg1|arg2
+`
+    )
+  })
+  it('should escape pipe in args', async function () {
+    const scriptingProvider = new ScriptingProvider(DefaultCapabilities)
+    await scriptingProvider.Build()
+
+    const convo = {
+      header: {
+        name: 'test convo'
+      },
+      conversation: [
+        {
+          sender: 'me',
+          userInputs: [{ name: 'CUSTOMINPUT', args: ['arg|1', 'arg|2'] }]
+        }
+      ]
+    }
+
+    const script = scriptingProvider.Decompile([convo], 'SCRIPTING_FORMAT_TXT')
+    assert.equal(script, `test convo
+
+#me
+CUSTOMINPUT arg\\|1|arg\\|2
 `
     )
   })