botium-core 1.13.2 → 1.13.3

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

@@ -4,94 +4,60 @@ const CardsCountAsserter = require('../../../src/scripting/logichook/asserter/Ca
 const CardsCountRecAsserter = require('../../../src/scripting/logichook/asserter/CardsCountRecAsserter')
 
 describe('scripting.asserters.cardsAsserter', function () {
-  beforeEach(async function () {
-    this.cardsAsserter = new CardsAsserter({
-      Match: (botresponse, utterance) => botresponse.toLowerCase().indexOf(utterance.toLowerCase()) >= 0
-    }, {})
-  })
-
-  it('should succeed on existing card text', async function () {
-    await this.cardsAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['cardtext'],
-      botMsg: {
-        cards: [
-          {
-            text: 'cardtext'
-          }
-        ]
-      }
+  describe('cardsAsserter', function () {
+    beforeEach(async function () {
+      this.cardsAsserter = new CardsAsserter({
+        Match: (botresponse, utterance) => botresponse.toLowerCase().indexOf(utterance.toLowerCase()) >= 0
+      }, {})
     })
-  })
-  it('should succeed on existing card subtext', async function () {
-    await this.cardsAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['cardtext'],
-      botMsg: {
-        cards: [
-          {
-            subtext: 'cardtext'
-          }
-        ]
-      }
-    })
-  })
-  it('should succeed on existing card content', async function () {
-    await this.cardsAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['cardtext'],
-      botMsg: {
-        cards: [
-          {
-            content: 'cardtext'
-          }
-        ]
-      }
+
+    it('should succeed on existing card text', async function () {
+      await this.cardsAsserter.assertConvoStep({
+        convoStep: { stepTag: 'test' },
+        args: ['cardtext'],
+        botMsg: {
+          cards: [
+            {
+              text: 'cardtext'
+            }
+          ]
+        }
+      })
     })
-  })
-  it('should succeed on multiple existing cards', async function () {
-    await this.cardsAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['cardtext1', 'cardtext2'],
-      botMsg: {
-        cards: [
-          {
-            text: 'cardtext1'
-          },
-          {
-            text: 'cardtext2'
-          }
-        ]
-      }
+    it('should succeed on existing card subtext', async function () {
+      await this.cardsAsserter.assertConvoStep({
+        convoStep: { stepTag: 'test' },
+        args: ['cardtext'],
+        botMsg: {
+          cards: [
+            {
+              subtext: 'cardtext'
+            }
+          ]
+        }
+      })
     })
-  })
-  it('should fail on missing card', async function () {
-    try {
+    it('should succeed on existing card content', async function () {
       await this.cardsAsserter.assertConvoStep({
         convoStep: { stepTag: 'test' },
-        args: ['missingcard'],
-        botMsg: { }
+        args: ['cardtext'],
+        botMsg: {
+          cards: [
+            {
+              content: 'cardtext'
+            }
+          ]
+        }
       })
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Expected card(s) with text "missingcard"') > 0)
-      assert.isNotNull(err.context)
-      assert.isNotNull(err.context.cause)
-      assert.isArray(err.context.cause.expected)
-      assert.deepEqual(err.context.cause.expected, ['missingcard'])
-      assert.deepEqual(err.context.cause.actual, [])
-      assert.deepEqual(err.context.cause.diff, ['missingcard'])
-    }
-  })
-  it('should fail on one missing card', async function () {
-    try {
+    })
+    it('should succeed on multiple existing cards', async function () {
       await this.cardsAsserter.assertConvoStep({
         convoStep: { stepTag: 'test' },
-        args: ['existingcard', 'missingcard'],
+        args: ['cardtext1', 'cardtext2'],
         botMsg: {
           cards: [
             {
-              text: 'existingcard'
+              text: 'cardtext1'
             },
             {
               text: 'cardtext2'
@@ -99,92 +65,96 @@ describe('scripting.asserters.cardsAsserter', function () {
           ]
         }
       })
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Expected card(s) with text "missingcard"') > 0)
-      assert.isNotNull(err.context)
-      assert.isNotNull(err.context.cause)
-      assert.isArray(err.context.cause.expected)
-      assert.isNotTrue(err.context.cause.not)
-      assert.deepEqual(err.context.cause.expected, ['existingcard', 'missingcard'])
-      assert.deepEqual(err.context.cause.actual, ['existingcard', 'cardtext2'])
-      assert.deepEqual(err.context.cause.diff, ['missingcard'])
-    }
-  })
-  it('should succeed on unexpected card text', async function () {
-    await this.cardsAsserter.assertNotConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['cardtext1'],
-      botMsg: {
-        cards: [
-          {
-            text: 'cardtext'
+    })
+    it('should fail on missing card', async function () {
+      try {
+        await this.cardsAsserter.assertConvoStep({
+          convoStep: { stepTag: 'test' },
+          args: ['missingcard'],
+          botMsg: {}
+        })
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Expected card(s) with text "missingcard"') > 0)
+        assert.isNotNull(err.context)
+        assert.isNotNull(err.context.cause)
+        assert.isArray(err.context.cause.expected)
+        assert.deepEqual(err.context.cause.expected, ['missingcard'])
+        assert.deepEqual(err.context.cause.actual, [])
+        assert.deepEqual(err.context.cause.diff, ['missingcard'])
+      }
+    })
+    it('should fail on one missing card', async function () {
+      try {
+        await this.cardsAsserter.assertConvoStep({
+          convoStep: { stepTag: 'test' },
+          args: ['existingcard', 'missingcard'],
+          botMsg: {
+            cards: [
+              {
+                text: 'existingcard'
+              },
+              {
+                text: 'cardtext2'
+              }
+            ]
           }
-        ]
+        })
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Expected card(s) with text "missingcard"') > 0)
+        assert.isNotNull(err.context)
+        assert.isNotNull(err.context.cause)
+        assert.isArray(err.context.cause.expected)
+        assert.isNotTrue(err.context.cause.not)
+        assert.deepEqual(err.context.cause.expected, ['existingcard', 'missingcard'])
+        assert.deepEqual(err.context.cause.actual, ['existingcard', 'cardtext2'])
+        assert.deepEqual(err.context.cause.diff, ['missingcard'])
       }
     })
-  })
-  it('should fail on one unexpected card', async function () {
-    try {
+    it('should succeed on unexpected card text', async function () {
       await this.cardsAsserter.assertNotConvoStep({
         convoStep: { stepTag: 'test' },
-        args: ['existingcard', 'missingcard'],
+        args: ['cardtext1'],
         botMsg: {
           cards: [
             {
-              text: 'existingcard'
-            },
-            {
-              text: 'cardtext2'
+              text: 'cardtext'
             }
           ]
         }
       })
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Not expected card(s) with text "existingcard"') > 0)
-      assert.isNotNull(err.context)
-      assert.isNotNull(err.context.cause)
-      assert.isArray(err.context.cause.expected)
-      assert.isTrue(err.context.cause.not)
-      assert.deepEqual(err.context.cause.expected, ['existingcard', 'missingcard'])
-      assert.deepEqual(err.context.cause.actual, ['existingcard', 'cardtext2'])
-      assert.deepEqual(err.context.cause.diff, ['existingcard'])
-    }
-  })
-  it('should succeed on existing card if has no arg', async function () {
-    await this.cardsAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: [],
-      botMsg: {
-        cards: [
-          {
-            text: 'test'
+    })
+    it('should fail on one unexpected card', async function () {
+      try {
+        await this.cardsAsserter.assertNotConvoStep({
+          convoStep: { stepTag: 'test' },
+          args: ['existingcard', 'missingcard'],
+          botMsg: {
+            cards: [
+              {
+                text: 'existingcard'
+              },
+              {
+                text: 'cardtext2'
+              }
+            ]
           }
-        ]
+        })
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Not expected card(s) with text "existingcard"') > 0)
+        assert.isNotNull(err.context)
+        assert.isNotNull(err.context.cause)
+        assert.isArray(err.context.cause.expected)
+        assert.isTrue(err.context.cause.not)
+        assert.deepEqual(err.context.cause.expected, ['existingcard', 'missingcard'])
+        assert.deepEqual(err.context.cause.actual, ['existingcard', 'cardtext2'])
+        assert.deepEqual(err.context.cause.diff, ['existingcard'])
       }
     })
-  })
-  it('should fail on no card if has no arg', async function () {
-    try {
-      await this.cardsAsserter.assertConvoStep({ convoStep: { stepTag: 'test' } })
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Expected some card(s)') > 0)
-      assert.isNotNull(err.context)
-      assert.isNotNull(err.context.cause)
-      assert.isArray(err.context.cause.expected)
-      assert.isNotTrue(err.context.cause.not)
-      assert.deepEqual(err.context.cause.expected, [])
-      assert.deepEqual(err.context.cause.actual, [])
-    }
-  })
-  it('should succeed on not existing card if has no arg and negated', async function () {
-    await this.cardsAsserter.assertNotConvoStep({ convoStep: { stepTag: 'test' } })
-  })
-  it('should fail on card if has no arg and negated', async function () {
-    try {
-      await this.cardsAsserter.assertNotConvoStep({
+    it('should succeed on existing card if has no arg', async function () {
+      await this.cardsAsserter.assertConvoStep({
         convoStep: { stepTag: 'test' },
         args: [],
         botMsg: {
@@ -195,90 +165,122 @@ describe('scripting.asserters.cardsAsserter', function () {
           ]
         }
       })
-      assert.fail('should have failed')
-    } catch (err) {
-      assert.isTrue(err.message.indexOf('Not expected card(s) with text "test"') > 0)
-      assert.isNotNull(err.context)
-      assert.isNotNull(err.context.cause)
-      assert.isArray(err.context.cause.expected)
-      assert.isTrue(err.context.cause.not)
-      assert.deepEqual(err.context.cause.expected, [])
-      assert.deepEqual(err.context.cause.actual, ['test'])
-    }
-  })
-})
-describe('scripting.asserters.cardsCountAsserter', function () {
-  beforeEach(async function () {
-    this.cardsCountAsserter = new CardsCountAsserter({}, {})
-    this.cardsCountRecAsserter = new CardsCountRecAsserter({}, {})
-  })
-
-  it('should succeed on no args with one card', async function () {
-    await this.cardsCountAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: [],
-      botMsg: {
-        cards: [{ text: 'test.jpg' }]
+    })
+    it('should fail on no card if has no arg', async function () {
+      try {
+        await this.cardsAsserter.assertConvoStep({ convoStep: { stepTag: 'test' } })
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Expected some card(s)') > 0)
+        assert.isNotNull(err.context)
+        assert.isNotNull(err.context.cause)
+        assert.isArray(err.context.cause.expected)
+        assert.isNotTrue(err.context.cause.not)
+        assert.deepEqual(err.context.cause.expected, [])
+        assert.deepEqual(err.context.cause.actual, [])
       }
     })
-  })
-
-  it('should succeed on >=3 with rec cards', async function () {
-    await this.cardsCountRecAsserter.assertConvoStep({
-      convoStep: { stepTag: 'test' },
-      args: ['>=3'],
-      botMsg: {
-        cards: [
-          {
-            text: 'card1',
+    it('should succeed on not existing card if has no arg and negated', async function () {
+      await this.cardsAsserter.assertNotConvoStep({ convoStep: { stepTag: 'test' } })
+    })
+    it('should fail on card if has no arg and negated', async function () {
+      try {
+        await this.cardsAsserter.assertNotConvoStep({
+          convoStep: { stepTag: 'test' },
+          args: [],
+          botMsg: {
             cards: [
               {
-                text: 'card2',
-                cards: [{ text: 'card3' }]
+                text: 'test'
               }
             ]
           }
-        ]
+        })
+        assert.fail('should have failed')
+      } catch (err) {
+        assert.isTrue(err.message.indexOf('Not expected card(s) with text "test"') > 0)
+        assert.isNotNull(err.context)
+        assert.isNotNull(err.context.cause)
+        assert.isArray(err.context.cause.expected)
+        assert.isTrue(err.context.cause.not)
+        assert.deepEqual(err.context.cause.expected, [])
+        assert.deepEqual(err.context.cause.actual, ['test'])
       }
     })
   })
-})
+  describe('cardsCountAsserter', function () {
+    beforeEach(async function () {
+      this.cardsCountAsserter = new CardsCountAsserter({}, {})
+      this.cardsCountRecAsserter = new CardsCountRecAsserter({}, {})
+    })
 
-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 on no args with one card', async function () {
+      await this.cardsCountAsserter.assertConvoStep({
+        convoStep: { stepTag: 'test' },
+        args: [],
+        botMsg: {
+          cards: [{ text: 'test.jpg' }]
+        }
+      })
+    })
 
-  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 succeed on >=3 with rec cards', async function () {
+      await this.cardsCountRecAsserter.assertConvoStep({
+        convoStep: { stepTag: 'test' },
+        args: ['>=3'],
+        botMsg: {
+          cards: [
+            {
+              text: 'card1',
+              cards: [
+                {
+                  text: 'card2',
+                  cards: [{ text: 'card3' }]
+                }
+              ]
+            }
+          ]
+        }
+      })
     })
   })
 
-  it('should fail with normalized text', async function () {
-    try {
+  describe('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 header1      test html text'],
+        args: ['Test Html header      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'])
-    }
+    })
+
+    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/asserters/convos/wer_threshold_nok.yml

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

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

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

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

@@ -8,6 +8,40 @@ const asserterWithGlobal = new IntentConfidenceAsserter(null, null, { expectedMi
 const asserterWithoutGlobal = new IntentConfidenceAsserter(null)
 
 describe('scripting.asserters.intentConfidenceAsserter', function () {
+  const _assert = (useWithGlobal, expected, found, negative) => {
+    const steptag = `UseWithGlobal: ${useWithGlobal}, expected: ${util.inspect(expected)}, found: ${util.inspect(found)}`
+    const promise = (useWithGlobal ? asserterWithGlobal : asserterWithoutGlobal).assertConvoStep(_params(
+      expected,
+      found,
+      steptag
+    ))
+
+    if (negative) {
+      return assert.isRejected(promise)
+    } else {
+      return assert.isFulfilled(promise)
+    }
+  }
+
+  const _params = (expected, found, steptag) => {
+    found = found / 100
+    return {
+      convoStep: {
+        stepTag: steptag
+      },
+      args: expected ? [expected] : [],
+      botMsg: {
+        nlp: found
+          ? {
+              intent: {
+                name: 'not_important',
+                confidence: found
+              }
+            }
+          : null
+      }
+    }
+  }
   // useWithGlobal, expected (minimum), found, negative (expect reject)
   const cases = [
     [true, null, null, true],
@@ -40,38 +74,3 @@ describe('scripting.asserters.intentConfidenceAsserter', function () {
     )
   })
 })
-
-const _assert = (useWithGlobal, expected, found, negative) => {
-  const steptag = `UseWithGlobal: ${useWithGlobal}, expected: ${util.inspect(expected)}, found: ${util.inspect(found)}`
-  const promise = (useWithGlobal ? asserterWithGlobal : asserterWithoutGlobal).assertConvoStep(_params(
-    expected,
-    found,
-    steptag
-  ))
-
-  if (negative) {
-    return assert.isRejected(promise)
-  } else {
-    return assert.isFulfilled(promise)
-  }
-}
-
-const _params = (expected, found, steptag) => {
-  found = found / 100
-  return {
-    convoStep: {
-      stepTag: steptag
-    },
-    args: expected ? [expected] : [],
-    botMsg: {
-      nlp: found
-        ? {
-            intent: {
-              name: 'not_important',
-              confidence: found
-            }
-          }
-        : null
-    }
-  }
-}