botium-core 1.13.6 → 1.13.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botium-core",
-  "version": "1.13.6",
+  "version": "1.13.8",
   "description": "The Selenium for Chatbots",
   "main": "index.js",
   "module": "dist/botium-es.js",

package/src/scripting/ScriptingProvider.js

@@ -885,12 +885,11 @@ module.exports = class ScriptingProvider {
       // drop unwanted convos
       convoFilter: null
     }, options)
-    const context = { count: 0 }
     const expandedConvos = []
     debug(`ExpandConvos - Using utterances expansion mode: ${this.caps[Capabilities.SCRIPTING_UTTEXPANSION_MODE]}`)
     this.convos.forEach((convo) => {
       convo.expandPartialConvos()
-      for (const expanded of this._expandConvo(convo, options, context)) {
+      for (const expanded of this._expandConvo(convo, options, {})) {
         expanded.header.assertionCount = this.GetAssertionCount(expanded)
         if (options.justHeader) {
           const ConvoWithOnlyHeader = {
@@ -922,10 +921,9 @@ module.exports = class ScriptingProvider {
     // creating a nested generator, calling the other.
     // We hope this.convos does not changes while this iterator is used
     const _convosIterable = function * (options) {
-      const context = { count: 0 }
       for (const convo of this.convos) {
         convo.expandPartialConvos()
-        yield * this._expandConvo(convo, options, context)
+        yield * this._expandConvo(convo, options, {})
       }
     }.bind(this)
 
@@ -1122,11 +1120,6 @@ module.exports = class ScriptingProvider {
     } else {
       const expanded = Object.assign(_.cloneDeep(currentConvo), { conversation: _.cloneDeep(convoStepsStack) })
       if (!options.convoFilter || options.convoFilter(expanded)) {
-        context.count++
-        const logPerEntry = context.count < 10 ? 1 : context.count < 100 ? 10 : context.count < 1000 ? 100 : context.count < 10000 ? 1000 : 10000
-        if (context.count % logPerEntry === 0) {
-          debug(`Convo #${context.count} expanded (${expanded.header.name})`)
-        }
         yield expanded
       }
     }

package/src/scripting/logichook/LogicHookUtils.js

@@ -111,19 +111,19 @@ module.exports = class LogicHookUtils {
 
     // 1 gives possibility to use default asserter as global asserter
     if (hookType === 'asserter') {
-      const asserter = DEFAULT_ASSERTERS.find(asserter => src === asserter.className)
+      const asserter = DEFAULT_ASSERTERS.find(asserter => src === asserter.className || src === asserter.name)
       if (asserter) {
         return new (asserter.Class)({ ref, ...this.buildScriptContext }, this.caps, args)
       }
     }
     if (hookType === 'logichook') {
-      const lh = DEFAULT_LOGIC_HOOKS.find(lh => src === lh.className)
+      const lh = DEFAULT_LOGIC_HOOKS.find(lh => src === lh.className || src === lh.name)
       if (lh) {
         return new (lh.Class)({ ref, ...this.buildScriptContext }, this.caps, args)
       }
     }
     if (hookType === 'userinput') {
-      const ui = DEFAULT_USER_INPUTS.find(ui => src === ui.className)
+      const ui = DEFAULT_USER_INPUTS.find(ui => src === ui.className || src === ui.name)
       if (ui) {
         return new (ui.Class)({ ref, ...this.buildScriptContext }, this.caps, args)
       }

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

@@ -126,7 +126,12 @@ module.exports = class JsonPathAsserter {
         ))
       }
     }
-    if (assert) {
+
+    if (this.globalArgs && this.globalArgs.checkExistanceOnEmptyAssert) {
+      if (!assert) return Promise.resolve()
+    }
+
+    if (!_.isNil(assert)) {
       const actual = (_.isArray(jsonPathValues) && jsonPathValues.length === 1) ? jsonPathValues[0] : jsonPathValues
 
       let matchFn = this.context.Match
@@ -134,10 +139,10 @@ module.exports = class JsonPathAsserter {
         matchFn = getMatchFunction(this.globalArgs.matchingMode)
       }
 
-      const match = jsonPathValues.find(a => matchFn(a, assert))
+      const match = !_.isNil(jsonPathValues.find(a => matchFn(a, assert)))
 
       if (not && match) {
-        return Promise.reject(new BotiumError(`${convoStep.stepTag}: Not expected: ${toString(actual)} in jsonPath ${path}"`,
+        return Promise.reject(new BotiumError(`${convoStep.stepTag}: Not expected: "${actual === '' ? '<empty>' : toString(actual)}" in jsonPath ${path}"`,
           {
             type: 'asserter',
             source: this.name,
@@ -158,7 +163,7 @@ module.exports = class JsonPathAsserter {
         ))
       }
       if (!not && !match) {
-        return Promise.reject(new BotiumError(`${convoStep.stepTag}: Expected: ${assert} in jsonPath ${path}: Actual: ${toString(actual)}`,
+        return Promise.reject(new BotiumError(`${convoStep.stepTag}: Expected: "${assert === '' ? '<empty>' : assert}" in jsonPath ${path}, actual: ${actual === '' ? '<empty>' : toString(actual)}`,
           {
             type: 'asserter',
             source: this.name,

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

@@ -7,16 +7,78 @@ describe('scripting.asserters.jsonPathAsserter', function () {
   describe('jsonPathAsserter', function () {
     beforeEach(async function () {
       this.jsonPathAsserter = new JsonPathAsserter({
-        Match: (botresponse, utterance) => botresponse.toLowerCase().indexOf(utterance.toLowerCase()) >= 0
+        Match: (botresponse, utterance) => {
+          return botresponse.toLowerCase().indexOf(utterance.toLowerCase()) >= 0
+        }
       }, {})
       this.jsonPathAsserterWildcard = new JsonPathAsserter({
         Match: getMatchFunction('wildcardIgnoreCase')
       }, {})
+      this.jsonPathAsserterEquals = new JsonPathAsserter({
+        Match: getMatchFunction('equals')
+      }, {})
       this.jsonPathAsserterGlobalArgs = new JsonPathAsserter({
         Match: (botresponse, utterance) => botresponse.toLowerCase().indexOf(utterance.toLowerCase()) >= 0
       }, {}, { path: '$.test' })
     })
 
+    describe('empty string', function () {
+      it('should succeed if both is empty', async function () {
+        await this.jsonPathAsserterWildcard.assertConvoStep({
+          convoStep: { stepTag: 'test' },
+          args: ['$.test', ''],
+          botMsg: {
+            sourceData: {
+              test: ''
+            }
+          }
+        })
+      })
+      it('should succeed if expected is empty, and asserter is negated', async function () {
+        await this.jsonPathAsserterEquals.assertNotConvoStep({
+          convoStep: { stepTag: 'test' },
+          args: ['$.test', ''],
+          botMsg: {
+            sourceData: {
+              test: 'something but not empty string'
+            }
+          }
+        })
+      })
+      it('should fail if expected is not empty', async function () {
+        try {
+          await this.jsonPathAsserterWildcard.assertConvoStep({
+            convoStep: { stepTag: 'test' },
+            args: ['$.test', 'something but not empty string'],
+            botMsg: {
+              sourceData: {
+                test: ''
+              }
+            }
+          })
+          assert.fail('expected jsonPathAsserter to fail')
+        } catch (err) {
+          assert.isTrue(err.message.includes('Expected: "something but not empty string" in jsonPath $.test, actual: <empty>'))
+        }
+      })
+      it('should fail if real is not empty', async function () {
+        try {
+          await this.jsonPathAsserterEquals.assertConvoStep({
+            convoStep: { stepTag: 'test' },
+            args: ['$.test', ''],
+            botMsg: {
+              sourceData: {
+                test: 'something but not empty string'
+              }
+            }
+          })
+          assert.fail('expected jsonPathAsserter to fail')
+        } catch (err) {
+          assert.isTrue(err.message.includes('Expected: "<empty>" in jsonPath $.test, actual: something but not empty string'))
+        }
+      })
+    })
+
     it('should do nothing on no arg', async function () {
       await this.jsonPathAsserter.assertConvoStep({})
     })
@@ -62,8 +124,7 @@ describe('scripting.asserters.jsonPathAsserter', function () {
           }
         })
       } catch (err) {
-        console.log(err.message)
-        assert.isTrue(err.message.includes('Expected: message4 in jsonPath $.messages[*].label: Actual: message1,message2,message3'))
+        assert.isTrue(err.message.includes('Expected: "message4" in jsonPath $.messages[*].label, actual: message1,message2,message3'))
       }
     })
     it('should fail on not existing jsonpath', async function () {
@@ -133,7 +194,7 @@ describe('scripting.asserters.jsonPathAsserter', function () {
           }
         })
       } catch (err) {
-        assert.isTrue(err.message.indexOf('Expected: {"label":"message2"} in jsonPath $.messages[0]: Actual: {"label":"message1"}') > 0)
+        assert.isTrue(err.message.indexOf('Expected: "{"label":"message2"}" in jsonPath $.messages[0], actual: {"label":"message1"}') > 0)
         assert.isNotNull(err.context)
         assert.isNotNull(err.context.cause)
         assert.isNotTrue(err.context.cause.not)
@@ -155,7 +216,7 @@ describe('scripting.asserters.jsonPathAsserter', function () {
         })
         assert.fail('should have failed')
       } catch (err) {
-        assert.isTrue(err.message.indexOf('Expected: test2 in jsonPath $.test') > 0)
+        assert.isTrue(err.message.indexOf('Expected: "test2" in jsonPath $.test') > 0)
         assert.isNotNull(err.context)
         assert.isNotNull(err.context.cause)
         assert.isNotTrue(err.context.cause.not)
@@ -196,7 +257,7 @@ describe('scripting.asserters.jsonPathAsserter', function () {
         })
         assert.fail('should have failed')
       } catch (err) {
-        assert.isTrue(err.message.indexOf('Not expected: test1 in jsonPath $.test') > 0)
+        assert.isTrue(err.message.indexOf('Not expected: "test1" in jsonPath $.test') > 0)
         assert.isNotNull(err.context)
         assert.isNotNull(err.context.cause)
         assert.isTrue(err.context.cause.not)
@@ -216,7 +277,7 @@ describe('scripting.asserters.jsonPathAsserter', function () {
       })
     })
     it('should succeed on matching jsonpath from globalArgs', async function () {
-      await this.jsonPathAsserter.assertConvoStep({
+      await this.jsonPathAsserterGlobalArgs.assertConvoStep({
         convoStep: { stepTag: 'test' },
         args: ['test'],
         botMsg: {
@@ -252,7 +313,7 @@ describe('scripting.asserters.jsonPathAsserter', function () {
         })
         assert.fail('should have failed')
       } catch (err) {
-        assert.isTrue(err.message.indexOf('Expected: test2 in jsonPath $.test') > 0)
+        assert.isTrue(err.message.indexOf('Expected: "test2" in jsonPath $.test') > 0)
         assert.isNotNull(err.context)
         assert.isNotNull(err.context.cause)
         assert.isNotTrue(err.context.cause.not)
@@ -332,7 +393,7 @@ describe('scripting.asserters.jsonPathAsserter', function () {
         })
         assert.fail('should have failed')
       } catch (err) {
-        assert.isTrue(err.message.indexOf('Expected: value in jsonPath $.test') > 0)
+        assert.isTrue(err.message.indexOf('Expected: "value" in jsonPath $.test') > 0)
       }
     })
     it('should succeed on setting matching mode in global args', async function () {
@@ -373,9 +434,24 @@ describe('scripting.asserters.jsonPathAsserter', function () {
         })
         assert.fail('should have failed')
       } catch (err) {
-        assert.isTrue(err.message.indexOf('Expected: value1 in jsonPath $.test') > 0)
+        assert.isTrue(err.message.indexOf('Expected: "value1" in jsonPath $.test') > 0)
       }
     })
+
+    it('should succeed on empty string if checkExistanceOnEmptyAssert is on in globalArgs', async function () {
+      this.jsonPathAsserterEquals.globalArgs = {
+        checkExistanceOnEmptyAssert: true
+      }
+      await this.jsonPathAsserterEquals.assertConvoStep({
+        convoStep: { stepTag: 'test' },
+        args: ['test', ''],
+        botMsg: {
+          sourceData: {
+            test: 'asdf'
+          }
+        }
+      })
+    })
   })
 
   describe('jsonPathCountAsserter', function () {