botium-core 1.13.5 → 1.13.6

package/src/scripting/logichook/asserter/WerAsserter.js

@@ -6,12 +6,12 @@ module.exports = class WerAsserter {
   constructor (context, caps = {}) {
     this.context = context
     this.caps = caps
-    this.name = 'WerAsserter'
+    this.name = 'Word Error Rate Asserter'
   }
 
   assertConvoStep ({ convo, convoStep, args, botMsg }) {
     if (!args || args.length < 1) {
-      return Promise.reject(new BotiumError(`${convoStep.stepTag}: WerAsserter Missing argument`,
+      return Promise.reject(new BotiumError(`${convoStep.stepTag}: ${this.name} - no argument given`,
         {
           type: 'asserter',
           subtype: 'wrong parameters',
@@ -21,7 +21,7 @@ module.exports = class WerAsserter {
       ))
     }
     if (args.length > 2) {
-      return Promise.reject(new BotiumError(`${convoStep.stepTag}: WerAsserter Too much argument "${args}"`,
+      return Promise.reject(new BotiumError(`${convoStep.stepTag}: ${this.name} - too many arguments "${args}"`,
         {
           type: 'asserter',
           subtype: 'wrong parameters',
@@ -32,12 +32,14 @@ module.exports = class WerAsserter {
     }
 
     const utterance = args[0]
-    const threshold = args[1]
+    const threshold = ([',', '.'].find(p => `${args[1]}`.includes(p)) ? parseFloat(args[1]) : parseInt(args[1]) / 100).toFixed(2)
 
-    const wer = speechScorer.wordErrorRate(botMsg.messageText, utterance)
+    const wer = speechScorer.wordErrorRate(botMsg.messageText, utterance).toFixed(2)
     if (wer > threshold) {
+      const _toPercent = (s) => `${(s * 100).toFixed(0)}%`
+
       return Promise.reject(new BotiumError(
-        `${convoStep.stepTag}: Word error rate ${wer} > ${threshold} for ${utterance}`,
+        `${convoStep.stepTag}: Word Error Rate (${_toPercent(wer)}) higher than accepted (${_toPercent(threshold)})`,
         {
           type: 'asserter',
           source: this.name,
@@ -47,8 +49,8 @@ module.exports = class WerAsserter {
             }
           },
           cause: {
-            expected: `Word error rate <= ${threshold}`,
-            actual: `Word error rate = ${wer}`
+            expected: `<=${_toPercent(threshold)}`,
+            actual: `${_toPercent(wer)}`
           }
         }
       ))

package/test/convo/transcript.spec.js

@@ -287,11 +287,11 @@ describe('convo.transcript', function () {
 
       assert.equal(err.transcript.err.context.input.messageText, 'Hello')
       assert.equal(err.transcript.err.context.errors[0].type, 'asserter')
-      assert.equal(err.transcript.err.context.errors[0].source, 'TextMatchAsserter')
+      assert.equal(err.transcript.err.context.errors[0].source, 'Text Match Asserter')
       assert.equal(err.transcript.err.context.errors[1].type, 'asserter')
-      assert.equal(err.transcript.err.context.errors[1].source, 'ButtonsAsserter')
+      assert.equal(err.transcript.err.context.errors[1].source, 'Buttons Asserter')
       assert.equal(err.transcript.err.context.errors[2].type, 'asserter')
-      assert.equal(err.transcript.err.context.errors[2].source, 'ButtonsAsserter')
+      assert.equal(err.transcript.err.context.errors[2].source, 'Buttons Asserter')
     }
   })
   it('should throw simple error with multiple asserting errors if its enabled and assertConvoEnd fail', async function () {
@@ -317,11 +317,11 @@ describe('convo.transcript', function () {
 
       assert.equal(err.transcript.err.context.input.messageText, 'Hello')
       assert.equal(err.transcript.err.context.errors[0].type, 'asserter')
-      assert.equal(err.transcript.err.context.errors[0].source, 'TextMatchAsserter')
+      assert.equal(err.transcript.err.context.errors[0].source, 'Text Match Asserter')
       assert.equal(err.transcript.err.context.errors[1].type, 'asserter')
-      assert.equal(err.transcript.err.context.errors[1].source, 'ButtonsAsserter')
+      assert.equal(err.transcript.err.context.errors[1].source, 'Buttons Asserter')
       assert.equal(err.transcript.err.context.errors[2].type, 'asserter')
-      assert.equal(err.transcript.err.context.errors[2].source, 'ButtonsAsserter')
+      assert.equal(err.transcript.err.context.errors[2].source, 'Buttons Asserter')
       assert.equal(err.transcript.err.context.errors[3].type, 'asserter')
       assert.equal(err.transcript.err.context.errors[3].source, 'assertConvoEnd')
     }

package/test/scripting/asserters/convos/wer_threshold_nok_percentage.yml

@@ -0,0 +1,7 @@
+convos:
+  - name: wer_threshold_nok
+    steps:
+      - me:
+          - test 123
+      - bot:
+          - TEXT_WER tast 123|10

package/test/scripting/asserters/convos/wer_threshold_ok_percentage.yml

@@ -0,0 +1,7 @@
+convos:
+  - name: wer_threshold_ok
+    steps:
+      - me:
+          - test 123
+      - bot:
+          - TEXT_WER tast 123|60

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

@@ -20,10 +20,9 @@ describe('scripting.asserters.entityContentAsserter', function () {
       })
       assert.fail('should have failed')
     } catch (err) {
-      assert.isTrue(err.message.indexOf('EntityContentAsserter Missing argument') > 0)
+      assert.isTrue(err.message.indexOf('Missing argument') > 0)
       assert.isNotNull(err.context)
       assert.equal(err.context.type, 'asserter')
-      assert.equal(err.context.source, 'EntityContentAsserter')
     }
   })
 
@@ -36,10 +35,9 @@ describe('scripting.asserters.entityContentAsserter', function () {
       })
       assert.fail('should have failed')
     } catch (err) {
-      assert.isTrue(err.message.indexOf('EntityContentAsserter Missing argument') > 0)
+      assert.isTrue(err.message.indexOf('Missing argument') > 0)
       assert.isNotNull(err.context)
       assert.equal(err.context.type, 'asserter')
-      assert.equal(err.context.source, 'EntityContentAsserter')
     }
   })
 
@@ -55,7 +53,6 @@ describe('scripting.asserters.entityContentAsserter', function () {
       assert.isTrue(err.message.indexOf('Expected entity "something" but found nothing') > 0)
       assert.isNotNull(err.context)
       assert.equal(err.context.type, 'asserter')
-      assert.equal(err.context.source, 'EntityContentAsserter')
     }
   })
 
@@ -88,7 +85,6 @@ describe('scripting.asserters.entityContentAsserter', function () {
       assert.isTrue(err.message.indexOf('test: Missing entity content: [ \'something_value\' ] of entity "something"') >= 0)
       assert.isNotNull(err.context)
       assert.equal(err.context.type, 'asserter')
-      assert.equal(err.context.source, 'EntityContentAsserter')
       assert.isNotNull(err.context.cause)
       assert.equal(err.context.cause.entity, 'something')
       assert.deepEqual(err.context.cause.expected, ['something_value'])
@@ -126,7 +122,6 @@ describe('scripting.asserters.entityContentAsserter', function () {
       assert.isTrue(err.message.indexOf('test: Missing entity content: [ \'entity1_value1\', \'entity1_value3\' ] of entity "entity1"') >= 0)
       assert.isNotNull(err.context)
       assert.equal(err.context.type, 'asserter')
-      assert.equal(err.context.source, 'EntityContentAsserter')
       assert.isNotNull(err.context.cause)
       assert.equal(err.context.cause.entity, 'entity1')
       assert.deepEqual(err.context.cause.expected, ['entity1_value1', 'entity1_value1', 'entity1_value3'])

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

@@ -62,7 +62,7 @@ const _assert = (expected, found) => {
   ))
 
   if (!expected) {
-    return assert.isRejected(promise, `${steptag}: IntentAsserter Missing argument`)
+    return assert.isRejected(promise, `${steptag}: NLU Intent Asserter Missing argument`)
   } else if (!found) {
     return assert.isRejected(promise, `${steptag}: Expected intent "${expected}" but found nothing`)
   } else if (expected !== found) {

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

@@ -278,7 +278,7 @@ describe('scripting.asserters.jsonPathAsserter', function () {
         })
         assert.fail('should have failed')
       } catch (err) {
-        assert.isTrue(err.message.indexOf('JsonPathAsserter 0 arguments expected') > 0)
+        assert.isTrue(err.message.indexOf('0 arguments expected') > 0)
       }
     })
     it('should succeed on existing jsonpath from pathPattern', async function () {

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

@@ -27,16 +27,36 @@ describe('scripting.asserters.werAsserter', function () {
     this.container && await this.container.Clean()
   })
 
-  it('ok', async function () {
-    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_ok.yml'))
+  it('ok (float)', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_ok_float.yml'))
 
     this.compiler.ExpandScriptingMemoryToConvos()
     assert.equal(this.compiler.convos.length, 1)
     await this.compiler.convos[0].Run(this.container)
   })
+  it('ok (percentage)', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_ok_percentage.yml'))
 
-  it('nok', async function () {
-    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_nok.yml'))
+    this.compiler.ExpandScriptingMemoryToConvos()
+    assert.equal(this.compiler.convos.length, 1)
+    await this.compiler.convos[0].Run(this.container)
+  })
+
+  it('nok (float)', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_nok_float.yml'))
+
+    this.compiler.ExpandScriptingMemoryToConvos()
+    assert.equal(this.compiler.convos.length, 1)
+
+    try {
+      await this.compiler.convos[0].Run(this.container)
+      assert.fail('expected error')
+    } catch (err) {
+      assert.equal(err.message, 'wer_threshold_nok/Line 2: assertion error - Line 2: Word Error Rate (50%) higher than accepted (10%)')
+    }
+  })
+  it('nok (percentage)', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_nok_percentage.yml'))
 
     this.compiler.ExpandScriptingMemoryToConvos()
     assert.equal(this.compiler.convos.length, 1)
@@ -45,7 +65,7 @@ describe('scripting.asserters.werAsserter', function () {
       await this.compiler.convos[0].Run(this.container)
       assert.fail('expected error')
     } catch (err) {
-      assert.equal(err.message, 'wer_threshold_nok/Line 2: assertion error - Line 2: Word error rate 0.5 > 0.1 for tast 123')
+      assert.equal(err.message, 'wer_threshold_nok/Line 2: assertion error - Line 2: Word Error Rate (50%) higher than accepted (10%)')
     }
   })
 })

package/test/scripting/matching/matchingmode.spec.js

@@ -306,7 +306,7 @@ describe('scripting.matching.matchingmode', function () {
     })
   })
 
-  describe('wer.lowthreshold', function () {
+  describe('wer.lowthreshold (float)', function () {
     beforeEach(async function () {
       const myCaps = {
         [Capabilities.PROJECTNAME]: 'matching.matchingmode',
@@ -326,8 +326,28 @@ describe('scripting.matching.matchingmode', function () {
       assert.isFalse(this.compiler.Match('test 123', 'tast 123'))
     })
   })
+  describe('wer.lowthreshold (percentage)', function () {
+    beforeEach(async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'matching.matchingmode',
+        [Capabilities.CONTAINERMODE]: echoConnector,
+        [Capabilities.SCRIPTING_MATCHING_MODE]: 'wer',
+        [Capabilities.SCRIPTING_MATCHING_MODE_ARGS]: [10]
+      }
+      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 not match because of low threshold', async function () {
+      assert.isFalse(this.compiler.Match('test 123', 'tast 123'))
+    })
+  })
 
-  describe('wer.highthreshold', function () {
+  describe('wer.highthreshold (float)', function () {
     beforeEach(async function () {
       const myCaps = {
         [Capabilities.PROJECTNAME]: 'matching.matchingmode',
@@ -343,6 +363,26 @@ describe('scripting.matching.matchingmode', function () {
       this.container && await this.container.Clean()
     })
 
+    it('should match because of high threshold', async function () {
+      assert.isTrue(this.compiler.Match('test 123', 'tast 123'))
+    })
+  })
+  describe('wer.highthreshold (percentage)', function () {
+    beforeEach(async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'matching.matchingmode',
+        [Capabilities.CONTAINERMODE]: echoConnector,
+        [Capabilities.SCRIPTING_MATCHING_MODE]: 'wer',
+        [Capabilities.SCRIPTING_MATCHING_MODE_ARGS]: [60]
+      }
+      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 match because of high threshold', async function () {
       assert.isTrue(this.compiler.Match('test 123', 'tast 123'))
     })

package/test/scripting/scriptingModificator.spec.js

@@ -55,9 +55,8 @@ describe('scriptingModificator.assertions', function () {
       })
       assert.fail('should have failed')
     } catch (err) {
-      assert.isTrue(err.message.indexOf('Expected asserter IntentAsserter with args "test1" to fail') > 0)
+      assert.isTrue(err.message.indexOf('Expected asserter NLU Intent Asserter with args "test1" to fail') > 0)
       assert.isNotNull(err.context)
-      assert.equal(err.context.source, 'IntentAsserter')
     }
   })
 })