botium-core 1.13.19 → 1.14.1

package/src/scripting/logichook/LogicHookUtils.js

@@ -1,11 +1,9 @@
-const { NodeVM } = require('vm2')
+const util = require('util')
 const path = require('path')
 const fs = require('fs')
 const isClass = require('is-class')
 const debug = require('debug')('botium-core-asserterUtils')
 
-const { BotiumError } = require('../BotiumError')
-
 const { DEFAULT_ASSERTERS, DEFAULT_LOGIC_HOOKS, DEFAULT_USER_INPUTS } = require('./LogicHookConsts')
 
 DEFAULT_ASSERTERS.forEach((asserter) => {
@@ -129,19 +127,7 @@ module.exports = class LogicHookUtils {
       }
     }
 
-    const _checkUnsafe = () => {
-      if (!this.caps[Capabilities.SECURITY_ALLOW_UNSAFE]) {
-        throw new BotiumError(
-          'Security Error. Using unsafe component is not allowed',
-          {
-            type: 'security',
-            subtype: 'allow unsafe',
-            source: path.basename(__filename),
-            cause: { src: !!src, ref, args, hookType }
-          }
-        )
-      }
-    }
+    const allowUnsafe = !!this.caps[Capabilities.SECURITY_ALLOW_UNSAFE]
 
     if (!src) {
       const packageName = `botium-${hookType}-${ref}`
@@ -154,10 +140,10 @@ module.exports = class LogicHookUtils {
         } else if (isClass(CheckClass.PluginClass)) {
           return new CheckClass.PluginClass({ ref, ...this.buildScriptContext }, this.caps, args)
         } else {
-          throw new Error(`${packageName} class or function or PluginClass field expected`)
+          throw new Error('Either class or function or PluginClass field expected')
         }
       } catch (err) {
-        throw new Error(`Failed to fetch hook ${ref} ${hookType} from guessed package ${packageName} - ${err.message}`)
+        throw new Error(`Logic Hook specification ${ref} ${hookType} (${packageName}) invalid: ${err.message}`)
       }
     }
 
@@ -166,14 +152,14 @@ module.exports = class LogicHookUtils {
         const CheckClass = src
         return new CheckClass({ ref, ...this.buildScriptContext }, this.caps, args)
       } catch (err) {
-        throw new Error(`Failed to load package ${ref} from provided class - ${err.message}`)
+        throw new Error(`Logic Hook specification ${ref} from class invalid: ${err.message}`)
       }
     }
     if (_.isFunction(src)) {
       try {
         return src({ ref, ...this.buildScriptContext }, this.caps, args)
       } catch (err) {
-        throw new Error(`Failed to load package ${ref} from provided function - ${err.message}`)
+        throw new Error(`Logic Hook specification ${ref} from function invalid: ${err.message}`)
       }
     }
     if (_.isObject(src) && !_.isString(src)) {
@@ -183,26 +169,15 @@ module.exports = class LogicHookUtils {
             const script = src[key]
             if (_.isFunction(script)) {
               return script(args)
-            } else if (_.isString(script)) {
-              try {
-                const vm = new NodeVM({
-                  eval: false,
-                  require: false,
-                  sandbox: args
-                })
-                return vm.run(script)
-              } catch (err) {
-                throw new Error(`Script ${key} is not valid - ${err.message || err}`)
-              }
             } else {
-              throw new Error(`Script "${key}" is not valid - only functions and javascript code accepted`)
+              throw new Error(`Script ${key} is not valid - only functions accepted`)
             }
           }
           return result
         }, {})
         return hookObject
       } catch (err) {
-        throw new Error(`Failed to load package ${ref} ${hookType} from provided src function - ${err.message}`)
+        throw new Error(`Logic Hook specification ${ref} ${hookType} from provided src (${util.inspect(src)}) invalid: ${err.message}`)
       }
     }
 
@@ -215,8 +190,8 @@ module.exports = class LogicHookUtils {
       }]
       if (src.indexOf('/') >= 0) {
         tryLoads.push({
-          tryLoadPackageName: src.substr(0, src.lastIndexOf('/')),
-          tryLoadAsserterByName: src.substr(src.lastIndexOf('/') + 1)
+          tryLoadPackageName: src.substring(0, src.lastIndexOf('/')),
+          tryLoadAsserterByName: src.substring(src.lastIndexOf('/') + 1)
         })
       }
 
