botium-core 1.11.13 → 1.12.0

package/src/scripting/ScriptingProvider.js

@@ -464,11 +464,33 @@ module.exports = class ScriptingProvider {
     return { convos: dirConvos, utterances: dirUtterances, pconvos: dirPartialConvos, scriptingMemories: dirScriptingMemories }
   }
 
+  ReadScriptFromBuffer (scriptBuffer, scriptingFormat, scriptingTypes = null) {
+    if (_.isString(scriptingTypes)) scriptingTypes = [scriptingTypes]
+    if (_.isArray(scriptingTypes) && scriptingTypes.length === 0) scriptingTypes = null
+
+    const result = {
+      convos: [],
+      utterances: [],
+      pconvos: [],
+      scriptingMemories: []
+    }
+    if (!scriptingTypes || scriptingTypes.includes(Constants.SCRIPTING_TYPE_UTTERANCES)) {
+      result.utterances = this.Compile(scriptBuffer, scriptingFormat, Constants.SCRIPTING_TYPE_UTTERANCES)
+    }
+    if (!scriptingTypes || scriptingTypes.includes(Constants.SCRIPTING_TYPE_PCONVO)) {
+      result.pconvos = this.Compile(scriptBuffer, scriptingFormat, Constants.SCRIPTING_TYPE_PCONVO)
+    }
+    if (!scriptingTypes || scriptingTypes.includes(Constants.SCRIPTING_TYPE_CONVO)) {
+      result.convos = this.Compile(scriptBuffer, scriptingFormat, Constants.SCRIPTING_TYPE_CONVO)
+    }
+    if (!scriptingTypes || scriptingTypes.includes(Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)) {
+      result.scriptingMemories = this.Compile(scriptBuffer, scriptingFormat, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)
+    }
+    return result
+  }
+
   ReadScript (convoDir, filename) {
-    let fileConvos = []
-    let fileUtterances = []
-    let filePartialConvos = []
-    let fileScriptingMemories = []
+    let result = {}
 
     try {
       let scriptBuffer = fs.readFileSync(path.resolve(convoDir, filename))
@@ -487,36 +509,25 @@ module.exports = class ScriptingProvider {
       }
 
       if (filename.endsWith('.xlsx') || filename.endsWith('.xlsm')) {
-        fileUtterances = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_XSLX, Constants.SCRIPTING_TYPE_UTTERANCES)
-        filePartialConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_XSLX, Constants.SCRIPTING_TYPE_PCONVO)
-        fileConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_XSLX, Constants.SCRIPTING_TYPE_CONVO)
-        fileScriptingMemories = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_XSLX, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_XSLX, [Constants.SCRIPTING_TYPE_UTTERANCES, Constants.SCRIPTING_TYPE_PCONVO, Constants.SCRIPTING_TYPE_CONVO, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY])
       } else if (filename.endsWith('.convo.txt')) {
-        fileConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_CONVO)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_CONVO)
       } else if (filename.endsWith('.pconvo.txt')) {
-        filePartialConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_PCONVO)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_PCONVO)
       } else if (filename.endsWith('.utterances.txt')) {
-        fileUtterances = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_UTTERANCES)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_UTTERANCES)
       } else if (filename.endsWith('.scriptingmemory.txt')) {
-        fileScriptingMemories = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_TXT, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)
       } else if (filename.endsWith('.convo.csv')) {
-        fileConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_CSV, Constants.SCRIPTING_TYPE_CONVO)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_CSV, Constants.SCRIPTING_TYPE_CONVO)
       } else if (filename.endsWith('.pconvo.csv')) {
-        filePartialConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_CSV, Constants.SCRIPTING_TYPE_PCONVO)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_CSV, Constants.SCRIPTING_TYPE_PCONVO)
       } else if (filename.endsWith('.yaml') || filename.endsWith('.yml')) {
-        fileUtterances = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_YAML, Constants.SCRIPTING_TYPE_UTTERANCES)
-        filePartialConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_YAML, Constants.SCRIPTING_TYPE_PCONVO)
-        fileConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_YAML, Constants.SCRIPTING_TYPE_CONVO)
-        fileScriptingMemories = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_YAML, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_YAML, [Constants.SCRIPTING_TYPE_UTTERANCES, Constants.SCRIPTING_TYPE_PCONVO, Constants.SCRIPTING_TYPE_CONVO, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY])
       } else if (filename.endsWith('.json')) {
-        fileUtterances = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_JSON, Constants.SCRIPTING_TYPE_UTTERANCES)
-        filePartialConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_JSON, Constants.SCRIPTING_TYPE_PCONVO)
-        fileConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_JSON, Constants.SCRIPTING_TYPE_CONVO)
-        fileScriptingMemories = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_JSON, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_JSON, [Constants.SCRIPTING_TYPE_UTTERANCES, Constants.SCRIPTING_TYPE_PCONVO, Constants.SCRIPTING_TYPE_CONVO, Constants.SCRIPTING_TYPE_SCRIPTING_MEMORY])
       } else if (filename.endsWith('.markdown') || filename.endsWith('.md')) {
-        fileUtterances = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_MARKDOWN, Constants.SCRIPTING_TYPE_UTTERANCES)
-        fileConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_MARKDOWN, Constants.SCRIPTING_TYPE_CONVO)
-        filePartialConvos = this.Compile(scriptBuffer, Constants.SCRIPTING_FORMAT_MARKDOWN, Constants.SCRIPTING_TYPE_PCONVO)
+        result = this.ReadScriptFromBuffer(scriptBuffer, Constants.SCRIPTING_FORMAT_MARKDOWN, [Constants.SCRIPTING_TYPE_UTTERANCES, Constants.SCRIPTING_TYPE_PCONVO, Constants.SCRIPTING_TYPE_CONVO])
       } else {
         debug(`ReadScript - dropped file: ${filename}, filename not supported`)
       }
