botium-core 1.14.9 → 1.14.10

package/dist/botium-es.js

@@ -35,7 +35,7 @@ import express from 'express';
 import bodyParser from 'body-parser';
 
 var name = "botium-core";
-var version$1 = "1.14.9";
+var version$1 = "1.14.10";
 var description = "The Selenium for Chatbots";
 var main = "index.js";
 var module = "dist/botium-es.js";
@@ -98,6 +98,7 @@ var dependencies = {
 	"socketio-auth": "^0.1.1",
 	"swagger-jsdoc": "^6.2.8",
 	"swagger-ui-express": "^5.0.0",
+	tinyglobby: "^0.2.10",
 	uuid: "^9.0.1",
 	"word-error-rate": "0.0.7",
 	"write-yaml": "^1.0.0",
@@ -1082,9 +1083,9 @@ var LogicHookUtils_1 = class LogicHookUtils {
     caps
   }) {
     this.asserters = {};
-    this.globalAsserters = [];
+    this.globalAsserterNames = [];
     this.logicHooks = {};
-    this.globalLogicHooks = [];
+    this.globalLogicHookNames = [];
     this.userInputs = {};
     this.buildScriptContext = buildScriptContext;
     this.caps = caps;
@@ -1117,7 +1118,7 @@ var LogicHookUtils_1 = class LogicHookUtils {
       }
       this.asserters[asserter.ref] = this._loadClass(asserter, 'asserter');
       if (asserter.global) {
-        this.globalAsserters.push(asserter.ref);
+        this.globalAsserterNames.push(asserter.ref);
       }
     });
   }
@@ -1128,7 +1129,7 @@ var LogicHookUtils_1 = class LogicHookUtils {
       }
       this.logicHooks[logicHook.ref] = this._loadClass(logicHook, 'logichook');
       if (logicHook.global) {
-        this.globalLogicHooks.push(logicHook.ref);
+        this.globalLogicHookNames.push(logicHook.ref);
       }
     });
   }
@@ -1140,11 +1141,17 @@ var LogicHookUtils_1 = class LogicHookUtils {
       this.userInputs[userInput.ref] = this._loadClass(userInput, 'userinput');
     });
   }
