botium-core 1.13.8 → 1.13.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botium-core",
-  "version": "1.13.8",
+  "version": "1.13.10",
   "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,13 +254,14 @@ 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
       }))
     const globalAsserter = Object.values(this.globalAsserter)
       .filter(a => a[asserterType])
-      .map(a => p(this.retryHelperAsserter, () => a[asserterType]({ convo, convoStep, scriptingMemory, args: [], isGlobal: true, ...rest })))
+      .map(a => p(this.retryHelperAsserter, () => a[asserterType]({ convo, convoStep, scriptingMemory, container, args: [], isGlobal: true, ...rest })))
 
     const allPromises = [...convoAsserter, ...globalAsserter]
     if (this.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]) {
@@ -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,28 +290,30 @@ 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
       })))
 
     const globalPromises = Object.values(this.globalLogicHook)
       .filter(l => l[hookType])
-      .map(l => p(this.retryHelperLogicHook, () => l[hookType]({ convo, convoStep, scriptingMemory, args: [], isGlobal: true, ...rest })))
+      .map(l => p(this.retryHelperLogicHook, () => l[hookType]({ convo, convoStep, scriptingMemory, container, args: [], isGlobal: true, ...rest })))
 
     const allPromises = [...convoStepPromises, ...globalPromises]
     if (allPromises.length > 0) return Promise.all(allPromises).then(() => true)
     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
       })))
 

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

@@ -139,7 +139,7 @@ module.exports = class JsonPathAsserter {
         matchFn = getMatchFunction(this.globalArgs.matchingMode)
       }
 
-      const match = !_.isNil(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: "${actual === '' ? '<empty>' : toString(actual)}" in jsonPath ${path}"`,

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

@@ -34,6 +34,17 @@ describe('scripting.asserters.jsonPathAsserter', function () {
           }
         })
       })
+      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' },

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

@@ -68,4 +68,45 @@ describe('scripting.asserters.werAsserter', function () {
       assert.equal(err.message, 'wer_threshold_nok/Line 2: assertion error - Line 2: Word Error Rate (50%) higher than accepted (10%)')
     }
   })
+
+  it('ok wildcard (percentage)', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_wildcard_ok_percentage.yml'))
+
+    this.compiler.ExpandScriptingMemoryToConvos()
+    assert.equal(this.compiler.convos.length, 1)
+    await this.compiler.convos[0].Run(this.container)
+  })
+  it('ok wildcard (float)', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_wildcard_ok_float.yml'))
+
+    this.compiler.ExpandScriptingMemoryToConvos()
+    assert.equal(this.compiler.convos.length, 1)
+    await this.compiler.convos[0].Run(this.container)
+  })
+  it('nok wildcard (percentage)', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_wildcard_nok_percentage.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_wildcard_nok/Line 2: assertion error - Line 2: Word Error Rate (33%) higher than accepted (1%)')
+    }
+  })
+  it('nok wildcard (float)', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_wildcard_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_wildcard_nok/Line 2: assertion error - Line 2: Word Error Rate (75%) higher than accepted (40%)')
+    }
+  })
 })

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

@@ -387,4 +387,86 @@ describe('scripting.matching.matchingmode', function () {
       assert.isTrue(this.compiler.Match('test 123', 'tast 123'))
     })
   })
+
+  describe('wer.lowthreshold.wildcard (float)', function () {
+    beforeEach(async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'matching.matchingmode',
+        [Capabilities.CONTAINERMODE]: echoConnector,
+        [Capabilities.SCRIPTING_MATCHING_MODE]: 'wer',
+        [Capabilities.SCRIPTING_MATCHING_MODE_ARGS]: [0.4]
+      }
+      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('This is an example', '* that are * hot'))
+    })
+  })
+  describe('wer.lowthreshold.wildcard (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('This is an example', '* is * hot'))
+    })
+  })
+
+  describe('wer.highthreshold.wildcard (float)', function () {
+    beforeEach(async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'matching.matchingmode',
+        [Capabilities.CONTAINERMODE]: echoConnector,
+        [Capabilities.SCRIPTING_MATCHING_MODE]: 'wer',
+        [Capabilities.SCRIPTING_MATCHING_MODE_ARGS]: [0.4]
+      }
+      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('this is an example', 'this is * sample'))
+    })
+  })
+  describe('wer.highthreshold.wildcard (percentage)', function () {
+    beforeEach(async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'matching.matchingmode',
+        [Capabilities.CONTAINERMODE]: echoConnector,
+        [Capabilities.SCRIPTING_MATCHING_MODE]: 'wer',
+        [Capabilities.SCRIPTING_MATCHING_MODE_ARGS]: [30]
+      }
+      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('this is an example', 'this is another *'))
+    })
+  })
 })

package/test/scripting/scriptingModificator.spec.js

@@ -20,6 +20,7 @@ describe('scriptingModificator.assertions', function () {
         ]
       },
       scriptingMemory: {},
+      container: {},
       botMsg: {
         buttons: [
           {
@@ -47,6 +48,7 @@ describe('scriptingModificator.assertions', function () {
           ]
         },
         scriptingMemory: {},
+        container: {},
         botMsg: {
           nlp: {
             intent: { name: 'test1' }

package/test/scripting/scriptingmemory/convosPartial/buy.convo.txt

@@ -0,0 +1,7 @@
+buy
+
+#begin
+INCLUDE sub1
+
+#include sub2
+

package/test/scripting/scriptingmemory/convosPartial/product.scriptingmemory.txt

@@ -0,0 +1,2 @@
+        |$productName    |$customer
+product1|schnitzel       |attila

package/test/scripting/scriptingmemory/convosPartial/sub1.pconvo.txt

@@ -0,0 +1,7 @@
+sub1
+
+#me
+schnitzel
+
+#bot
+JSON_PATH $.request|$productName