@@ -243,29 +218,34 @@ module.exports = class LogicHookUtils {
         } else if (_.isFunction(CheckClass.PluginClass)) {
           return CheckClass.PluginClass({ ref, ...this.buildScriptContext }, this.caps, args)
         } else {
-          throw new Error(`${src} class or function expected`)
+          throw new Error('Expected class or function')
         }
       }
 
       for (const tryLoad of tryLoads) {
-        const tryLoadFile = path.resolve(process.cwd(), tryLoad.tryLoadPackageName)
-        if (fs.existsSync(tryLoadFile)) {
-          _checkUnsafe()
+        if (this.caps.SAFEDIR) {
+          const tryLoadFile = path.resolve(this.caps.SAFEDIR, tryLoad.tryLoadPackageName)
+          if (tryLoadFile.startsWith(path.resolve(this.caps.SAFEDIR))) {
+            if (fs.existsSync(tryLoadFile)) {
+              try {
+                return tryLoadFromSource(tryLoadFile, tryLoad.tryLoadAsserterByName)
+              } catch (err) {
+                loadErr.push(`Logic Hook specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `)
+              }
+            }
+          }
+        }
+        if (allowUnsafe || tryLoad.tryLoadPackageName.startsWith('botium-')) {
           try {
-            return tryLoadFromSource(tryLoadFile, tryLoad.tryLoadAsserterByName)
+            return tryLoadFromSource(tryLoad.tryLoadPackageName, tryLoad.tryLoadAsserterByName)
           } catch (err) {
-            loadErr.push(`Failed to fetch ${ref} ${hookType} from ${src} - ${err.message} `)
+            loadErr.push(`Logic Hook specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `)
           }
         }
-        try {
-          return tryLoadFromSource(tryLoad.tryLoadPackageName, tryLoad.tryLoadAsserterByName)
-        } catch (err) {
-          loadErr.push(`Failed to fetch ${ref} ${hookType} from ${src} - ${err.message} `)
-        }
       }
 
       loadErr.forEach(debug)
     }
-    throw new Error(`Failed to fetch ${ref} ${hookType}, no idea how to load ...`)
+    throw new Error(`Logic Hook specification ${ref} ${hookType} from "${util.inspect(src)}" invalid : no loader available`)
   }
 }

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

@@ -51,6 +51,6 @@ module.exports = class ConditionalBusinessHoursLogicHook {
     }
     params.now = moment()
     convoStep.conditional.skip = !this._isBetween(params)
-    debug(`ConditionalBusinessHoursLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+    debug(`ConditionalBusinessHoursLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${util.inspect(convoStep.conditional)}`)
   }
 }

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

@@ -32,6 +32,6 @@ module.exports = class ConditionalCapabilityValueBasedLogicHook {
       conditionGroupId
     }
     convoStep.conditional.skip = !this._isCapabilityValueEqual(params)
-    debug(`ConditionalCapabilityValueBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+    debug(`ConditionalCapabilityValueBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${util.inspect(convoStep.conditional)}`)
   }
 }

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

@@ -26,6 +26,6 @@ module.exports = class ConditionalJsonPathBasedLogicHook {
       skip = !(values && values.length > 0 && values.includes(params.value))
     }
     convoStep.conditional.skip = skip
