botium-core 1.13.7 → 1.13.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botium-core",
-  "version": "1.13.7",
+  "version": "1.13.9",
   "description": "The Selenium for Chatbots",
   "main": "index.js",
   "module": "dist/botium-es.js",
@@ -19,7 +19,7 @@
     "test": "cross-env NODE_PATH=\"./test/plugins/plugindir/fromfolder:./test/plugins/plugindir/fromfile:./test/security/resources\" mocha \"./test/**/*.spec.js\"",
     "coverage:report": "nyc report --reporter=lcov npm test",
     "license-checker": "license-checker > LICENSES-3RDPARTY.txt",
-    "update-dependencies": "npm-check-updates --reject globby -u --timeout 120000"
+    "update-dependencies": "npm-check-updates --reject globby,rollup -u --timeout 120000"
   },
   "repository": {
     "type": "git",
@@ -32,17 +32,17 @@
   },
   "homepage": "https://www.botium.ai",
   "dependencies": {
-    "@babel/runtime": "^7.19.0",
+    "@babel/runtime": "^7.20.6",
     "async": "^3.2.4",
-    "body-parser": "^1.20.0",
+    "body-parser": "^1.20.1",
     "boolean": "^3.2.0",
     "bottleneck": "^2.19.5",
-    "csv-parse": "^5.3.0",
+    "csv-parse": "^5.3.3",
     "debug": "^4.3.4",
     "esprima": "^4.0.1",
-    "express": "^4.18.1",
+    "express": "^4.18.2",
     "globby": "11.0.4",
-    "ioredis": "^5.2.3",
+    "ioredis": "^5.2.4",
     "is-class": "^0.0.9",
     "is-json": "^2.0.1",
     "jsonpath": "^1.1.1",
@@ -53,47 +53,47 @@
     "moment": "^2.29.4",
     "mustache": "^4.2.0",
     "promise-retry": "^2.0.1",
-    "promise.allsettled": "^1.0.5",
+    "promise.allsettled": "^1.0.6",
     "randomatic": "^3.1.1",
     "request": "^2.88.2",
     "rimraf": "^3.0.2",
     "sanitize-filename": "^1.6.3",
     "slugify": "^1.6.5",
-    "socket.io": "^4.5.2",
-    "socket.io-client": "^4.5.2",
+    "socket.io": "^4.5.4",
+    "socket.io-client": "^4.5.4",
     "socketio-auth": "^0.1.1",
     "swagger-jsdoc": "^6.2.5",
-    "swagger-ui-express": "^4.5.0",
+    "swagger-ui-express": "^4.6.0",
     "uuid": "^9.0.0",
-    "vm2": "^3.9.11",
+    "vm2": "^3.9.13",
     "word-error-rate": "0.0.7",
     "write-yaml": "^1.0.0",
     "xlsx": "^0.18.5",
     "xregexp": "^5.1.1",
-    "yaml": "^2.1.1"
+    "yaml": "^2.1.3"
   },
   "devDependencies": {
-    "@babel/core": "^7.19.3",
-    "@babel/node": "^7.19.1",
-    "@babel/plugin-transform-runtime": "^7.19.1",
-    "@babel/preset-env": "^7.19.3",
-    "chai": "^4.3.6",
+    "@babel/core": "^7.20.5",
+    "@babel/node": "^7.20.5",
+    "@babel/plugin-transform-runtime": "^7.19.6",
+    "@babel/preset-env": "^7.20.2",
+    "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
     "cross-env": "^7.0.3",
-    "eslint": "^8.24.0",
+    "eslint": "^8.29.0",
     "eslint-config-standard": "^17.0.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-mocha": "^10.1.0",
-    "eslint-plugin-n": "^15.3.0",
-    "eslint-plugin-promise": "^6.0.1",
+    "eslint-plugin-n": "^15.6.0",
+    "eslint-plugin-promise": "^6.1.1",
     "eslint-plugin-standard": "^4.1.0",
     "license-checker": "^25.0.1",
     "license-compatibility-checker": "^0.3.5",
-    "mocha": "^10.0.0",
+    "mocha": "^10.2.0",
     "nock": "^13.2.9",
-    "npm-check-updates": "^16.3.4",
+    "npm-check-updates": "^16.5.6",
     "nyc": "^15.1.0",
-    "rollup": "^2.79.1",
+    "rollup": "2.79.1",
     "rollup-plugin-babel": "^4.4.0",
     "rollup-plugin-commonjs": "^10.1.0",
     "rollup-plugin-json": "^4.0.0",

package/src/scripting/Convo.js

@@ -591,26 +591,53 @@ class Convo {
   }
 
   GetScriptingMemoryAllVariables (container) {
-    const resultOuter = this.conversation.reduce((acc, convoStep) => {
-      let result = acc
-      result = result.concat(this.GetScriptingMemoryVariables(container, convoStep.messageText))
-      const extractFromArgs = (convoStepItems) => {
-        let resultInner = []
-        for (const item of (convoStepItems || [])) {
-          for (const arg of (item.args || [])) {
-            resultInner = resultInner.concat(this.GetScriptingMemoryVariables(container, arg))
+    const partialConvos = this.context.GetPartialConvos()
+
+    const variableNames = this.conversation.reduce((acc, convoStep) => {
+      if (convoStep.sender === 'include') {
+        if (convoStep.channel) {
+          const partialConvo = partialConvos[convoStep.channel]
+          if (partialConvo) {
+            acc = [...acc, ...partialConvo.GetScriptingMemoryAllVariables(container)]
           }
         }
-        return resultInner
-      }
-      result = result.concat(extractFromArgs(convoStep.asserters))
-      result = result.concat(extractFromArgs(convoStep.logicHooks))
-      result = result.concat(extractFromArgs(convoStep.userInputs))
+        if (convoStep.messageText) {
+          for (const partialConvoName of splitStringInNonEmptyLines(convoStep.messageText)) {
+            const partialConvo = partialConvos[partialConvoName]
+            if (partialConvo) {
+              acc = [...acc, ...partialConvo.GetScriptingMemoryAllVariables(container)]
+            }
+          }
+        }
+      } else {
+        acc = [...acc, ...this.GetScriptingMemoryVariables(container, convoStep.messageText)]
 
-      return result
+        const __extractFromArgs = (convoStepItems) => {
+          let resultInner = []
+          for (const item of (convoStepItems || [])) {
+            for (const arg of (item.args || [])) {
+              resultInner = resultInner.concat(this.GetScriptingMemoryVariables(container, arg))
+            }
+          }
+          return resultInner
+        }
+        acc = [...acc, ...__extractFromArgs(convoStep.asserters)]
+        acc = [...acc, ...__extractFromArgs(convoStep.logicHooks)]
+        acc = [...acc, ...__extractFromArgs(convoStep.userInputs)]
+
+        convoStep.logicHooks.forEach((logicHook) => {
+          if (logicHook.name === LOGIC_HOOK_INCLUDE) {
+            const partialConvo = partialConvos[logicHook.args[0]]
+            if (partialConvo) {
+              acc = [...acc, ...partialConvo.GetScriptingMemoryAllVariables(container)]
+            }
+          }
+        })
+      }
+      return acc
     }, [])
 
-    return [...new Set(resultOuter)]
+    return _.uniq(variableNames)
   }
 
   GetScriptingMemoryVariables (container, utterance) {

package/src/scripting/MatchFunctions.js

@@ -1,10 +1,9 @@
 const _ = require('lodash')
-const speechScorer = require('word-error-rate')
 
-const { toString, quoteRegexpString } = require('./helper')
+const { toString, quoteRegexpString, calculateWer } = require('./helper')
 
 const _normalize = (botresponse) => {
-  if (_.isUndefined(botresponse)) return ''
+  if (_.isUndefined(botresponse) || _.isNil(botresponse)) return ''
   if (_.isObject(botresponse) && _.has(botresponse, 'messageText')) {
     return toString(botresponse.messageText) || ''
   }
@@ -85,7 +84,7 @@ const wer = () => (botresponse, utterance, args) => {
   utterance = toString(utterance || '')
 
   const threshold = ([',', '.'].find(p => `${args[0]}`.includes(p)) ? parseFloat(args[0]) : parseInt(args[0]) / 100)
-  return speechScorer.wordErrorRate(botresponse, utterance) <= threshold
+  return calculateWer(botresponse, utterance) <= threshold
 }
 
 const getMatchFunction = (matchingMode) => {

package/src/scripting/ScriptingProvider.js

@@ -209,7 +209,7 @@ module.exports = class ScriptingProvider {
     this.retryHelperUserInput = new RetryHelper(this.caps, 'USERINPUT')
   }
 
-  _createAsserterPromises ({ asserterType, asserters, convo, convoStep, scriptingMemory, ...rest }) {
+  _createAsserterPromises ({ asserterType, asserters, convo, convoStep, scriptingMemory, container, ...rest }) {
     if (!this._isValidAsserterType(asserterType)) {
       throw Error(`Unknown asserterType ${asserterType}`)
     }
@@ -254,7 +254,8 @@ module.exports = class ScriptingProvider {
         convo,
         convoStep,
         scriptingMemory,
-        args: ScriptingMemory.applyToArgs(a.args, scriptingMemory, this.caps, rest.botMsg),
+        container,
+        args: ScriptingMemory.applyToArgs(a.args, scriptingMemory, container.caps, rest.botMsg),
         isGlobal: false,
         ...rest
       }))
@@ -276,7 +277,7 @@ module.exports = class ScriptingProvider {
     return Promise.resolve(false)
   }
 
-  _createLogicHookPromises ({ hookType, logicHooks, convo, convoStep, scriptingMemory, ...rest }) {
+  _createLogicHookPromises ({ hookType, logicHooks, convo, convoStep, scriptingMemory, container, ...rest }) {
     if (hookType !== 'onMeStart' && hookType !== 'onMePrepare' && hookType !== 'onMeEnd' && hookType !== 'onBotStart' && hookType !== 'onBotPrepare' && hookType !== 'onBotEnd' &&
       hookType !== 'onConvoBegin' && hookType !== 'onConvoEnd'
     ) {
@@ -289,7 +290,8 @@ module.exports = class ScriptingProvider {
         convo,
         convoStep,
         scriptingMemory,
-        args: ScriptingMemory.applyToArgs(l.args, scriptingMemory, this.caps, rest.botMsg),
+        container,
+        args: ScriptingMemory.applyToArgs(l.args, scriptingMemory, container.caps, rest.botMsg),
         isGlobal: false,
         ...rest
       })))
@@ -303,14 +305,15 @@ module.exports = class ScriptingProvider {
     return Promise.resolve(false)
   }
 
-  _createUserInputPromises ({ convo, convoStep, scriptingMemory, ...rest }) {
+  _createUserInputPromises ({ convo, convoStep, scriptingMemory, container, ...rest }) {
     const convoStepPromises = (convoStep.userInputs || [])
       .filter(ui => this.userInputs[ui.name])
       .map(ui => p(this.retryHelperUserInput, () => this.userInputs[ui.name].setUserInput({
         convo,
         convoStep,
         scriptingMemory,
-        args: ScriptingMemory.applyToArgs(ui.args, scriptingMemory, this.caps, rest.meMsg),
+        container,
+        args: ScriptingMemory.applyToArgs(ui.args, scriptingMemory, container.caps, rest.meMsg),
         ...rest
       })))
 
@@ -885,12 +888,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 +924,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 +1123,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/helper.js

@@ -1,5 +1,6 @@
 const _ = require('lodash')
 const isJSON = require('is-json')
+const speechScorer = require('word-error-rate')
 
 const { E_SCRIPTING_MEMORY_COLUMN_MODE } = require('../Enums')
 
@@ -61,7 +62,7 @@ const removeBuffers = obj => {
 }
 
 const toString = (value) => {
-  if (_.isUndefined(value)) return undefined
+  if (_.isUndefined(value) || _.isNil(value)) return ''
   if (_.isString(value)) return value
   if (_.isNumber(value)) return value.toString()
   if (_.isArray(value)) return value.map(v => toString(v)).join(',')
@@ -524,6 +525,63 @@ const linesToScriptingMemories = (lines, columnMode = null) => {
   return scriptingMemories
 }
 
+const calculateWer = (str, pattern) => {
+  const _prepareString = (str, remWildcard = false) => {
+    if (remWildcard) return str.replace(/[.,/#!$%^&;:*{}=\-_`~()]/g, '').toLowerCase()
+    return str.replace(/[.,/#!$%^&;:{}=\-_`~()]/g, '').toLowerCase()
+  }
+
+  const _getSubsets = (array, size) => {
+    const subsets = []
+    for (const index in array) {
+      const end = parseInt(index) + size
+      if (end <= array.length) { subsets.push(array.slice(index, end)) }
+    }
+    return subsets
+  }
+
+  const _getWords = str => str.split(' ').map(w => w.trim())
+
+  const _getErrors = (words1, words2) => words1.map((w, i) => {
+    return w !== words2[i]
+  })
+
+  const utterance = pattern
+
+  const botMessage = _prepareString(str)
+  const botMessageWords = botMessage.split(' ').map(bm => bm.trim())
+  const utt = _prepareString(utterance)
+
+  const errors = []
+  for (let wildcardPart of utt.split('*')) {
+    let wer = 1
+    wildcardPart = wildcardPart.trim()
+    if (wildcardPart.length === 0) {
+      errors.push([false])
+      continue
+    }
+    const wordCount = wildcardPart.split(' ').length
+    const subsetPhrases = _getSubsets(botMessageWords, wordCount).map(subset => subset.join(' ')) // botMessageWordsSubsets.filter(subset => subset.length === wordCount).map(subset => subset.reverse().join(' '))
+    let subsetPhraseFound = null
+    for (const subsetPhrase of subsetPhrases) {
+      const localWer = speechScorer.wordErrorRate(subsetPhrase, wildcardPart).toFixed(2)
+      if (localWer <= wer) {
+        subsetPhraseFound = subsetPhrase
+        wer = localWer
+      }
+    }
+    console.log('lala', subsetPhraseFound)
+    errors.push(_getErrors(_getWords(wildcardPart), _getWords(subsetPhraseFound)))
+  }
+  let errCount = 0
+  let allCount = 0
+  for (const err of errors) {
+    errCount += err.filter(err => err === true).length
+    allCount += err.length
+  }
+  return (errCount / allCount).toFixed(2)
+}
+
 module.exports = {
   normalizeText,
   splitStringInNonEmptyLines,
@@ -537,5 +595,6 @@ module.exports = {
   validSenders,
   validateSender,
   validateConvo,
-  linesToScriptingMemories
+  linesToScriptingMemories,
+  calculateWer
 }

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

@@ -127,6 +127,10 @@ module.exports = class JsonPathAsserter {
       }
     }
 
+    if (this.globalArgs && this.globalArgs.checkExistanceOnEmptyAssert) {
+      if (!assert) return Promise.resolve()
+    }
+
     if (!_.isNil(assert)) {
       const actual = (_.isArray(jsonPathValues) && jsonPathValues.length === 1) ? jsonPathValues[0] : jsonPathValues
 
@@ -135,10 +139,10 @@ module.exports = class JsonPathAsserter {
         matchFn = getMatchFunction(this.globalArgs.matchingMode)
       }
 
-      const match = jsonPathValues.find(a => matchFn(a, assert))
+      const match = jsonPathValues.findIndex(a => matchFn(a, assert)) >= 0
 
       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,
@@ -159,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/src/scripting/logichook/asserter/WerAsserter.js

@@ -1,6 +1,6 @@
 // const _ = require('lodash')
-const speechScorer = require('word-error-rate')
 const { BotiumError } = require('../../BotiumError')
+const { calculateWer } = require('../../helper')
 
 module.exports = class WerAsserter {
   constructor (context, caps = {}) {
@@ -34,7 +34,8 @@ module.exports = class WerAsserter {
     const utterance = args[0]
     const threshold = ([',', '.'].find(p => `${args[1]}`.includes(p)) ? parseFloat(args[1]) : parseInt(args[1]) / 100).toFixed(2)
 
-    const wer = speechScorer.wordErrorRate(botMsg.messageText, utterance).toFixed(2)
+    const wer = calculateWer(botMsg.messageText, utterance)
+
     if (wer > threshold) {
       const _toPercent = (s) => `${(s * 100).toFixed(0)}%`
 

package/src/scripting/logichook/logichooks/SetScriptingMemoryLogicHook.js

@@ -44,7 +44,7 @@ module.exports = class SetScriptingMemoryLogicHook {
     // args[0] cant have the whole name of the variable, because the variable names are replaced
     const name = '$' + params.name
     const value = params.value
-    debug(`Set scripting memory variable "${name}" from "${scriptingMemory[name]}" to "${value}, isGlobal: ${isGlobal}, type: ${type}"`)
+    debug(`Set scripting memory variable "${name}" from "${scriptingMemory[name]}" to "${value}", isGlobal: ${isGlobal}, type: ${type}"`)
     scriptingMemory[name] = value
 
     return Promise.resolve()

package/test/convo/convos/applyscriptingmemoryinbegin.convo.txt

@@ -0,0 +1,14 @@
+applyscriptingmemoryinbegin
+
+#begin
+SET_SCRIPTING_MEMORY access_token|$cap(MYTOKEN)
+
+#me
+access token: $cap(MYTOKEN)
+
+#bot
+
+#me
+access token: $access_token
+
+#bot

package/test/convo/fillAndApplyScriptingMemory.spec.js

@@ -163,6 +163,26 @@ describe('convo.fillAndApplyScriptingMemory', function () {
       const transcript = await compiler.convos[0].Run(container)
       assert.isObject(transcript.scriptingMemory)
     })
+    it('should apply scripting memory in begin args', async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'convo.scriptingmemory',
+        [Capabilities.CONTAINERMODE]: echoConnector,
+        [Capabilities.SCRIPTING_ENABLE_MEMORY]: true,
+        [Capabilities.CUSTOMHOOK_ONBUILD]: 'module.exports = ({ container }) => { console.log("customhooks called"); container.caps.MYTOKEN = "test1234" }'
+      }
+      const driver = new BotDriver(myCaps)
+      const compiler = driver.BuildCompiler()
+      const container = await driver.Build()
+
+      compiler.ReadScript(path.resolve(__dirname, 'convos'), 'applyscriptingmemoryinbegin.convo.txt')
+      assert.equal(compiler.convos.length, 1)
+
+      const transcript = await compiler.convos[0].Run(container)
+      assert.isObject(transcript.scriptingMemory)
+      assert.equal(transcript.scriptingMemory.$access_token, 'test1234')
+      assert.equal(transcript.steps[0].actual.messageText, 'access token: test1234')
+      assert.equal(transcript.steps[2].actual.messageText, 'access token: test1234')
+    })
   })
 
   describe('api', function () {

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

@@ -0,0 +1,7 @@
+convos:
+  - name: wer_threshold_wildcard_nok
+    steps:
+      - me:
+          - This is an example
+      - bot:
+          - TEXT_WER * that are * hot|0.4

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

@@ -0,0 +1,7 @@
+convos:
+  - name: wer_threshold_wildcard_nok
+    steps:
+      - me:
+          - This is an example
+      - bot:
+          - TEXT_WER * is * hot|1

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

@@ -0,0 +1,7 @@
+convos:
+  - name: wer_threshold_wildcard_ok
+    steps:
+      - me:
+          - This is an example
+      - bot:
+          - TEXT_WER this is * sample|0.4

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

@@ -0,0 +1,7 @@
+convos:
+  - name: wer_threshold_wildcard_ok
+    steps:
+      - me:
+          - This is an example
+      - bot:
+          - TEXT_WER this is another *|30

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

@@ -7,16 +7,89 @@ 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 null', async function () {
+        await this.jsonPathAsserterEquals.assertConvoStep({
+          convoStep: { stepTag: 'test' },
+          args: ['$.test', ''],
+          botMsg: {
+            sourceData: {
+              test: null
+            }
+          }
+        })
+      })
+      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,7 +135,6 @@ 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'))
       }
     })
@@ -216,7 +288,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: {
@@ -376,6 +448,21 @@ describe('scripting.asserters.jsonPathAsserter', function () {
         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 () {