-  getGlobalAsserter() {
-    return this.globalAsserters.map(name => this.asserters[name]);
+  getGlobalAsserters() {
+    return this.globalAsserterNames.reduce((agg, name) => ({
+      ...agg,
+      [name]: this.asserters[name]
+    }), {});
   }
-  getGlobalLogicHook() {
-    return this.globalLogicHooks.map(name => this.logicHooks[name]);
+  getGlobalLogicHooks() {
+    return this.globalLogicHookNames.reduce((agg, name) => ({
+      ...agg,
+      [name]: this.logicHooks[name]
+    }), {});
   }
   _loadClass({
     src,
@@ -2934,6 +2941,10 @@ class Convo$6 {
       let skipTranscriptStep = false;
       let conditionalGroupId = null;
       let conditionMetInGroup = false;
+      let skipOptionalStep = false;
+      // If there are optional step(s) in the conversation, and the message from the bot fails on each optional bot step(s) and/or mandatory bot step, then we have an unexpected message.
+      // So in this case an unexpected error should be shown instead of the latest assertion error.
+      let optionalStepAssertionError = false;
       let globalConvoStepParameters = container.caps[Capabilities.SCRIPTING_CONVO_STEP_PARAMETERS] || {};
       let retryBotMessageTimeoutEnd = null;
       let retryBotMessageConvoId = null;
@@ -2941,6 +2952,13 @@ class Convo$6 {
       for (let i = 0; i < this.conversation.length; i = retryBotMessageDropBotResponse ? i : i + 1) {
         retryBotMessageDropBotResponse = false;
         const convoStep = this.conversation[i];
+        if (!convoStep.optional) {
+          skipOptionalStep = false;
+        }
+        if (convoStep.optional && skipOptionalStep) {
+          // If there are multiple optional steps, and the previous optional step was timeout, then the next optional step should be skipped to prevent too long convo run with multiple timeout.
+          continue;
+        }
         const rawConvoStepParameters = convoStep.logicHooks.find(lh => lh.name === 'CONVO_STEP_PARAMETERS')?.args;
         let convoStepParameters = {};
         if (rawConvoStepParameters && rawConvoStepParameters.length) {
@@ -3125,7 +3143,8 @@ class Convo$6 {
               debug$k(`${this.header.name}: bot says (cleaned by binary and base64 data and sourceData) ${JSON.stringify(coreMsg, null, 2)}`);
             } catch (err) {
               transcriptStep.botEnd = new Date();
-              if (convoStep.optional) {
+              if (!(err.message.indexOf('Bot did not respond within') < 0) && convoStep.optional) {
+                skipOptionalStep = true;
                 continue;
               }
               const failErr = botiumErrorFromErr$1(`${this.header.name}/${convoStep.stepTag}: error waiting for bot - ${err.message}`, err);
@@ -3209,6 +3228,7 @@ class Convo$6 {
                 }
                 waitForBotSays = false;
                 skipTranscriptStep = true;
+                optionalStepAssertionError = true;
                 return true;
               } else if (retryOn) {
                 if (!retryBotMessageTimeoutEnd || retryBotMessageConvoId !== convoStep.stepTag) {
@@ -3226,9 +3246,18 @@ class Convo$6 {
                 }
               }
               if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]) {
-                assertErrors.push(err);
+                if (optionalStepAssertionError) {
+                  optionalStepAssertionError = false;
+                  assertErrors.push(new BotiumError$2(`${this.header.name}: Unexpected message.`));
+                } else {
+                  assertErrors.push(err);
+                }
                 return false;
               } else {
+                if (optionalStepAssertionError) {
+                  optionalStepAssertionError = false;
+                  throw new BotiumError$2(`${this.header.name}: Unexpected message.`);
+                }
                 throw err;
               }
             };
@@ -3242,6 +3271,7 @@ class Convo$6 {
               if (convoStep.not) {
                 try {
                   this.scriptingEvents.assertBotNotResponse(response, tomatch, `${this.header.name}/${convoStep.stepTag}`, lastMeConvoStep, convoStepParameters);
+                  optionalStepAssertionError = false;
                 } catch (err) {
                   if (isErrorHandledWithOptionConvoStep(err)) {
                     continue;
@@ -3250,6 +3280,7 @@ class Convo$6 {
               } else {
                 try {
                   this.scriptingEvents.assertBotResponse(response, tomatch, `${this.header.name}/${convoStep.stepTag}`, lastMeConvoStep, convoStepParameters);
+                  optionalStepAssertionError = false;
                 } catch (err) {
                   if (isErrorHandledWithOptionConvoStep(err)) {
                     continue;
@@ -3259,6 +3290,7 @@ class Convo$6 {
             } else if (convoStep.sourceData) {
               try {
                 this._compareObject(container, scriptingMemory, convoStep, botMsg.sourceData, convoStep.sourceData, botMsg, convoStepParameters);
+                optionalStepAssertionError = false;
               } catch (err) {
                 if (isErrorHandledWithOptionConvoStep(err)) {
                   continue;
@@ -3285,11 +3317,13 @@ class Convo$6 {
                 transcript,
                 transcriptStep
               });
+              optionalStepAssertionError = false;
             } catch (err) {
               const nextConvoStep = this.conversation[i + 1];
               if (convoStep.optional && nextConvoStep && nextConvoStep.sender === 'bot') {
                 waitForBotSays = false;
                 skipTranscriptStep = true;
+                optionalStepAssertionError = true;
                 continue;
               }
               const errors = err.toArray ? err.toArray() : [];
@@ -3318,8 +3352,17 @@ class Convo$6 {
                   this.scriptingEvents.fail && this.scriptingEvents.fail(failErr, lastMeConvoStep);
                 } catch (failErr) {}
                 if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS] && err instanceof BotiumError$2) {
-                  assertErrors.push(err);
+                  if (optionalStepAssertionError) {
+                    optionalStepAssertionError = false;
+                    assertErrors.push(new BotiumError$2(`${this.header.name}: Unexpected message.`));
+                  } else {
+                    assertErrors.push(err);
+                  }
                 } else {
+                  if (optionalStepAssertionError) {
+                    optionalStepAssertionError = false;
+                    throw new BotiumError$2(`${this.header.name}: Unexpected message.`);
+                  }
                   throw failErr;
                 }
               }
@@ -5520,9 +5563,9 @@ var ScriptingProvider_1 = class ScriptingProvider {
     this.utterances = {};
     this.matchFn = null;
     this.asserters = {};
-    this.globalAsserter = {};
+    this.globalAsserters = {};
     this.logicHooks = {};
-    this.globalLogicHook = {};
+    this.globalLogicHooks = {};
     this.userInputs = {};
     this.partialConvos = {};
     this.scriptingMemories = [];
@@ -5891,7 +5934,8 @@ var ScriptingProvider_1 = class ScriptingProvider {
         return p(this.retryHelperAsserter, () => asserter[asserterType](params));
       }
     };
-    const convoAsserter = asserters.filter(a => this.asserters[a.name][asserterType]).map(a => ({
+    const localAsserters = (asserters || []).filter(a => this.asserters[a.name][asserterType]);
+    const convoStepPromises = localAsserters.map(a => ({
       asserter: a,
       promise: callAsserter(a, this.asserters[a.name], {
         convo,
@@ -5906,7 +5950,8 @@ var ScriptingProvider_1 = class ScriptingProvider {
       promise,
       asserter
     }) => updateExceptionContext(promise, asserter));
-    const globalAsserter = Object.values(this.globalAsserter).filter(a => a[asserterType]).map(a => ({
+    const globalAsserters = Object.keys(this.globalAsserters).filter(name => localAsserters.map(a => a.name).indexOf(name) < 0).reduce((agg, name) => [...agg, this.globalAsserters[name]], []).filter(a => a[asserterType]);
+    const globalPromises = globalAsserters.map(a => ({
       asserter: a,
       promise: p(this.retryHelperAsserter, () => a[asserterType]({
         convo,
@@ -5921,7 +5966,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       promise,
       asserter
     }) => updateExceptionContext(promise, asserter));
-    const allPromises = [...convoAsserter, ...globalAsserter];
+    const allPromises = [...convoStepPromises, ...globalPromises];
     if (this.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]) {
       return Promise.allSettled(allPromises).then(results => {
         const rejected = results.filter(result => result.status === 'rejected').map(result => result.reason);
@@ -5956,7 +6001,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       isGlobal: false,
       ...rest
     })));
-    const globalHooks = Object.values(this.globalLogicHook).filter(l => l[hookType]);
+    const globalHooks = Object.keys(this.globalLogicHooks).filter(name => localHooks.map(l => l.name).indexOf(name) < 0).reduce((agg, name) => [...agg, this.globalLogicHooks[name]], []).filter(l => l[hookType]);
     const globalPromises = globalHooks.map(l => p(this.retryHelperLogicHook, () => l[hookType]({
       convo,
       convoStep,
@@ -6076,9 +6121,9 @@ var ScriptingProvider_1 = class ScriptingProvider {
       caps: this.caps
     });
     this.asserters = logicHookUtils.asserters;
-    this.globalAsserter = logicHookUtils.getGlobalAsserter();
+    this.globalAsserters = logicHookUtils.getGlobalAsserters();
     this.logicHooks = logicHookUtils.logicHooks;
-    this.globalLogicHook = logicHookUtils.getGlobalLogicHook();
+    this.globalLogicHooks = logicHookUtils.getGlobalLogicHooks();
     this.userInputs = logicHookUtils.userInputs;
   }
   IsAsserterValid(name) {