-    debug(`ConditionalJsonPathBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+    debug(`ConditionalJsonPathBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${util.inspect(convoStep.conditional)}`)
   }
 }

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

@@ -41,6 +41,6 @@ module.exports = class ConditionalTimeBasedLogicHook {
     }
     params.now = moment()
     convoStep.conditional.skip = !this._isBetween(params)
-    debug(`ConditionalTimeBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${convoStep.conditional}`)
+    debug(`ConditionalTimeBasedLogicHook onBotPrepare ${convo.header.name}/${convoStep.stepTag}, args: ${util.inspect(args)}, convoStep.conditional: ${util.inspect(convoStep.conditional)}`)
   }
 }

package/test/compiler/precompilerscript.spec.js

@@ -33,13 +33,13 @@ const afterCustom = async (thisParam) => {
 
 describe('compiler.precompiler.script', function () {
   it('should execute non-standard json', async function () {
-    await beforeCustom(this, `
+    await beforeCustom(this, ({ scriptData }) => {
       const utterances = {}
       for (const entry of scriptData) {
         utterances[entry.intent] = entry.sentences
       }
-      module.exports = {utterances}
-    `)
+      return { utterances }
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -54,15 +54,15 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should filter by extension, accepted', async function () {
-    await beforeCustom(this, `
-    if (filename.endsWith('.json')) {
+    await beforeCustom(this, ({ filename, scriptData }) => {
+      if (filename.endsWith('.json')) {
         const utterances = {}
         for (const entry of scriptData) {
           utterances[entry.intent] = entry.sentences
         }
-        module.exports = {utterances}
+        return { utterances }
       }
-    `)
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -71,15 +71,15 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should filter by extension, rejected', async function () {
-    await beforeCustom(this, `
-    if (filename.endsWith('.xxx')) {
+    await beforeCustom(this, ({ filename, scriptData }) => {
+      if (filename.endsWith('.xxx')) {
         const utterances = {}
         for (const entry of scriptData) {
           utterances[entry.intent] = entry.sentences
         }
-        module.exports = {utterances}
+        return { utterances }
       }
-    `)
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -88,15 +88,15 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should filter by content, accepted', async function () {
-    await beforeCustom(this, `
+    await beforeCustom(this, ({ scriptData }) => {
       if (scriptData) {
         const utterances = {}
         for (const entry of scriptData) {
           utterances[entry.intent] = entry.sentences
         }
-        module.exports = {utterances}
+        return { utterances }
       }
-    `)
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -105,15 +105,15 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should filter by content, rejected', async function () {
-    await beforeCustom(this, `
+    await beforeCustom(this, ({ scriptData }) => {
       if (scriptData.utterances) {
         const utterances = {}
         for (const entry of scriptData.utterances) {
           utterances[entry.intent] = entry.sentences
         }
-        module.exports = {utterances}
+        return { utterances }
       }
-  `)
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -122,13 +122,13 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should change extension', async function () {
-    await beforeCustom(this, `
+    await beforeCustom(this, ({ filename, scriptData }) => {
       const utterances = {}
       for (const entry of scriptData) {
         utterances[entry.intent] = entry.sentences
       }
-      module.exports = { scriptBuffer:{utterances}, filename: filename + ".json" }
-  `)
+      return { scriptBuffer: { utterances }, filename: filename + '.json' }
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json.txt')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -137,13 +137,13 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should not read anything without extension change', async function () {
-    await beforeCustom(this, `
+    await beforeCustom(this, ({ scriptData }) => {
       const utterances = {}
       for (const entry of scriptData) {
         utterances[entry.intent] = entry.sentences
       }
-      module.exports = { scriptBuffer:{utterances} }
-  `)
+      return { scriptBuffer: { utterances } }
+    })
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script.json.txt')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()
@@ -152,9 +152,7 @@ describe('compiler.precompiler.script', function () {
   })
 
   it('should be able to precompile text to text', async function () {
-    await beforeCustom(this, `
-      module.exports = scriptData.replace("Hi!", "Hi Bot!")
-  `)
+    await beforeCustom(this, ({ scriptData }) => scriptData.replace('Hi!', 'Hi Bot!'))
     this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'convos_precompiler_script_text_to_text.convo.txt')
     this.compiler.ExpandUtterancesToConvos()
     this.compiler.ExpandConvos()

package/test/connectors/pluginconnectorcontainer.spec.js

@@ -0,0 +1,60 @@
+const assert = require('chai').assert
+const BotDriver = require('../../').BotDriver
+const Capabilities = require('../../').Capabilities
+
+const echoConnectorWithMetadata = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = {
+        sender: 'bot',
+        sourceData: msg.sourceData,
+        messageText: `Response of ${msg.messageText}`
+      }
+      queueBotSays(botMsg)
+    },
+    GetMetaData () {
+      return Promise.resolve('Sample response from GetMetaData')
+    }
+  }
+}
+const echoConnectorWithoutMetadata = ({ queueBotSays }) => {
+  return {
+    UserSays (msg) {
+      const botMsg = {
+        sender: 'bot',
+        sourceData: msg.sourceData,
+        messageText: `Response of ${msg.messageText}`
+      }
+      queueBotSays(botMsg)
+    }
+  }
+}
+
+describe('compiler.precompiler.json', function () {
+  beforeEach(async function () {
+    this.init = async (withGetMetaData) => {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'connector.basecontainer',
+        [Capabilities.CONTAINERMODE]: withGetMetaData ? echoConnectorWithMetadata : echoConnectorWithoutMetadata
+      }
+      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 get metadata if its available', async function () {
+    await this.init(true)
+    const result = await this.container.GetMetaData()
+    assert.equal(result, 'Sample response from GetMetaData')
+  })
+
+  it('should get undefined if metadata is not available', async function () {
+    await this.init(false)
+    const result = await this.container.GetMetaData()
+    assert.equal(result, undefined)
+  })
+})

package/test/connectors/simplerest.spec.js

@@ -50,7 +50,6 @@ const myCapsScriptingMemory = {
     FUNCTION_WITHOUT_PARAM: '{{fnc.year}}',
     FUNCTION_WITH_PARAM: '{{#fnc.random}}5{{/fnc.random}}',
     FUNCTION_WITH_PARAM_FROM_SCRIPTING_MEMORY: '{{#fnc.random}}{{msg.scriptingMemory.functionArgument}}{{/fnc.random}}',
-    USING_CODE: '{{#fnc.func}}1 + 2{{/fnc.func}}',
     SAMPLE_ENV: '{{#fnc.env}}SAMPLE_ENV{{/fnc.env}}',
     VARIABLE: '{{msg.scriptingMemory.variable}}',
     PROJECTNAME: '{{fnc.projectname}}',
@@ -91,11 +90,11 @@ const myCapsHookBase = {
   [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: ['$']
 }
 const myCapsRequestHookFromString = Object.assign({
-  [Capabilities.SIMPLEREST_REQUEST_HOOK]: `
+  [Capabilities.SIMPLEREST_REQUEST_HOOK]: ({ requestOptions, context }) => {
     let counter = 1
-    requestOptions.body = {bodyFieldRequestHook: counter++}
+    requestOptions.body = { bodyFieldRequestHook: counter++ }
     context.contextFieldRequestHook = counter
-  `
+  }
 }, myCapsHookBase)
 const myCapsRequestHookFromStringInvalid = Object.assign({
   [Capabilities.SIMPLEREST_REQUEST_HOOK]: '!'
@@ -108,12 +107,13 @@ const myCapsRequestHookFromFunction = Object.assign({
   }
 }, myCapsHookBase)
 const myCapsRequestHookFromModule = Object.assign({
-  [Capabilities.SIMPLEREST_REQUEST_HOOK]: 'test/connectors/logicHook.js'
+  [Capabilities.SAFEDIR]: './test/connectors/',
+  [Capabilities.SIMPLEREST_REQUEST_HOOK]: 'logicHook.js'
 }, myCapsHookBase)
 const myCapsResponseHook = Object.assign({
-  [Capabilities.SIMPLEREST_RESPONSE_HOOK]: `
-    botMsg.messageText = 'message text from hook'  
-  `
+  [Capabilities.SIMPLEREST_RESPONSE_HOOK]: ({ botMsg }) => {
+    botMsg.messageText = 'message text from hook'
+  }
 }, myCapsHookBase)
 
 const msg = {
@@ -460,9 +460,6 @@ describe('connectors.simplerest', function () {
       assert.exists(request.body.SAMPLE_ENV)
       assert.equal(request.body.SAMPLE_ENV, 'SAMPLE_ENV')
 
-      assert.exists(request.body.USING_CODE)
-      assert.equal(request.body.USING_CODE, 3)
-
       assert.exists(request.body.VARIABLE)
       assert.equal(request.body.VARIABLE, 'varvalue')
 
@@ -519,13 +516,13 @@ describe('connectors.simplerest', function () {
     it('should use request hook, from module', async function () {
       await _assertHook(Object.assign({}, myCapsRequestHookFromModule))
     })
-    it('should use request hook, from invalid string', async function () {
+    it('should reject request hook, from invalid string', async function () {
       const driver = new BotDriver(myCapsRequestHookFromStringInvalid)
       try {
         await driver.Build()
         assert.fail('it should have failed')
       } catch (err) {
-        assert.isTrue(err.message.includes('Cant load hook, syntax is not valid'))
+        assert.isTrue(err.message.includes('Hook specification "\'!\'" invalid'))
       }
     })
     it('should add query params from UPDATE_CUSTOM (without "?")', async function () {
@@ -741,9 +738,9 @@ describe('connectors.simplerest', function () {
       const myCaps = Object.assign({}, myCapsGet, {
         [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: '$.text',
         [Capabilities.SIMPLEREST_MEDIA_JSONPATH]: '$.media',
-        [Capabilities.SIMPLEREST_RESPONSE_HOOK]: `
-        botMsg.nlp = { intent: { name: 'hugo' } }
-      `,
+        [Capabilities.SIMPLEREST_RESPONSE_HOOK]: ({ botMsg }) => {
+          botMsg.nlp = { intent: { name: 'hugo' } }
+        },
         [Capabilities.SIMPLEREST_IGNORE_EMPTY]: true
       })
       const driver = new BotDriver(myCaps)
@@ -764,9 +761,9 @@ describe('connectors.simplerest', function () {
       const myCaps = Object.assign({}, myCapsGet, {
         [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: '$.text',
         [Capabilities.SIMPLEREST_MEDIA_JSONPATH]: '$.media',
-        [Capabilities.SIMPLEREST_RESPONSE_HOOK]: `
-        botMsg.someextradata = 'message text from hook'
-      `,
+        [Capabilities.SIMPLEREST_RESPONSE_HOOK]: ({ botMsg }) => {
+          botMsg.someextradata = 'message text from hook'
+        },
         [Capabilities.SIMPLEREST_IGNORE_EMPTY]: true
       })
       const driver = new BotDriver(myCaps)
@@ -787,9 +784,9 @@ describe('connectors.simplerest', function () {
       const myCaps = Object.assign({}, myCapsGet, {
         [Capabilities.SIMPLEREST_RESPONSE_JSONPATH]: '$.text',
         [Capabilities.SIMPLEREST_MEDIA_JSONPATH]: '$.media',
-        [Capabilities.SIMPLEREST_RESPONSE_HOOK]: `
-        botMsg.messageText = 'message text from hook'
-      `,
+        [Capabilities.SIMPLEREST_RESPONSE_HOOK]: ({ botMsg }) => {
+          botMsg.messageText = 'message text from hook'
+        },
         [Capabilities.SIMPLEREST_IGNORE_EMPTY]: true
       })
       const driver = new BotDriver(myCaps)
@@ -1061,7 +1058,7 @@ describe('connectors.simplerest', 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'
+        [Capabilities.SIMPLEREST_PARSER_HOOK]: ({ body }) => { body.text = JSON.parse(body.text).prop }
       })
 
       this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'responsefromping.convo.txt')
@@ -1074,7 +1071,7 @@ describe('connectors.simplerest', 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 })'
+        [Capabilities.SIMPLEREST_PARSER_HOOK]: ({ changeBody, body }) => changeBody({ text: body })
       })
 
       this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'responsefromping.convo.txt')
@@ -1114,7 +1111,7 @@ describe('connectors.simplerest', 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'
+        [Capabilities.SIMPLEREST_PARSER_HOOK]: ({ body }) => { body.text = JSON.parse(body.text).prop }
       })
 
       this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'responsefromstart.convo.txt')
@@ -1127,7 +1124,7 @@ describe('connectors.simplerest', 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 })'
+        [Capabilities.SIMPLEREST_PARSER_HOOK]: ({ changeBody, body }) => changeBody({ text: body })
       })
 
       this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'responsefromstart.convo.txt')
@@ -1283,7 +1280,7 @@ describe('connectors.simplerest', function () {
         [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"'
+        [Capabilities.SIMPLEREST_POLL_REQUEST_HOOK]: ({ requestOptions }) => { requestOptions.uri = 'https://mock.com/_from_hook' }
       }
       const scope = nock('https://mock.com')
         .get('/endpoint')

package/test/convo/fillAndApplyScriptingMemory.spec.js

@@ -168,7 +168,7 @@ describe('convo.fillAndApplyScriptingMemory', function () {
         [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" }'
+        [Capabilities.CUSTOMHOOK_ONBUILD]: ({ container }) => { console.log('customhooks called'); container.caps.MYTOKEN = 'test1234' }
       }
       const driver = new BotDriver(myCaps)
       const compiler = driver.BuildCompiler()
@@ -847,52 +847,6 @@ describe('convo.fillAndApplyScriptingMemory', function () {
         assert(result.length === 36, '$uniqid invalid')
       })
 
-      it('func', async function () {
-        const result = ScriptingMemory.apply(
-          { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
-          {},
-          '$func(3*5)'
-        )
-
-        assert(result === '15', 'func invalid')
-      })
-      it('func with caps', async function () {
-        const result = ScriptingMemory.apply(
-          { caps: Object.assign({}, CAPS_ENABLE_SCRIPTING_MEMORY, { mycap: 'botium' }) },
-          {},
-          '$func(caps.mycap)'
-        )
-        assert.equal(result, 'botium')
-      })
-      it('func invalid code', async function () {
-        try {
-          ScriptingMemory.apply(
-            { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
-            {},
-            '$func(hugo123)'
-          )
-          assert.fail('should have failed')
-        } catch (err) {
-          assert.isTrue(err.message.indexOf('func function execution failed') >= 0)
-        }
-      })
-      it('func environment variable', async function () {
-        process.env.MY_VAR_VALUE = 'botium'
-        const result = ScriptingMemory.apply(
-          { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
-          {},
-          '$func(process.env.MY_VAR_VALUE)'
-        )
-        assert.equal(result, 'botium')
-      })
-      it('func with moment', async function () {
-        const result = ScriptingMemory.apply(
-          { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
-          {},
-          '$func(moment(\\).subtract(1, "month"\\).startOf("month"\\).format("DD.MM.YYYY"\\))'
-        )
-        assert.equal(result, moment().subtract(1, 'month').startOf('month').format('DD.MM.YYYY'))
-      })
       it('environment variable', async function () {
         process.env.MY_VAR_VALUE = 'botium'
         const result = ScriptingMemory.apply(

package/test/hooks/customhooks.spec.js

@@ -65,28 +65,6 @@ describe('customhooks.hookfromsrc', function () {
     assert.isTrue(onStopCalled)
     assert.isTrue(onCleanCalled)
   })
-  it('should call hooks from string function', async function () {
-    const { container } = await buildDriver({
-      [Capabilities.CUSTOMHOOK_ONBUILD]: 'module.exports = ({ container }) => { container.onBuildCalled = true }',
-      [Capabilities.CUSTOMHOOK_ONSTART]: 'module.exports = ({ container }) => { container.onStartCalled = true }',
-      [Capabilities.CUSTOMHOOK_ONUSERSAYS]: 'module.exports = ({ container }) => { container.onUserSaysCalled = true }',
-      [Capabilities.CUSTOMHOOK_ONBOTRESPONSE]: 'module.exports = ({ container }) => { container.onBotResponseCalled = true }',
-      [Capabilities.CUSTOMHOOK_ONSTOP]: 'module.exports = ({ container }) => { container.onStopCalled = true }',
-      [Capabilities.CUSTOMHOOK_ONCLEAN]: 'module.exports = ({ container }) => { container.onCleanCalled = true }'
-    })
-    await container.Start()
-    await container.UserSaysText('hallo')
-    await container.WaitBotSays()
-    await container.Stop()
-    await container.Clean()
-
-    assert.isTrue(container.onBuildCalled)
-    assert.isTrue(container.onStartCalled)
-    assert.isTrue(container.onUserSaysCalled)
-    assert.isTrue(container.onBotResponseCalled)
-    assert.isTrue(container.onStopCalled)
-    assert.isTrue(container.onCleanCalled)
-  })
   it('should change meMsg from hook', async function () {
     const { container } = await buildDriver({
       [Capabilities.CUSTOMHOOK_ONUSERSAYS]: ({ meMsg }) => {
@@ -115,7 +93,7 @@ describe('customhooks.hookfromsrc', function () {
 
     assert.equal(botMsg.fromHook, 1)
   })
-  it('should call http api from string function', async function () {
+  it('should call http api from function', async function () {
     const scope = nock('https://gettoken.com')
       .get('/get')
       .reply(200, {
@@ -124,7 +102,7 @@ describe('customhooks.hookfromsrc', function () {
       .persist()
 
     const { container } = await buildDriver({
-      [Capabilities.CUSTOMHOOK_ONSTART]: `module.exports = async ({ container, request }) => {
+      [Capabilities.CUSTOMHOOK_ONSTART]: async ({ container, request }) => {
         return new Promise((resolve, reject) => {
           request({ method: 'get', uri: 'https://gettoken.com/get', json: true }, (err, response, body) => {
             if (err) return reject(err)
@@ -132,7 +110,7 @@ describe('customhooks.hookfromsrc', function () {
             resolve()
           })
         })
-      }`
+      }
     })
     await container.Start()
     assert.equal(container.caps.MYTOKEN, 'thisisausertoken')