@@ -526,42 +537,40 @@ module.exports = class ScriptingProvider {
     }
 
     // Compilers saved the convos, and we alter here the saved version too
-    if (fileConvos) {
-      fileConvos.forEach((fileConvo) => {
+    if (result.convos && result.convos.length > 0) {
+      result.convos.forEach((fileConvo) => {
         fileConvo.sourceTag = { convoDir, filename }
         if (!fileConvo.header.name) {
           fileConvo.header.name = filename
         }
       })
       const isSkip = (c) => c.header.name && skipPattern.test(c.header.name.toLowerCase())
-      fileConvos.filter(c => isSkip(c)).forEach(c => debug(`ReadScript - skipping convo '${c.header.name}'`))
-      fileConvos = fileConvos.filter(c => !isSkip(c))
+      result.convos.filter(c => isSkip(c)).forEach(c => debug(`ReadScript - skipping convo '${c.header.name}'`))
+      result.convos = result.convos.filter(c => !isSkip(c))
     }
-    if (filePartialConvos) {
-      filePartialConvos.forEach((filePartialConvo) => {
+    if (result.pconvos && result.pconvos.length > 0) {
+      result.pconvos.forEach((filePartialConvo) => {
         filePartialConvo.sourceTag = { convoDir, filename }
         if (!filePartialConvo.header.name) {
           filePartialConvo.header.name = filename
         }
       })
     }
-    if (fileScriptingMemories && fileScriptingMemories.length) {
-      fileScriptingMemories.forEach((scriptingMemory) => {
+    if (result.scriptingMemories && result.scriptingMemories.length > 0) {
+      result.scriptingMemories.forEach((scriptingMemory) => {
         scriptingMemory.sourceTag = { filename }
       })
     }
-
-    if (fileUtterances) {
-      this.fileUtterances = this._tagAndCleanupUtterances(fileUtterances, convoDir, filename)
+    if (result.utterances) {
+      result.utterances = this._tagAndCleanupUtterances(result.utterances, convoDir, filename)
     }
-    return { convos: fileConvos, utterances: fileUtterances, pconvos: filePartialConvos, scriptingMemories: fileScriptingMemories }
+    return { convos: result.convos || [], utterances: result.utterances || [], pconvos: result.pconvos || [], scriptingMemories: result.scriptingMemories || [] }
   }
 
   _tagAndCleanupUtterances (utteranceFiles, convoDir, filename) {
     return utteranceFiles.map((fileUtt) => {
       fileUtt.sourceTag = { convoDir, filename }
-      fileUtt.utterances = fileUtt.utterances
-        .filter(u => u)
+      fileUtt.utterances = fileUtt.utterances.filter(u => u)
       return fileUtt
     })
   }
@@ -944,7 +953,7 @@ module.exports = class ScriptingProvider {
         }
       }
     } else {
-      expandedConvos.push(Object.assign(_.cloneDeep(currentConvo), { conversation: convoStepsStack }))
+      expandedConvos.push(Object.assign(_.cloneDeep(currentConvo), { conversation: _.cloneDeep(convoStepsStack) }))
     }
   }
 

package/src/scripting/helper.js

@@ -72,7 +72,7 @@ const toString = (value) => {
 }
 
 const flatString = (str) => {
-  return str.split('\n').map(s => s.trim()).join(' ')
+  return str ? str.split('\n').map(s => s.trim()).join(' ') : ''
 }
 
 const linesToConvoStep = (lines, sender, context, eol, singleLineMode = false) => {
@@ -439,7 +439,7 @@ const convoStepToLines = (step) => {
     if (step.messageText) {
       lines.push((step.optional ? '?' : '') + (step.not ? '!' : '') + step.messageText)
     }
-    if (step.buttons && step.buttons.length > 0) lines.push('BUTTONS ' + step.buttons.map(b => flatString(b.text)).join('|'))
+    if (step.buttons && step.buttons.length > 0) lines.push('BUTTONS ' + step.buttons.filter(b => b.text).map(b => flatString(b.text)).join('|'))
     if (step.media && step.media.length > 0) lines.push('MEDIA ' + step.media.filter(m => !m.buffer && m.mediaUri).map(m => m.mediaUri).join('|'))
     if (step.cards && step.cards.length > 0) {
       step.cards.forEach(c => {
@@ -449,7 +449,7 @@ const convoStepToLines = (step) => {
         if (c.content) cardTexts = cardTexts.concat(_.isArray(c.content) ? c.content : [c.content])
         if (cardTexts.length > 0) lines.push('CARDS ' + cardTexts.map(c => flatString(c)).join('|'))
 
-        if (c.buttons && c.buttons.length > 0) lines.push('BUTTONS ' + c.buttons.map(b => flatString(b.text)).join('|'))
+        if (c.buttons && c.buttons.length > 0) lines.push('BUTTONS ' + c.buttons.filter(b => b.text).map(b => flatString(b.text)).join('|'))
         if (c.image && !c.image.buffer && c.image.mediaUri) lines.push('MEDIA ' + c.image.mediaUri)
       })
     }

package/src/scripting/logichook/LogicHookConsts.js

@@ -33,6 +33,10 @@ module.exports = {
     { name: 'TEXT_WILDCARD_ANY_IC', className: 'TextWildcardAnyICAsserter' },
     { name: 'TEXT_WILDCARD_ALL', className: 'TextWildcardAllAsserter' },
     { name: 'TEXT_WILDCARD_ALL_IC', className: 'TextWildcardAllICAsserter' },
+    { name: 'TEXT_WILDCARDEXACT_ANY', className: 'TextWildcardExactAnyAsserter' },
+    { name: 'TEXT_WILDCARDEXACT_ANY_IC', className: 'TextWildcardExactAnyICAsserter' },
+    { name: 'TEXT_WILDCARDEXACT_ALL', className: 'TextWildcardExactAllAsserter' },
+    { name: 'TEXT_WILDCARDEXACT_ALL_IC', className: 'TextWildcardExactAllICAsserter' },
     { name: 'TEXT_REGEXP_ANY', className: 'TextRegexpAnyAsserter' },
     { name: 'TEXT_REGEXP_ANY_IC', className: 'TextRegexpAnyICAsserter' },
     { name: 'TEXT_REGEXP_ALL', className: 'TextRegexpAllAsserter' },

package/src/scripting/logichook/LogicHookUtils.js

@@ -240,6 +240,8 @@ module.exports = class LogicHookUtils {
           return CheckClass({ ref, ...this.buildScriptContext }, this.caps, args)
         } else if (isClass(CheckClass.PluginClass)) {
           return new CheckClass.PluginClass({ ref, ...this.buildScriptContext }, this.caps, args)
+        } else if (_.isFunction(CheckClass.PluginClass)) {
+          return CheckClass.PluginClass({ ref, ...this.buildScriptContext }, this.caps, args)
         } else {
           throw new Error(`${src} class or function expected`)
         }

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

@@ -118,7 +118,7 @@ module.exports = class JsonPathAsserter {
               }
             },
             cause: {
-              expected: assert || (args && `any element for ${args.join('|')}`) || (!args && `any element in ${path}`),
+              expected: assert || ((args && args.length > 0) && `any element for ${args.join('|')}`) || ((!args || args.length === 0) && `any element in ${path}`),
               actual: null,
               path
             }

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

@@ -0,0 +1,8 @@
+const BaseTextAsserter = require('./BaseTextAsserter')
+const MatchFunctions = require('../../MatchFunctions')
+
+module.exports = class TextWildcardExactAnyAsserter extends BaseTextAsserter {
+  constructor (context, caps = {}) {
+    super(context, caps, MatchFunctions.wildcardExact(false), 'all')
+  }
+}

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

@@ -0,0 +1,8 @@
+const BaseTextAsserter = require('./BaseTextAsserter')
+const MatchFunctions = require('../../MatchFunctions')
+
+module.exports = class TextWildcardExactAnyAsserter extends BaseTextAsserter {
+  constructor (context, caps = {}) {
+    super(context, caps, MatchFunctions.wildcardExact(true), 'all')
+  }
+}

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

@@ -0,0 +1,8 @@
+const BaseTextAsserter = require('./BaseTextAsserter')
+const MatchFunctions = require('../../MatchFunctions')
+
+module.exports = class TextWildcardExactAnyAsserter extends BaseTextAsserter {
+  constructor (context, caps = {}) {
+    super(context, caps, MatchFunctions.wildcardExact(false), 'any')
+  }
+}

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

@@ -0,0 +1,8 @@
+const BaseTextAsserter = require('./BaseTextAsserter')
+const MatchFunctions = require('../../MatchFunctions')
+
+module.exports = class TextWildcardExactAnyAsserter extends BaseTextAsserter {
+  constructor (context, caps = {}) {
+    super(context, caps, MatchFunctions.wildcardExact(true), 'any')
+  }
+}

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

@@ -1,8 +1,6 @@
 const util = require('util')
 const _ = require('lodash')
 
-const { isStringJson } = require('../../../helpers/Utils')
-
 module.exports = class UpdateCustomLogicHook {
   constructor (context, caps = {}, globalArgs = {}) {
     this.context = context
@@ -58,10 +56,11 @@ module.exports = class UpdateCustomLogicHook {
   }
 
   _getValue (raw) {
-    if (isStringJson(raw)) {
+    try {
       return JSON.parse(raw)
+    } catch (e) {
+      return raw
     }
-    return raw
   }
 
   _update (args, meMsg) {

package/test/connectors/convos/hello.convo.txt

@@ -0,0 +1,6 @@
+hello
+
+#me
+hello
+
+#bot

package/test/connectors/simplerest.spec.js

@@ -22,6 +22,12 @@ const myCapsPost = {
   [Capabilities.SIMPLEREST_BODY_TEMPLATE]: { BODY1: 'BODY1VALUE', BODY2: '{{msg.messageText}}' },
   [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: ['$']
 }
+const myCapsFormPost = {
+  [Capabilities.CONTAINERMODE]: 'simplerest',
+  [Capabilities.SIMPLEREST_URL]: 'http://my-host.com/api/endpoint/{{msg.messageText}}',
+  [Capabilities.SIMPLEREST_METHOD]: 'POST',
+  [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: ['$']
+}
 
 const myCapsScriptingMemory = {
   [Capabilities.CONTAINERMODE]: 'simplerest',
@@ -448,7 +454,7 @@ describe('connectors.simplerest.build', function () {
       assert.isTrue(err.message.includes('Cant load hook, syntax is not valid'))
     }
   })
-  it('should query params from UPDATE_CUSTOM (without "?")', async function () {
+  it('should add query params from UPDATE_CUSTOM (without "?")', async function () {
     const myCaps = Object.assign({}, myCapsGet)
     const myMsg = Object.assign({}, msg)
     myMsg.ADD_QUERY_PARAM = {
@@ -467,7 +473,7 @@ describe('connectors.simplerest.build', function () {
 
     await container.Clean()
   })
-  it('should query params from UPDATE_CUSTOM (with "?")', async function () {
+  it('should add query params from UPDATE_CUSTOM (with "?")', async function () {
     const myCaps = Object.assign({}, myCapsGet)
     myCaps.SIMPLEREST_URL = 'http://my-host.com/api/endpoint/messageText?const1=const1'
     const myMsg = Object.assign({}, msg)
@@ -510,6 +516,26 @@ describe('connectors.simplerest.build', function () {
 
     await container.Clean()
   })
+  it('should add form params from UPDATE_CUSTOM (without "?")', async function () {
+    const myCaps = Object.assign({}, myCapsFormPost)
+    const myMsg = Object.assign({}, msg)
+    myMsg.ADD_FORM_PARAM = {
+      formparam1: 'valueparam1',
+      formparam2: '{{msg.messageText}}'
+    }
+
+    const driver = new BotDriver(myCaps)
+    const container = await driver.Build()
+    assert.equal(container.pluginInstance.constructor.name, 'SimpleRestContainer')
+
+    await container.Start()
+    const request = await container.pluginInstance._buildRequest(myMsg)
+    assert.isObject(request.form)
+    assert.equal(request.form.formparam1, 'valueparam1')
+    assert.equal(request.form.formparam2, 'messageText')
+
+    await container.Clean()
+  })
   it('should add header from UPDATE_CUSTOM', async function () {
     const myCaps = Object.assign({}, myCapsGet)
     const myMsg = Object.assign({}, msg)
@@ -782,9 +808,14 @@ describe('connectors.simplerest.useresponse', function () {
       this.scope = nock('https://mock.com')
         .get('/ping').reply(200, { text: 'response from ping' })
         .get('/pingtrash').reply(200, 'asdfasdfasdfasdf')
+        .get('/pingencoded').reply(200, { text: JSON.stringify({ prop: 'response from ping' }) })
+        .get('/pingstring').reply(200, 'response from ping')
         .get('/start').reply(200, { text: 'response from start' })
         .get('/starttrash').reply(200, 'asdfasdfasdfasdf')
+        .get('/startencoded').reply(200, { text: JSON.stringify({ prop: 'response from start' }) })
+        .get('/startstring').reply(200, 'response from start')
         .get('/msg').reply(200, { text: 'response from msg' })
+        .get('/msgfail').reply(400, { error: 'failure text' })
         .persist()
 
       const myCaps = Object.assign({
@@ -832,6 +863,32 @@ describe('connectors.simplerest.useresponse', function () {
     }
   })
 
+  it('should use parser to parse response from ping', async function () {
+    await this.init({
+      [Capabilities.SIMPLEREST_PING_URL]: 'https://mock.com/pingencoded',
+      [Capabilities.SIMPLEREST_PING_PROCESS_RESPONSE]: true,
+      [Capabilities.SIMPLEREST_PARSER_HOOK]: 'body.text = JSON.parse(body.text).prop'
+    })
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'responsefromping.convo.txt')
+    const transcript = await this.compiler.convos[0].Run(this.container)
+    assert.equal(transcript.steps.length, 1)
+    assert.equal(transcript.steps[0].actual.messageText, 'response from ping')
+  })
+
+  it('should use parser to parse string from ping', async function () {
+    await this.init({
+      [Capabilities.SIMPLEREST_PING_URL]: 'https://mock.com/pingstring',
+      [Capabilities.SIMPLEREST_PING_PROCESS_RESPONSE]: true,
+      [Capabilities.SIMPLEREST_PARSER_HOOK]: 'changeBody({ text: body })'
+    })
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'responsefromping.convo.txt')
+    const transcript = await this.compiler.convos[0].Run(this.container)
+    assert.equal(transcript.steps.length, 1)
+    assert.equal(transcript.steps[0].actual.messageText, 'response from ping')
+  })
+
   it('should use response from start', async function () {
     await this.init({
       [Capabilities.SIMPLEREST_START_URL]: 'https://mock.com/start',
@@ -858,6 +915,45 @@ describe('connectors.simplerest.useresponse', function () {
       assert.isTrue(err.message.indexOf('Bot did not respond within') >= 0)
     }
   })
+
+  it('should use parser to parse response from ping', async function () {
+    await this.init({
+      [Capabilities.SIMPLEREST_START_URL]: 'https://mock.com/startencoded',
+      [Capabilities.SIMPLEREST_START_PROCESS_RESPONSE]: true,
+      [Capabilities.SIMPLEREST_PARSER_HOOK]: 'body.text = JSON.parse(body.text).prop'
+    })
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'responsefromstart.convo.txt')
+    const transcript = await this.compiler.convos[0].Run(this.container)
+    assert.equal(transcript.steps.length, 1)
+    assert.equal(transcript.steps[0].actual.messageText, 'response from start')
+  })
+
+  it('should use parser to parse string from ping', async function () {
+    await this.init({
+      [Capabilities.SIMPLEREST_START_URL]: 'https://mock.com/startstring',
+      [Capabilities.SIMPLEREST_START_PROCESS_RESPONSE]: true,
+      [Capabilities.SIMPLEREST_PARSER_HOOK]: 'changeBody({ text: body })'
+    })
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'responsefromstart.convo.txt')
+    const transcript = await this.compiler.convos[0].Run(this.container)
+    assert.equal(transcript.steps.length, 1)
+    assert.equal(transcript.steps[0].actual.messageText, 'response from start')
+  })
+
+  it('should use error body content', async function () {
+    await this.init({
+      [Capabilities.SIMPLEREST_URL]: 'https://mock.com/msgfail'
+    })
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'hello.convo.txt')
+    try {
+      await this.compiler.convos[0].Run(this.container)
+    } catch (err) {
+      assert.isTrue(err.message.indexOf('failure text') >= 0)
+    }
+  })
 })
 
 describe('connectors.simplerest.inbound', function () {
@@ -985,6 +1081,37 @@ describe('connectors.simplerest.polling', function () {
     await container.WaitBotSays()
     await container.WaitBotSays()
 
+    await container.Stop()
+    await container.Clean()
+    scope.persist(false)
+  }).timeout(5000)
+  it('should use request hook for polling', async () => {
+    const caps = {
+      [Capabilities.CONTAINERMODE]: 'simplerest',
+      [Capabilities.SIMPLEREST_URL]: () => 'https://mock.com/endpoint',
+      [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: () => ['$.text'],
+      [Capabilities.SIMPLEREST_POLL_URL]: () => 'https://mock.com/poll',
+      [Capabilities.SIMPLEREST_POLL_REQUEST_HOOK]: 'requestOptions.uri = "https://mock.com/_from_hook"'
+    }
+    const scope = nock('https://mock.com')
+      .get('/endpoint')
+      .reply(200, {
+        text: 'you called me'
+      })
+      .get('/_from_hook')
+      .reply(200, {
+        text: 'you called me'
+      })
+      .persist()
+
+    const driver = new BotDriver(caps)
+    const container = await driver.Build()
+    await container.Start()
+
+    await container.UserSays({ text: 'hallo' })
+    await container.WaitBotSays()
+    await container.WaitBotSays()
+
     await container.Stop()
     await container.Clean()
     scope.persist(false)

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

@@ -0,0 +1,7 @@
+convos:
+  - name: text_wildcardexact_all_nok
+    steps:
+      - me:
+          - Im Joe, my number is 12345, and my ID is id1_123
+      - bot:
+          - TEXT_WILDCARDEXACT_ALL Im Joe, my number is 12345, and my ID is id2_*3|Im Joe, my number is 1*5, and my ID is id1_123

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

@@ -0,0 +1,7 @@
+convos:
+  - name: text_wildcardexact_all_nok
+    steps:
+      - me:
+          - Im Joe, my number is 12345, and my ID is id1_123
+      - bot:
+          - TEXT_WILDCARDEXACT_ALL Im Joe, my number is 12345, and my ID is id1_*3|Im Joe, my number is 1*5, and my ID is id1_123

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

@@ -0,0 +1,7 @@
+convos:
+  - name: text_wildcardexact_any_nok
+    steps:
+      - me:
+          - Im Joe, my number is 12345, and my ID is id1_123
+      - bot:
+          - TEXT_WILDCARDEXACT_ANY Im Joe, my number is 12345, and my ID is id2_*3|Im Joe, my number is 12345, and my ID is id3_*3

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

@@ -0,0 +1,7 @@
+convos:
+  - name: text_wildcardexact_any_ok
+    steps:
+      - me:
+          - Im Joe, my number is 12345, and my ID is id1_123
+      - bot:
+          - TEXT_WILDCARDEXACT_ANY Im Joe, my number is 12345, and my ID is id1_*3|Im Joe, my number is 12345, and my ID is id2_*3

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

@@ -0,0 +1,51 @@
+const assert = require('chai').assert
+const path = require('path')
+
+const BotDriver = require('../../..').BotDriver
+const Capabilities = require('../../..').Capabilities
+
+const echoConnector = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: msg.messageText }
+      queueBotSays(botMsg)
+    }
+  }
+}
+
+describe('scripting.asserters.textWildcardExactAllAsserter', function () {
+  beforeEach(async function () {
+    const myCaps = {
+      [Capabilities.PROJECTNAME]: 'scripting.asserters.textWildcardExactAllAsserter',
+      [Capabilities.CONTAINERMODE]: echoConnector
+    }
+    const driver = new BotDriver(myCaps)
+    this.compiler = driver.BuildCompiler()
+    this.container = await driver.Build()
+  })
+  afterEach(async function () {
+    this.container && await this.container.Clean()
+  })
+
+  it('ok', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'text_wildcardexact_all_ok.yml'))
+
+    this.compiler.ExpandScriptingMemoryToConvos()
+    assert.equal(this.compiler.convos.length, 1)
+    await this.compiler.convos[0].Run(this.container)
+  })
+
+  it('nok', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'text_wildcardexact_all_nok.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, 'text_wildcardexact_all_nok/Line 2: assertion error - Line 2: Expected text(s) in response "Im Joe, my number is 12345, and my ID is id2_*3"')
+    }
+  })
+})

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

@@ -0,0 +1,51 @@
+const assert = require('chai').assert
+const path = require('path')
+
+const BotDriver = require('../../..').BotDriver
+const Capabilities = require('../../..').Capabilities
+
+const echoConnector = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = { sender: 'bot', sourceData: msg.sourceData, messageText: msg.messageText }
+      queueBotSays(botMsg)
+    }
+  }
+}
+
+describe('scripting.asserters.textWildcardExactAnyAsserter', function () {
+  beforeEach(async function () {
+    const myCaps = {
+      [Capabilities.PROJECTNAME]: 'scripting.asserters.textWildcardExactAnyAsserter',
+      [Capabilities.CONTAINERMODE]: echoConnector
+    }
+    const driver = new BotDriver(myCaps)
+    this.compiler = driver.BuildCompiler()
+    this.container = await driver.Build()
+  })
+  afterEach(async function () {
+    this.container && await this.container.Clean()
+  })
+
+  it('ok', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'text_wildcardexact_any_ok.yml'))
+
+    this.compiler.ExpandScriptingMemoryToConvos()
+    assert.equal(this.compiler.convos.length, 1)
+    await this.compiler.convos[0].Run(this.container)
+  })
+
+  it('nok', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'text_wildcardexact_any_nok.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, 'text_wildcardexact_any_nok/Line 2: assertion error - Line 2: Expected any text in response "Im Joe, my number is 12345, and my ID is id2_*3,Im Joe, my number is 12345, and my ID is id3_*3"')
+    }
+  })
+})

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

@@ -206,6 +206,49 @@ describe('matching.matchingmode.wildcardIgnoreCase', function () {
   })
 })
 
+describe('matching.matchingmode.wildcardExact', function () {
+  beforeEach(async function () {
+    const myCaps = {
+      [Capabilities.PROJECTNAME]: 'matching.matchingmode',
+      [Capabilities.CONTAINERMODE]: echoConnector,
+      [Capabilities.SCRIPTING_MATCHING_MODE]: 'wildcardExact'
+    }
+    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 response with substring', async function () {
+    assert.isFalse(this.compiler.Match('Interesting...', 'Interesting'))
+  })
+  it('should match long response with wildcard', async function () {
+    assert.isTrue(this.compiler.Match('this is a long text', 'this is a * text'))
+  })
+  it('should match very long response with wildcard', async function () {
+    assert.isTrue(this.compiler.Match('this is a long text this is a long text this is a long text this is a long text', 'this is a * text this is a * text this is a * text this is a * text'))
+  })
+  it('should not match long uppcercase response with wildcard', async function () {
+    assert.isFalse(this.compiler.Match('THIS IS A LONG TEXT', 'this is a * text'))
+  })
+  it('should match very long response with very long wildcard', async function () {
+    assert.isTrue(this.compiler.Match('begin this is a long text this is a long text this is a long text this is a long text end', 'begin * end'))
+  })
+  it('should not allow more than 10 wildcards in a string', async function () {
+    try {
+      this.compiler.Match('some text', 'begin * * * * * * * * * * * end')
+      assert.fail('should have failed')
+    } catch (err) {
+      assert.equal(err.message, 'Maximum number of 10 wildcards supported.')
+    }
+  })
+  it('should not match if pattern is not matching', async function () {
+    assert.isFalse(this.compiler.Match('This is a long text', '*notthere*'))
+  })
+})
+
 describe('matching.matchingmode.equals', function () {
   beforeEach(async function () {
     const myCaps = {