botium-core
Version:
The Selenium for Chatbots
1,361 lines (1,343 loc) • 368 kB
JavaScript
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var util = require('util');
var fs = require('fs');
var path = require('path');
var async = require('async');
var rimraf$1 = require('rimraf');
var mkdirp = require('mkdirp');
var sanitizeFilename = require('sanitize-filename');
var moment = require('moment');
var randomatic = require('randomatic');
var lodash = require('lodash');
var boolean$1 = require('boolean');
var events = require('events');
var debug$n = require('debug');
var isClass = require('is-class');
var crypto = require('crypto');
var globby = require('globby');
var promiseRetry = require('promise-retry');
var promise = require('promise.allsettled');
var uuid = require('uuid');
var jsonpath = require('jsonpath');
var isJson$1 = require('is-json');
var wordErrorRate = require('word-error-rate');
var markdownIt = require('markdown-it');
var xlsx = require('xlsx');
var sync = require('csv-parse/sync');
var yaml = require('yaml');
var child_process = require('child_process');
var socket = require('socket.io-client');
var bottleneck = require('bottleneck');
var request = require('request');
var mustache = require('mustache');
var mimeTypes = require('mime-types');
var ioredis = require('ioredis');
var express = require('express');
var bodyParser = require('body-parser');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var util__default = /*#__PURE__*/_interopDefaultLegacy(util);
var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
var async__default = /*#__PURE__*/_interopDefaultLegacy(async);
var rimraf__default = /*#__PURE__*/_interopDefaultLegacy(rimraf$1);
var mkdirp__default = /*#__PURE__*/_interopDefaultLegacy(mkdirp);
var sanitizeFilename__default = /*#__PURE__*/_interopDefaultLegacy(sanitizeFilename);
var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
var randomatic__default = /*#__PURE__*/_interopDefaultLegacy(randomatic);
var lodash__default = /*#__PURE__*/_interopDefaultLegacy(lodash);
var boolean__default = /*#__PURE__*/_interopDefaultLegacy(boolean$1);
var events__default = /*#__PURE__*/_interopDefaultLegacy(events);
var debug__default = /*#__PURE__*/_interopDefaultLegacy(debug$n);
var isClass__default = /*#__PURE__*/_interopDefaultLegacy(isClass);
var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
var globby__default = /*#__PURE__*/_interopDefaultLegacy(globby);
var promiseRetry__default = /*#__PURE__*/_interopDefaultLegacy(promiseRetry);
var promise__default = /*#__PURE__*/_interopDefaultLegacy(promise);
var uuid__default = /*#__PURE__*/_interopDefaultLegacy(uuid);
var jsonpath__default = /*#__PURE__*/_interopDefaultLegacy(jsonpath);
var isJson__default = /*#__PURE__*/_interopDefaultLegacy(isJson$1);
var wordErrorRate__default = /*#__PURE__*/_interopDefaultLegacy(wordErrorRate);
var markdownIt__default = /*#__PURE__*/_interopDefaultLegacy(markdownIt);
var xlsx__default = /*#__PURE__*/_interopDefaultLegacy(xlsx);
var sync__default = /*#__PURE__*/_interopDefaultLegacy(sync);
var yaml__default = /*#__PURE__*/_interopDefaultLegacy(yaml);
var child_process__default = /*#__PURE__*/_interopDefaultLegacy(child_process);
var socket__default = /*#__PURE__*/_interopDefaultLegacy(socket);
var bottleneck__default = /*#__PURE__*/_interopDefaultLegacy(bottleneck);
var request__default = /*#__PURE__*/_interopDefaultLegacy(request);
var mustache__default = /*#__PURE__*/_interopDefaultLegacy(mustache);
var mimeTypes__default = /*#__PURE__*/_interopDefaultLegacy(mimeTypes);
var ioredis__default = /*#__PURE__*/_interopDefaultLegacy(ioredis);
var express__default = /*#__PURE__*/_interopDefaultLegacy(express);
var bodyParser__default = /*#__PURE__*/_interopDefaultLegacy(bodyParser);
var name = "botium-core";
var version$1 = "1.14.0";
var description = "The Selenium for Chatbots";
var main = "index.js";
var module$1 = "dist/botium-es.js";
var engines = {
node: ">=14.0.0"
};
var scripts = {
postinstall: "node ./report.js",
build: "npm run eslint && nyc npm test && nyc check-coverage --lines 50 --functions 50 --branches 35 && rollup -c",
eslint: "eslint \"./src/**/*.js\" \"./test/**/*.js\"",
"eslint-fix": "eslint --fix \"./src/**/*.js\" \"./test/**/*.js\"",
newpatch: "npm version patch",
agent: "node ./src/grid/agent/agent.js",
"agent-jsdoc": "swagger-jsdoc -d ./src/grid/agent/swaggerDef.json -o ./src/grid/agent/swagger.json ./src/grid/agent/routes.js",
link: "npm link botium-connector-dialogflow botium-connector-webdriverio botium-connector-directline3 botium-connector-watson botium-connector-alexa-smapi botium-connector-echo",
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",
"update-dependencies": "npm-check-updates --reject globby,rollup -u --timeout 120000"
};
var repository = {
type: "git",
url: "git+https://github.com/codeforequity-at/botium-core.git"
};
var author = "Florian Treml";
var license = "MIT";
var bugs = {
url: "https://github.com/codeforequity-at/botium-core/issues"
};
var homepage = "https://www.botium.ai";
var dependencies = {
"@babel/runtime": "^7.22.15",
async: "^3.2.4",
"body-parser": "^1.20.2",
boolean: "^3.2.0",
bottleneck: "^2.19.5",
"csv-parse": "^5.5.0",
debug: "^4.3.4",
express: "^4.18.2",
globby: "11.0.4",
ioredis: "^5.3.2",
"is-class": "^0.0.9",
"is-json": "^2.0.1",
jsonpath: "^1.1.1",
lodash: "^4.17.21",
"markdown-it": "^13.0.1",
"mime-types": "^2.1.35",
mkdirp: "^3.0.1",
moment: "^2.29.4",
"moment-timezone": "^0.5.43",
mustache: "^4.2.0",
"promise-retry": "^2.0.1",
"promise.allsettled": "^1.0.7",
randomatic: "^3.1.1",
request: "^2.88.2",
rimraf: "^5.0.1",
"sanitize-filename": "^1.6.3",
slugify: "^1.6.6",
"socket.io": "^4.7.2",
"socket.io-client": "^4.7.2",
"socketio-auth": "^0.1.1",
"swagger-jsdoc": "^6.2.8",
"swagger-ui-express": "^5.0.0",
uuid: "^9.0.0",
"word-error-rate": "0.0.7",
"write-yaml": "^1.0.0",
xlsx: "^0.18.5",
xregexp: "^5.1.1",
yaml: "^2.3.2"
};
var devDependencies = {
"@babel/core": "^7.22.17",
"@babel/node": "^7.22.15",
"@babel/plugin-transform-runtime": "^7.22.15",
"@babel/preset-env": "^7.22.15",
chai: "^4.3.8",
"chai-as-promised": "^7.1.1",
"cross-env": "^7.0.3",
eslint: "^8.49.0",
"eslint-config-standard": "^17.1.0",
"eslint-plugin-import": "^2.28.1",
"eslint-plugin-mocha": "^10.1.0",
"eslint-plugin-n": "^16.1.0",
"eslint-plugin-promise": "^6.1.1",
"eslint-plugin-standard": "^4.1.0",
mocha: "^10.2.0",
nock: "^13.3.3",
"npm-check-updates": "^16.13.3",
nyc: "^15.1.0",
rollup: "2.79.1",
"rollup-plugin-babel": "^4.4.0",
"rollup-plugin-commonjs": "^10.1.0",
"rollup-plugin-json": "^4.0.0",
"rollup-plugin-node-resolve": "^5.2.0"
};
var _package = {
name: name,
version: version$1,
description: description,
main: main,
module: module$1,
engines: engines,
scripts: scripts,
repository: repository,
author: author,
license: license,
bugs: bugs,
homepage: homepage,
dependencies: dependencies,
devDependencies: devDependencies
};
var _package$1 = /*#__PURE__*/Object.freeze({
__proto__: null,
name: name,
version: version$1,
description: description,
main: main,
module: module$1,
engines: engines,
scripts: scripts,
repository: repository,
author: author,
license: license,
bugs: bugs,
homepage: homepage,
dependencies: dependencies,
devDependencies: devDependencies,
'default': _package
});
var Capabilities = {
PROJECTNAME: 'PROJECTNAME',
TESTSESSIONNAME: 'TESTSESSIONNAME',
TESTCASENAME: 'TESTCASENAME',
TEMPDIR: 'TEMPDIR',
SAFEDIR: 'SAFEDIR',
CLEANUPTEMPDIR: 'CLEANUPTEMPDIR',
WAITFORBOTTIMEOUT: 'WAITFORBOTTIMEOUT',
CONTAINERMODE: 'CONTAINERMODE',
PLUGINMODULEPATH: 'PLUGINMODULEPATH',
// falsy or ms/keystroke
SIMULATE_WRITING_SPEED: 'SIMULATE_WRITING_SPEED',
BOTIUMGRIDURL: 'BOTIUMGRIDURL',
BOTIUMAPITOKEN: 'BOTIUMAPITOKEN',
BOTIUMGRIDSLOT: 'BOTIUMGRIDSLOT',
// Simple Rest Bot Settings
SIMPLEREST_PING_URL: 'SIMPLEREST_PING_URL',
SIMPLEREST_PING_VERB: 'SIMPLEREST_PING_VERB',
SIMPLEREST_PING_BODY: 'SIMPLEREST_PING_BODY',
SIMPLEREST_PING_BODY_RAW: 'SIMPLEREST_PING_BODY_RAW',
SIMPLEREST_PING_HEADERS: 'SIMPLEREST_PING_HEADERS',
SIMPLEREST_PING_REQUEST_HOOK: 'SIMPLEREST_PING_REQUEST_HOOK',
SIMPLEREST_PING_RETRIES: 'SIMPLEREST_PING_RETRIES',
SIMPLEREST_PING_TIMEOUT: 'SIMPLEREST_PING_TIMEOUT',
SIMPLEREST_PING_UPDATE_CONTEXT: 'SIMPLEREST_PING_UPDATE_CONTEXT',
SIMPLEREST_PING_PROCESS_RESPONSE: 'SIMPLEREST_PING_PROCESS_RESPONSE',
SIMPLEREST_START_URL: 'SIMPLEREST_START_URL',
SIMPLEREST_START_VERB: 'SIMPLEREST_START_VERB',
SIMPLEREST_START_BODY: 'SIMPLEREST_START_BODY',
SIMPLEREST_START_BODY_RAW: 'SIMPLEREST_START_BODY_RAW',
SIMPLEREST_START_HEADERS: 'SIMPLEREST_START_HEADERS',
SIMPLEREST_START_REQUEST_HOOK: 'SIMPLEREST_START_REQUEST_HOOK',
SIMPLEREST_START_RETRIES: 'SIMPLEREST_START_RETRIES',
SIMPLEREST_START_TIMEOUT: 'SIMPLEREST_START_TIMEOUT',
SIMPLEREST_START_UPDATE_CONTEXT: 'SIMPLEREST_START_UPDATE_CONTEXT',
SIMPLEREST_START_PROCESS_RESPONSE: 'SIMPLEREST_START_PROCESS_RESPONSE',
SIMPLEREST_STOP_URL: 'SIMPLEREST_STOP_URL',
SIMPLEREST_STOP_VERB: 'SIMPLEREST_STOP_VERB',
SIMPLEREST_STOP_BODY: 'SIMPLEREST_STOP_BODY',
SIMPLEREST_STOP_BODY_RAW: 'SIMPLEREST_STOP_BODY_RAW',
SIMPLEREST_STOP_HEADERS: 'SIMPLEREST_STOP_HEADERS',
SIMPLEREST_STOP_REQUEST_HOOK: 'SIMPLEREST_STOP_REQUEST_HOOK',
SIMPLEREST_STOP_RETRIES: 'SIMPLEREST_STOP_RETRIES',
SIMPLEREST_STOP_TIMEOUT: 'SIMPLEREST_STOP_TIMEOUT',
SIMPLEREST_INIT_CONTEXT: 'SIMPLEREST_INIT_CONTEXT',
SIMPLEREST_INIT_TEXT: 'SIMPLEREST_INIT_TEXT',
SIMPLEREST_INIT_PROCESS_RESPONSE: 'SIMPLEREST_INIT_PROCESS_RESPONSE',
SIMPLEREST_PROXY_URL: 'SIMPLEREST_PROXY_URL',
SIMPLEREST_STRICT_SSL: 'SIMPLEREST_STRICT_SSL',
SIMPLEREST_URL: 'SIMPLEREST_URL',
SIMPLEREST_EXTRA_OPTIONS: 'SIMPLEREST_EXTRA_OPTIONS',
SIMPLEREST_IGNORE_EMPTY: 'SIMPLEREST_IGNORE_EMPTY',
SIMPLEREST_TIMEOUT: 'SIMPLEREST_TIMEOUT',
SIMPLEREST_METHOD: 'SIMPLEREST_METHOD',
SIMPLEREST_VERB: 'SIMPLEREST_VERB',
SIMPLEREST_HEADERS_TEMPLATE: 'SIMPLEREST_HEADERS_TEMPLATE',
SIMPLEREST_BODY_TEMPLATE: 'SIMPLEREST_BODY_TEMPLATE',
SIMPLEREST_BODY_RAW: 'SIMPLEREST_BODY_RAW',
SIMPLEREST_START_HOOK: 'SIMPLEREST_START_HOOK',
SIMPLEREST_STOP_HOOK: 'SIMPLEREST_STOP_HOOK',
SIMPLEREST_REQUEST_HOOK: 'SIMPLEREST_REQUEST_HOOK',
SIMPLEREST_PARSER_HOOK: 'SIMPLEREST_PARSER_HOOK',
SIMPLEREST_POLL_URL: 'SIMPLEREST_POLL_URL',
SIMPLEREST_POLL_VERB: 'SIMPLEREST_POLL_VERB',
SIMPLEREST_POLL_BODY: 'SIMPLEREST_POLL_BODY',
SIMPLEREST_POLL_BODY_RAW: 'SIMPLEREST_POLL_BODY_RAW',
SIMPLEREST_POLL_HEADERS: 'SIMPLEREST_POLL_HEADERS',
SIMPLEREST_POLL_REQUEST_HOOK: 'SIMPLEREST_POLL_REQUEST_HOOK',
SIMPLEREST_POLL_INTERVAL: 'SIMPLEREST_POLL_INTERVAL',
SIMPLEREST_POLL_TIMEOUT: 'SIMPLEREST_PING_TIMEOUT',
SIMPLEREST_POLL_UPDATE_CONTEXT: 'SIMPLEREST_POLL_UPDATE_CONTEXT',
SIMPLEREST_CONTEXT_IGNORE_JSONPATH: 'SIMPLEREST_CONTEXT_IGNORE_JSONPATH',
SIMPLEREST_CONTEXT_IGNORE_MATCH: 'SIMPLEREST_CONTEXT_IGNORE_MATCH',
SIMPLEREST_CONTEXT_SKIP_JSONPATH: 'SIMPLEREST_CONTEXT_SKIP_JSONPATH',
SIMPLEREST_CONTEXT_SKIP_MATCH: 'SIMPLEREST_CONTEXT_SKIP_MATCH',
SIMPLEREST_CONTEXT_CONTINUE_JSONPATH: 'SIMPLEREST_CONTEXT_CONTINUE_JSONPATH',
SIMPLEREST_CONTEXT_CONTINUE_MATCH: 'SIMPLEREST_CONTEXT_CONTINUE_MATCH',
SIMPLEREST_BODY_JSONPATH: 'SIMPLEREST_BODY_JSONPATH',
SIMPLEREST_RESPONSE_JSONPATH: 'SIMPLEREST_RESPONSE_JSONPATH',
SIMPLEREST_RESPONSE_HOOK: 'SIMPLEREST_RESPONSE_HOOK',
SIMPLEREST_MEDIA_JSONPATH: 'SIMPLEREST_MEDIA_JSONPATH',
SIMPLEREST_BUTTONS_JSONPATH: 'SIMPLEREST_BUTTONS_JSONPATH',
SIMPLEREST_BUTTONS_TEXT_SUBJSONPATH: 'SIMPLEREST_BUTTONS_TEXT_SUBJSONPATH',
SIMPLEREST_BUTTONS_PAYLOAD_SUBJSONPATH: 'SIMPLEREST_BUTTONS_PAYLOAD_SUBJSONPATH',
SIMPLEREST_CARDS_JSONPATH: 'SIMPLEREST_CARDS_JSONPATH',
SIMPLEREST_CARD_TEXT_JSONPATH: 'SIMPLEREST_CARD_TEXT_JSONPATH',
SIMPLEREST_CARD_SUBTEXT_JSONPATH: 'SIMPLEREST_CARD_SUBTEXT_JSONPATH',
SIMPLEREST_CARD_BUTTONS_JSONPATH: 'SIMPLEREST_CARD_BUTTONS_JSONPATH',
SIMPLEREST_CARD_BUTTONS_TEXT_SUBJSONPATH: 'SIMPLEREST_CARD_BUTTONS_TEXT_SUBJSONPATH',
SIMPLEREST_CARD_BUTTONS_PAYLOAD_SUBJSONPATH: 'SIMPLEREST_CARD_BUTTONS_PAYLOAD_SUBJSONPATH',
SIMPLEREST_CARD_ATTACHMENTS_JSONPATH: 'SIMPLEREST_CARD_ATTACHMENTS_JSONPATH',
SIMPLEREST_CONTEXT_JSONPATH: 'SIMPLEREST_CONTEXT_JSONPATH',
SIMPLEREST_CONTEXT_MERGE_OR_REPLACE: 'SIMPLEREST_CONTEXT_MERGE_OR_REPLACE',
SIMPLEREST_CONVERSATION_ID_TEMPLATE: 'SIMPLEREST_CONVERSATION_ID_TEMPLATE',
SIMPLEREST_STEP_ID_TEMPLATE: 'SIMPLEREST_STEP_ID_TEMPLATE',
SIMPLEREST_INBOUND_REDISURL: 'SIMPLEREST_INBOUND_REDISURL',
SIMPLEREST_INBOUND_ENDPOINT: 'SIMPLEREST_INBOUND_ENDPOINT',
SIMPLEREST_INBOUND_PORT: 'SIMPLEREST_INBOUND_PORT',
SIMPLEREST_INBOUND_SELECTOR_JSONPATH: 'SIMPLEREST_INBOUND_SELECTOR_JSONPATH',
SIMPLEREST_INBOUND_SELECTOR_VALUE: 'SIMPLEREST_INBOUND_SELECTOR_VALUE',
SIMPLEREST_INBOUND_UPDATE_CONTEXT: 'SIMPLEREST_INBOUND_UPDATE_CONTEXT',
SIMPLEREST_REDIS_TOPIC: 'SIMPLEREST_REDIS_TOPIC',
SIMPLEREST_INBOUND_ORDER_UNSETTLED_EVENTS_JSONPATH: 'SIMPLEREST_INBOUND_ORDER_UNSETTLED_EVENTS_JSONPATH',
SIMPLEREST_INBOUND_DEBOUNCE_TIMEOUT: 'SIMPLEREST_INBOUND_DEBOUNCE_TIMEOUT',
SIMPLEREST_COOKIE_REPLICATION: 'SIMPLEREST_COOKIE_REPLICATION',
// Script Compiler
SCRIPTING_TXT_EOL: 'SCRIPTING_TXT_EOL',
// ROW_PER_MESSAGE or QUESTION_ANSWER
SCRIPTING_XLSX_MODE: 'SCRIPTING_XLSX_MODE',
SCRIPTING_XLSX_EOL_WRITE: 'SCRIPTING_XLSX_EOL_WRITE',
SCRIPTING_XLSX_STARTROW: 'SCRIPTING_XLSX_STARTROW',
SCRIPTING_XLSX_STARTCOL: 'SCRIPTING_XLSX_STARTCOL',
SCRIPTING_XLSX_HASNAMECOL: 'SCRIPTING_XLSX_HASNAMECOL',
SCRIPTING_XLSX_HASHEADERS: 'SCRIPTING_XLSX_HASHEADERS',
SCRIPTING_XLSX_SHEETNAMES: 'SCRIPTING_XLSX_SHEETNAMES',
SCRIPTING_XLSX_SHEETNAMES_PCONVOS: 'SCRIPTING_XLSX_SHEETNAMES_PCONVOS',
SCRIPTING_XLSX_SHEETNAMES_UTTERANCES: 'SCRIPTING_XLSX_SHEETNAMES_UTTERANCES',
SCRIPTING_XLSX_SHEETNAMES_SCRIPTING_MEMORY: 'SCRIPTING_XLSX_SHEETNAMES_SCRIPTING_MEMORY',
// hidden capability. All newly in Box created testsets will have this as true. CsvCompiler
// - throws less error (Box reads csv files as utterances, and convo. Compiler cant throw exception if a file is correct, but box tries to load it with incorrect script type)
// 4 or more colums are compiled just as utterances.
SCRIPTING_CSV_LEGACY_MODE_OFF: 'SCRIPTING_CSV_LEGACY_MODE_OFF',
SCRIPTING_CSV_DELIMITER: 'SCRIPTING_CSV_DELIMITER',
SCRIPTING_CSV_SKIP_HEADER: 'SCRIPTING_CSV_SKIP_HEADER',
SCRIPTING_CSV_QUOTE: 'SCRIPTING_CSV_QUOTE',
SCRIPTING_CSV_ESCAPE: 'SCRIPTING_CSV_ESCAPE',
SCRIPTING_CSV_MULTIROW_COLUMN_CONVERSATION_ID: 'SCRIPTING_CSV_MULTIROW_COLUMN_CONVERSATION_ID',
SCRIPTING_CSV_MULTIROW_COLUMN_SENDER: 'SCRIPTING_CSV_MULTIROW_COLUMN_SENDER',
SCRIPTING_CSV_MULTIROW_COLUMN_TEXT: 'SCRIPTING_CSV_MULTIROW_COLUMN_TEXT',
SCRIPTING_CSV_QA_COLUMN_QUESTION: 'SCRIPTING_CSV_QA_COLUMN_QUESTION',
SCRIPTING_CSV_QA_COLUMN_ANSWER: 'SCRIPTING_CSV_QA_COLUMN_ANSWER',
SCRIPTING_CSV_UTTERANCE_STARTROW: 'SCRIPTING_CSV_UTTERANCE_STARTROW',
SCRIPTING_CSV_UTTERANCE_STARTROW_HEADER: 'SCRIPTING_CSV_UTTERANCE_STARTROW_HEADER',
SCRIPTING_CSV_UTTERANCE_STOP_ON_EMPTY: 'SCRIPTING_CSV_UTTERANCE_STOP_ON_EMPTY',
SCRIPTING_NORMALIZE_TEXT: 'SCRIPTING_NORMALIZE_TEXT',
SCRIPTING_ENABLE_MEMORY: 'SCRIPTING_ENABLE_MEMORY',
SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS: 'SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS',
SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS: 'SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS',
SCRIPTING_FORCE_BOT_CONSUMED: 'SCRIPTING_FORCE_BOT_CONSUMED',
// regexp, regexpIgnoreCase, wildcard, wildcardIgnoreCase, wildcardExact, wildcardExactIgnoreCase, include, includeIgnoreCase, equals, equalsIgnoreCase, wer
SCRIPTING_MATCHING_MODE: 'SCRIPTING_MATCHING_MODE',
SCRIPTING_MATCHING_MODE_ARGS: 'SCRIPTING_MATCHING_MODE_ARGS',
// all, first, random
SCRIPTING_UTTEXPANSION_MODE: 'SCRIPTING_UTTEXPANSION_MODE',
SCRIPTING_UTTEXPANSION_RANDOM_COUNT: 'SCRIPTING_UTTEXPANSION_RANDOM_COUNT',
SCRIPTING_UTTEXPANSION_INCOMPREHENSION: 'SCRIPTING_UTTEXPANSION_INCOMPREHENSION',
SCRIPTING_UTTEXPANSION_INCOMPREHENSIONINTENTS: 'SCRIPTING_UTTEXPANSION_INCOMPREHENSIONINTENTS',
SCRIPTING_UTTEXPANSION_INCOMPREHENSIONUTTS: 'SCRIPTING_UTTEXPANSION_INCOMPREHENSIONUTTS',
SCRIPTING_UTTEXPANSION_USENAMEASINTENT: 'SCRIPTING_UTTEXPANSION_USENAMEASINTENT',
// justLineTag, utterance
SCRIPTING_UTTEXPANSION_NAMING_MODE: 'SCRIPTING_UTTEXPANSION_NAMING_MODE',
SCRIPTING_UTTEXPANSION_NAMING_UTTERANCE_MAX: 'SCRIPTING_UTTEXPANSION_NAMING_UTTERANCE_MAX',
// Del original convo or not
SCRIPTING_MEMORYEXPANSION_KEEP_ORIG: 'SCRIPTING_MEMORYEXPANSION_KEEP_ORIG',
// word, non_whitespace, joker
SCRIPTING_MEMORY_MATCHING_MODE: 'SCRIPTING_MEMORY_MATCHING_MODE',
// varnames, testcasenames
SCRIPTING_MEMORY_COLUMN_MODE: 'SCRIPTING_MEMORY_COLUMN_MODE',
// Botium Lifecycle Hooks
CUSTOMHOOK_ONBUILD: 'CUSTOMHOOK_ONBUILD',
CUSTOMHOOK_ONSTART: 'CUSTOMHOOK_ONSTART',
CUSTOMHOOK_ONUSERSAYS: 'CUSTOMHOOK_ONUSERSAYS',
CUSTOMHOOK_ONBOTRESPONSE: 'CUSTOMHOOK_ONBOTRESPONSE',
CUSTOMHOOK_ONSTOP: 'CUSTOMHOOK_ONSTOP',
CUSTOMHOOK_ONCLEAN: 'CUSTOMHOOK_ONCLEAN',
// Extension components
ASSERTERS: 'ASSERTERS',
LOGIC_HOOKS: 'LOGIC_HOOKS',
USER_INPUTS: 'USER_INPUTS',
// API Calls Rate Limiting
RATELIMIT_USERSAYS_MAXCONCURRENT: 'RATELIMIT_USERSAYS_MAXCONCURRENT',
RATELIMIT_USERSAYS_MINTIME: 'RATELIMIT_USERSAYS_MINTIME',
RATELIMIT_BOTTLENECK_FN: 'RATELIMIT_BOTTLENECK_FN',
SECURITY_ALLOW_UNSAFE: 'SECURITY_ALLOW_UNSAFE',
PRECOMPILERS: 'PRECOMPILERS'
};
Capabilities.PROJECTNAME;
Capabilities.TESTSESSIONNAME;
Capabilities.TESTCASENAME;
Capabilities.TEMPDIR;
Capabilities.SAFEDIR;
Capabilities.CLEANUPTEMPDIR;
Capabilities.WAITFORBOTTIMEOUT;
Capabilities.CONTAINERMODE;
Capabilities.PLUGINMODULEPATH;
Capabilities.SIMULATE_WRITING_SPEED;
Capabilities.BOTIUMGRIDURL;
Capabilities.BOTIUMAPITOKEN;
Capabilities.BOTIUMGRIDSLOT;
Capabilities.SIMPLEREST_PING_URL;
Capabilities.SIMPLEREST_PING_VERB;
Capabilities.SIMPLEREST_PING_BODY;
Capabilities.SIMPLEREST_PING_BODY_RAW;
Capabilities.SIMPLEREST_PING_HEADERS;
Capabilities.SIMPLEREST_PING_REQUEST_HOOK;
Capabilities.SIMPLEREST_PING_RETRIES;
Capabilities.SIMPLEREST_PING_TIMEOUT;
Capabilities.SIMPLEREST_PING_UPDATE_CONTEXT;
Capabilities.SIMPLEREST_PING_PROCESS_RESPONSE;
Capabilities.SIMPLEREST_START_URL;
Capabilities.SIMPLEREST_START_VERB;
Capabilities.SIMPLEREST_START_BODY;
Capabilities.SIMPLEREST_START_BODY_RAW;
Capabilities.SIMPLEREST_START_HEADERS;
Capabilities.SIMPLEREST_START_REQUEST_HOOK;
Capabilities.SIMPLEREST_START_RETRIES;
Capabilities.SIMPLEREST_START_TIMEOUT;
Capabilities.SIMPLEREST_START_UPDATE_CONTEXT;
Capabilities.SIMPLEREST_START_PROCESS_RESPONSE;
Capabilities.SIMPLEREST_STOP_URL;
Capabilities.SIMPLEREST_STOP_VERB;
Capabilities.SIMPLEREST_STOP_BODY;
Capabilities.SIMPLEREST_STOP_BODY_RAW;
Capabilities.SIMPLEREST_STOP_HEADERS;
Capabilities.SIMPLEREST_STOP_REQUEST_HOOK;
Capabilities.SIMPLEREST_STOP_RETRIES;
Capabilities.SIMPLEREST_STOP_TIMEOUT;
Capabilities.SIMPLEREST_INIT_CONTEXT;
Capabilities.SIMPLEREST_INIT_TEXT;
Capabilities.SIMPLEREST_INIT_PROCESS_RESPONSE;
Capabilities.SIMPLEREST_PROXY_URL;
Capabilities.SIMPLEREST_STRICT_SSL;
Capabilities.SIMPLEREST_URL;
Capabilities.SIMPLEREST_EXTRA_OPTIONS;
Capabilities.SIMPLEREST_IGNORE_EMPTY;
Capabilities.SIMPLEREST_TIMEOUT;
Capabilities.SIMPLEREST_METHOD;
Capabilities.SIMPLEREST_VERB;
Capabilities.SIMPLEREST_HEADERS_TEMPLATE;
Capabilities.SIMPLEREST_BODY_TEMPLATE;
Capabilities.SIMPLEREST_BODY_RAW;
Capabilities.SIMPLEREST_START_HOOK;
Capabilities.SIMPLEREST_STOP_HOOK;
Capabilities.SIMPLEREST_REQUEST_HOOK;
Capabilities.SIMPLEREST_PARSER_HOOK;
Capabilities.SIMPLEREST_POLL_URL;
Capabilities.SIMPLEREST_POLL_VERB;
Capabilities.SIMPLEREST_POLL_BODY;
Capabilities.SIMPLEREST_POLL_BODY_RAW;
Capabilities.SIMPLEREST_POLL_HEADERS;
Capabilities.SIMPLEREST_POLL_REQUEST_HOOK;
Capabilities.SIMPLEREST_POLL_INTERVAL;
Capabilities.SIMPLEREST_POLL_TIMEOUT;
Capabilities.SIMPLEREST_POLL_UPDATE_CONTEXT;
Capabilities.SIMPLEREST_CONTEXT_IGNORE_JSONPATH;
Capabilities.SIMPLEREST_CONTEXT_IGNORE_MATCH;
Capabilities.SIMPLEREST_CONTEXT_SKIP_JSONPATH;
Capabilities.SIMPLEREST_CONTEXT_SKIP_MATCH;
Capabilities.SIMPLEREST_CONTEXT_CONTINUE_JSONPATH;
Capabilities.SIMPLEREST_CONTEXT_CONTINUE_MATCH;
Capabilities.SIMPLEREST_BODY_JSONPATH;
Capabilities.SIMPLEREST_RESPONSE_JSONPATH;
Capabilities.SIMPLEREST_RESPONSE_HOOK;
Capabilities.SIMPLEREST_MEDIA_JSONPATH;
Capabilities.SIMPLEREST_BUTTONS_JSONPATH;
Capabilities.SIMPLEREST_BUTTONS_TEXT_SUBJSONPATH;
Capabilities.SIMPLEREST_BUTTONS_PAYLOAD_SUBJSONPATH;
Capabilities.SIMPLEREST_CARDS_JSONPATH;
Capabilities.SIMPLEREST_CARD_TEXT_JSONPATH;
Capabilities.SIMPLEREST_CARD_SUBTEXT_JSONPATH;
Capabilities.SIMPLEREST_CARD_BUTTONS_JSONPATH;
Capabilities.SIMPLEREST_CARD_BUTTONS_TEXT_SUBJSONPATH;
Capabilities.SIMPLEREST_CARD_BUTTONS_PAYLOAD_SUBJSONPATH;
Capabilities.SIMPLEREST_CARD_ATTACHMENTS_JSONPATH;
Capabilities.SIMPLEREST_CONTEXT_JSONPATH;
Capabilities.SIMPLEREST_CONTEXT_MERGE_OR_REPLACE;
Capabilities.SIMPLEREST_CONVERSATION_ID_TEMPLATE;
Capabilities.SIMPLEREST_STEP_ID_TEMPLATE;
Capabilities.SIMPLEREST_INBOUND_REDISURL;
Capabilities.SIMPLEREST_INBOUND_ENDPOINT;
Capabilities.SIMPLEREST_INBOUND_PORT;
Capabilities.SIMPLEREST_INBOUND_SELECTOR_JSONPATH;
Capabilities.SIMPLEREST_INBOUND_SELECTOR_VALUE;
Capabilities.SIMPLEREST_INBOUND_UPDATE_CONTEXT;
Capabilities.SIMPLEREST_REDIS_TOPIC;
Capabilities.SIMPLEREST_INBOUND_ORDER_UNSETTLED_EVENTS_JSONPATH;
Capabilities.SIMPLEREST_INBOUND_DEBOUNCE_TIMEOUT;
Capabilities.SIMPLEREST_COOKIE_REPLICATION;
Capabilities.SCRIPTING_TXT_EOL;
Capabilities.SCRIPTING_XLSX_MODE;
Capabilities.SCRIPTING_XLSX_EOL_WRITE;
Capabilities.SCRIPTING_XLSX_STARTROW;
Capabilities.SCRIPTING_XLSX_STARTCOL;
Capabilities.SCRIPTING_XLSX_HASNAMECOL;
Capabilities.SCRIPTING_XLSX_HASHEADERS;
Capabilities.SCRIPTING_XLSX_SHEETNAMES;
Capabilities.SCRIPTING_XLSX_SHEETNAMES_PCONVOS;
Capabilities.SCRIPTING_XLSX_SHEETNAMES_UTTERANCES;
Capabilities.SCRIPTING_XLSX_SHEETNAMES_SCRIPTING_MEMORY;
Capabilities.SCRIPTING_CSV_LEGACY_MODE_OFF;
Capabilities.SCRIPTING_CSV_DELIMITER;
Capabilities.SCRIPTING_CSV_SKIP_HEADER;
Capabilities.SCRIPTING_CSV_QUOTE;
Capabilities.SCRIPTING_CSV_ESCAPE;
Capabilities.SCRIPTING_CSV_MULTIROW_COLUMN_CONVERSATION_ID;
Capabilities.SCRIPTING_CSV_MULTIROW_COLUMN_SENDER;
Capabilities.SCRIPTING_CSV_MULTIROW_COLUMN_TEXT;
Capabilities.SCRIPTING_CSV_QA_COLUMN_QUESTION;
Capabilities.SCRIPTING_CSV_QA_COLUMN_ANSWER;
Capabilities.SCRIPTING_CSV_UTTERANCE_STARTROW;
Capabilities.SCRIPTING_CSV_UTTERANCE_STARTROW_HEADER;
Capabilities.SCRIPTING_CSV_UTTERANCE_STOP_ON_EMPTY;
Capabilities.SCRIPTING_NORMALIZE_TEXT;
Capabilities.SCRIPTING_ENABLE_MEMORY;
Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS;
Capabilities.SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS;
Capabilities.SCRIPTING_FORCE_BOT_CONSUMED;
Capabilities.SCRIPTING_MATCHING_MODE;
Capabilities.SCRIPTING_MATCHING_MODE_ARGS;
Capabilities.SCRIPTING_UTTEXPANSION_MODE;
Capabilities.SCRIPTING_UTTEXPANSION_RANDOM_COUNT;
Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSION;
Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSIONINTENTS;
Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSIONUTTS;
Capabilities.SCRIPTING_UTTEXPANSION_USENAMEASINTENT;
Capabilities.SCRIPTING_UTTEXPANSION_NAMING_MODE;
Capabilities.SCRIPTING_UTTEXPANSION_NAMING_UTTERANCE_MAX;
Capabilities.SCRIPTING_MEMORYEXPANSION_KEEP_ORIG;
Capabilities.SCRIPTING_MEMORY_MATCHING_MODE;
Capabilities.SCRIPTING_MEMORY_COLUMN_MODE;
Capabilities.CUSTOMHOOK_ONBUILD;
Capabilities.CUSTOMHOOK_ONSTART;
Capabilities.CUSTOMHOOK_ONUSERSAYS;
Capabilities.CUSTOMHOOK_ONBOTRESPONSE;
Capabilities.CUSTOMHOOK_ONSTOP;
Capabilities.CUSTOMHOOK_ONCLEAN;
Capabilities.ASSERTERS;
Capabilities.LOGIC_HOOKS;
Capabilities.USER_INPUTS;
Capabilities.RATELIMIT_USERSAYS_MAXCONCURRENT;
Capabilities.RATELIMIT_USERSAYS_MINTIME;
Capabilities.RATELIMIT_BOTTLENECK_FN;
Capabilities.SECURITY_ALLOW_UNSAFE;
Capabilities.PRECOMPILERS;
var Source = {
LOCALPATH: 'LOCALPATH',
GITPATH: 'GITPATH',
GITURL: 'GITURL',
GITBRANCH: 'GITBRANCH',
GITDIR: 'GITDIR',
GITPREPARECMD: 'GITPREPARECMD'
};
Source.LOCALPATH;
Source.GITPATH;
Source.GITURL;
Source.GITBRANCH;
Source.GITDIR;
Source.GITPREPARECMD;
var Defaults$1 = {
Capabilities: {
[Capabilities.PROJECTNAME]: 'Botium Project',
[Capabilities.TESTSESSIONNAME]: 'Botium Test Session',
[Capabilities.TESTCASENAME]: 'Botium Test Case',
[Capabilities.TEMPDIR]: 'botiumwork',
[Capabilities.CLEANUPTEMPDIR]: true,
[Capabilities.WAITFORBOTTIMEOUT]: 10000,
[Capabilities.SIMPLEREST_PING_RETRIES]: 6,
[Capabilities.SIMPLEREST_PING_TIMEOUT]: 10000,
[Capabilities.SIMPLEREST_PING_VERB]: 'GET',
[Capabilities.SIMPLEREST_PING_UPDATE_CONTEXT]: true,
[Capabilities.SIMPLEREST_PING_PROCESS_RESPONSE]: false,
[Capabilities.SIMPLEREST_INIT_PROCESS_RESPONSE]: false,
[Capabilities.SIMPLEREST_STOP_RETRIES]: 6,
[Capabilities.SIMPLEREST_STOP_TIMEOUT]: 10000,
[Capabilities.SIMPLEREST_STOP_VERB]: 'GET',
[Capabilities.SIMPLEREST_START_RETRIES]: 6,
[Capabilities.SIMPLEREST_START_TIMEOUT]: 10000,
[Capabilities.SIMPLEREST_START_UPDATE_CONTEXT]: true,
[Capabilities.SIMPLEREST_START_PROCESS_RESPONSE]: true,
[Capabilities.SIMPLEREST_START_VERB]: 'GET',
[Capabilities.SIMPLEREST_POLL_VERB]: 'GET',
[Capabilities.SIMPLEREST_POLL_INTERVAL]: 1000,
[Capabilities.SIMPLEREST_POLL_TIMEOUT]: 10000,
[Capabilities.SIMPLEREST_POLL_UPDATE_CONTEXT]: true,
[Capabilities.SIMPLEREST_METHOD]: 'GET',
[Capabilities.SIMPLEREST_IGNORE_EMPTY]: true,
[Capabilities.SIMPLEREST_TIMEOUT]: 10000,
[Capabilities.SIMPLEREST_STRICT_SSL]: true,
[Capabilities.SIMPLEREST_INBOUND_UPDATE_CONTEXT]: true,
[Capabilities.SIMPLEREST_CONTEXT_MERGE_OR_REPLACE]: 'MERGE',
[Capabilities.SIMPLEREST_COOKIE_REPLICATION]: true,
[Capabilities.SCRIPTING_TXT_EOL]: '\n',
[Capabilities.SCRIPTING_XLSX_EOL_WRITE]: '\r\n',
[Capabilities.SCRIPTING_XLSX_HASHEADERS]: true,
[Capabilities.SCRIPTING_CSV_SKIP_HEADER]: true,
[Capabilities.SCRIPTING_CSV_QUOTE]: '"',
[Capabilities.SCRIPTING_CSV_ESCAPE]: '"',
[Capabilities.SCRIPTING_NORMALIZE_TEXT]: true,
[Capabilities.SCRIPTING_ENABLE_MEMORY]: false,
[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS]: false,
[Capabilities.SCRIPTING_MATCHING_MODE]: 'wildcardIgnoreCase',
[Capabilities.SCRIPTING_UTTEXPANSION_MODE]: 'all',
[Capabilities.SCRIPTING_UTTEXPANSION_RANDOM_COUNT]: 1,
[Capabilities.SCRIPTING_UTTEXPANSION_NAMING_MODE]: 'justLineTag',
[Capabilities.SCRIPTING_UTTEXPANSION_NAMING_UTTERANCE_MAX]: '16',
[Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSION]: null,
[Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSIONINTENTS]: [],
[Capabilities.SCRIPTING_UTTEXPANSION_INCOMPREHENSIONUTTS]: [],
[Capabilities.SCRIPTING_UTTEXPANSION_USENAMEASINTENT]: false,
[Capabilities.SCRIPTING_MEMORYEXPANSION_KEEP_ORIG]: false,
[Capabilities.SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS]: false,
[Capabilities.SCRIPTING_FORCE_BOT_CONSUMED]: false,
[Capabilities.ASSERTERS]: [],
[Capabilities.LOGIC_HOOKS]: [],
[Capabilities.USER_INPUTS]: [],
[Capabilities.SECURITY_ALLOW_UNSAFE]: true
},
Sources: {
[Source.LOCALPATH]: '.',
[Source.GITPATH]: 'git',
[Source.GITBRANCH]: 'master',
[Source.GITDIR]: '.'
},
Envs: {
IS_BOTIUM_CONTAINER: true
}
};
Defaults$1.Capabilities;
Defaults$1.Sources;
Defaults$1.Envs;
var Fluent_1 = class Fluent {
constructor(driver) {
this.driver = driver;
this.compiler = null;
this.container = null;
this.currentChannel = null;
this.tasks = [];
this.tasks.push(() => {
return new Promise((resolve, reject) => {
this.driver.Build().then(container => {
this.container = container;
resolve();
}).catch(err => {
reject(err);
});
});
});
}
Exec() {
return new Promise((resolve, reject) => {
async__default["default"].eachSeries(this.tasks, (task, cb) => {
try {
const taskResult = task();
if (taskResult && taskResult.then) {
taskResult.then(() => cb()).catch(cb);
} else {
cb();
}
} catch (err) {
cb(err);
}
}, err => {
if (err) return reject(err);
resolve();
});
});
}
Start() {
this.tasks.push(() => {
return this.container.Start();
});
return this;
}
SwitchChannel(channel) {
this.tasks.push(() => {
this.currentChannel = channel;
return Promise.resolve();
});
return this;
}
ReadScripts(convoDir, globFilter) {
this.tasks.push(() => {
return new Promise((resolve, reject) => {
if (this.compiler == null) {
try {
this.compiler = this.driver.BuildCompiler();
} catch (err) {
return reject(err);
}
}
try {
this.compiler.ReadScriptsFromDirectory(convoDir, globFilter);
resolve();
} catch (err) {
reject(err);
}
});
});
return this;
}
Compile(scriptBuffer, scriptFormat, scriptType) {
this.tasks.push(() => {
return new Promise((resolve, reject) => {
if (this.compiler == null) {
try {
this.compiler = this.driver.BuildCompiler();
} catch (err) {
return reject(err);
}
}
try {
this.compiler.Compile(scriptBuffer, scriptFormat, scriptType);
resolve();
} catch (err) {
reject(err);
}
});
});
return this;
}
RunScripts(assertCb, failCb) {
this.tasks.push(() => {
return new Promise((resolve, reject) => {
if (assertCb) {
this.compiler.scriptingEvents.assertBotResponse = assertCb.bind(this.compiler);
}
if (failCb) {
this.compiler.scriptingEvents.fail = failCb.bind(this.compiler);
}
this.compiler.ExpandConvos();
async__default["default"].eachSeries(this.compiler.convos, (convo, convoDone) => {
this.container.Start().then(() => convo.Run(this.container)).then(() => this.container.Stop()).then(() => convoDone()).catch(convoDone);
}, err => {
if (err) return reject(err);else resolve();
});
});
});
return this;
}
UserSaysText(msg) {
this.tasks.push(() => {
if (lodash__default["default"].isFunction(msg)) {
msg = msg();
}
if (this.currentChannel) {
return this.container.UserSays({
messageText: msg,
channel: this.currentChannel
});
} else {
return this.container.UserSaysText(msg);
}
});
return this;
}
UserSays(msg) {
this.tasks.push(() => {
if (lodash__default["default"].isFunction(msg)) {
msg = msg();
}
if (this.currentChannel && !msg.channel) {
msg = Object.assign({}, msg);
msg.channel = this.currentChannel;
}
return this.container.UserSays(msg);
});
return this;
}
WaitBotSays(channel = null, timeoutMillis = null, callback = null) {
if (!callback) {
if (timeoutMillis && lodash__default["default"].isFunction(timeoutMillis)) {
callback = timeoutMillis;
timeoutMillis = null;
} else if (!timeoutMillis && channel && lodash__default["default"].isFunction(channel)) {
callback = channel;
timeoutMillis = null;
channel = null;
}
}
this.tasks.push(() => {
return new Promise((resolve, reject) => {
if (this.currentChannel && !channel) {
channel = this.currentChannel;
}
this.container.WaitBotSays(channel, timeoutMillis).then(botMsg => {
if (callback) callback(botMsg);
resolve();
}).catch(err => {
reject(err);
});
});
});
return this;
}
WaitBotSaysText(channel = null, timeoutMillis = null, callback = null) {
if (!callback) {
if (timeoutMillis && lodash__default["default"].isFunction(timeoutMillis)) {
callback = timeoutMillis;
timeoutMillis = null;
} else if (!timeoutMillis && channel && lodash__default["default"].isFunction(channel)) {
callback = channel;
timeoutMillis = null;
channel = null;
}
}
this.tasks.push(() => {
return new Promise((resolve, reject) => {
if (this.currentChannel && !channel) {
channel = this.currentChannel;
}
this.container.WaitBotSaysText(channel, timeoutMillis).then(text => {
if (callback) callback(text);
resolve();
}).catch(err => {
reject(err);
});
});
});
return this;
}
Restart() {
this.tasks.push(() => {
return this.container.Restart();
});
return this;
}
Stop() {
this.tasks.push(() => {
return this.container.Stop();
});
return this;
}
Clean() {
this.tasks.push(() => {
return this.container.Clean();
});
return this;
}
Call(customFunction) {
this.tasks.push(() => {
return customFunction(this) || Promise.resolve();
});
return this;
}
};
var Events = {
// Botium Events
CONTAINER_BUILDING: 'CONTAINER_BUILDING',
CONTAINER_BUILT: 'CONTAINER_BUILT',
CONTAINER_BUILD_ERROR: 'CONTAINER_BUILD_ERROR',
CONTAINER_STARTING: 'CONTAINER_STARTING',
CONTAINER_STARTED: 'CONTAINER_STARTED',
CONTAINER_START_ERROR: 'CONTAINER_START_ERROR',
CONTAINER_STOPPING: 'CONTAINER_STOPPING',
CONTAINER_STOPPED: 'CONTAINER_STOPPED',
CONTAINER_STOP_ERROR: 'CONTAINER_STOP_ERROR',
CONTAINER_CLEANING: 'CONTAINER_CLEANING',
CONTAINER_CLEANED: 'CONTAINER_CLEANED',
CONTAINER_CLEAN_ERROR: 'CONTAINER_CLEAN_ERROR',
BOT_CONNECTED: 'BOT_CONNECTED',
CONVO_STEP_NEXT: 'CONVO_STEP_NEXT',
// Chatbot Events
MESSAGE_SENTTOBOT: 'MESSAGE_SENTTOBOT',
MESSAGE_SENDTOBOT_ERROR: 'MESSAGE_SENDTOBOT_ERROR',
MESSAGE_RECEIVEDFROMBOT: 'MESSAGE_RECEIVEDFROMBOT',
MESSAGE_RECEIVEFROMBOT_ERROR: 'MESSAGE_RECEIVEFROMBOT_ERROR',
MESSAGE_ATTACHMENT: 'MESSAGE_ATTACHMENT',
MESSAGE_TRANSCRIPT: 'MESSAGE_TRANSCRIPT',
// Botium Agent Events
TOOMUCHWORKERS_ERROR: 'TOOMUCHWORKERS_ERROR'
};
Events.CONTAINER_BUILDING;
Events.CONTAINER_BUILT;
Events.CONTAINER_BUILD_ERROR;
Events.CONTAINER_STARTING;
Events.CONTAINER_STARTED;
Events.CONTAINER_START_ERROR;
Events.CONTAINER_STOPPING;
Events.CONTAINER_STOPPED;
Events.CONTAINER_STOP_ERROR;
Events.CONTAINER_CLEANING;
Events.CONTAINER_CLEANED;
Events.CONTAINER_CLEAN_ERROR;
Events.BOT_CONNECTED;
Events.CONVO_STEP_NEXT;
Events.MESSAGE_SENTTOBOT;
Events.MESSAGE_SENDTOBOT_ERROR;
Events.MESSAGE_RECEIVEDFROMBOT;
Events.MESSAGE_RECEIVEFROMBOT_ERROR;
Events.MESSAGE_ATTACHMENT;
Events.MESSAGE_TRANSCRIPT;
Events.TOOMUCHWORKERS_ERROR;
function commonjsRequire () {
throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
}
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
function getCjsExportFromNamespace (n) {
return n && n['default'] || n;
}
const LOGIC_HOOK_INCLUDE$1 = 'INCLUDE';
var LogicHookConsts = {
LOGIC_HOOK_INCLUDE: LOGIC_HOOK_INCLUDE$1,
DEFAULT_ASSERTERS: [{
name: 'BUTTONS',
className: 'ButtonsAsserter'
}, {
name: 'BUTTONS_COUNT',
className: 'ButtonsCountAsserter'
}, {
name: 'BUTTONS_COUNT_REC',
className: 'ButtonsCountRecAsserter'
}, {
name: 'MEDIA',
className: 'MediaAsserter'
}, {
name: 'MEDIA_COUNT',
className: 'MediaCountAsserter'
}, {
name: 'MEDIA_COUNT_REC',
className: 'MediaCountRecAsserter'
}, {
name: 'CARDS',
className: 'CardsAsserter'
}, {
name: 'CARDS_COUNT',
className: 'CardsCountAsserter'
}, {
name: 'CARDS_COUNT_REC',
className: 'CardsCountRecAsserter'
}, {
name: 'PAUSE_ASSERTER',
className: 'PauseAsserter'
}, {
name: 'JSON_PATH',
className: 'JsonPathAsserter'
}, {
name: 'JSON_PATH_COUNT',
className: 'JsonPathCountAsserter'
}, {
name: 'RESPONSE_LENGTH',
className: 'ResponseLengthAsserter'
}, {
name: 'FORMS',
className: 'FormsAsserter'
}, {
name: 'ENTITIES',
className: 'EntitiesAsserter'
}, {
name: 'ENTITY_VALUES',
className: 'EntityValuesAsserter'
}, {
name: 'ENTITY_CONTENT',
className: 'EntityContentAsserter'
}, {
name: 'INTENT',
className: 'IntentAsserter'
}, {
name: 'INTENT_UNIQUE',
className: 'IntentUniqueAsserter'
}, {
name: 'INTENT_CONFIDENCE',
className: 'IntentConfidenceAsserter'
}, {
name: 'TEXT_CONTAINS_ANY',
className: 'TextContainsAnyAsserter'
}, {
name: 'TEXT_CONTAINS_ANY_IC',
className: 'TextContainsAnyICAsserter'
}, {
name: 'TEXT_CONTAINS_ALL',
className: 'TextContainsAllAsserter'
}, {
name: 'TEXT_CONTAINS_ALL_IC',
className: 'TextContainsAllICAsserter'
}, {
name: 'TEXT_WILDCARD_ANY',
className: 'TextWildcardAnyAsserter'
}, {
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'
}, {
name: 'TEXT_REGEXP_ALL_IC',
className: 'TextRegexpAllICAsserter'
}, {
name: 'TEXT_EQUALS',
className: 'TextEqualsAnyAsserter'
}, {
name: 'TEXT_EQUALS_IC',
className: 'TextEqualsAnyICAsserter'
}, {
name: 'TEXT',
className: 'TextEqualsAnyAsserter'
}, {
name: 'TEXT_IC',
className: 'TextEqualsAnyICAsserter'
}, {
name: 'TEXT_WER',
className: 'WerAsserter'
}, {
name: 'BOT_CONSUMED',
className: 'BotRepliesConsumedAsserter'
}, {
name: 'BOT_UNCONSUMED_COUNT',
className: 'BotRepliesUnconsumedCountAsserter'
}],
DEFAULT_LOGIC_HOOKS: [{
name: 'PAUSE',
className: 'PauseLogicHook'
}, {
name: 'WAITFORBOT',
className: 'WaitForBotLogicHook'
}, {
name: 'SET_SCRIPTING_MEMORY',
className: 'SetScriptingMemoryLogicHook'
}, {
name: 'CLEAR_SCRIPTING_MEMORY',
className: 'ClearScriptingMemoryLogicHook'
}, {
name: 'ASSIGN_SCRIPTING_MEMORY',
className: 'AssignScriptingMemoryLogicHook'
}, {
name: 'UPDATE_CUSTOM',
className: 'UpdateCustomLogicHook'
}, {
name: 'SKIP_BOT_UNCONSUMED',
className: 'ClearQueueLogicHook'
}, {
name: LOGIC_HOOK_INCLUDE$1,
className: 'IncludeLogicHook'
}, {
name: 'CONDITIONAL_STEP_TIME_BASED',
className: 'ConditionalTimeBasedLogicHook'
}, {
name: 'CONDITIONAL_STEP_BUSINESS_HOURS',
className: 'ConditionalBusinessHoursLogicHook'
}, {
name: 'CONDITIONAL_STEP_CAPABILITY_VALUE_BASED',
className: 'ConditionalCapabilityValueBasedLogicHook'
}, {
name: 'CONDITIONAL_STEP_JSON_PATH_BASED',
className: 'ConditionalJsonPathBasedLogicHook.js'
}],
DEFAULT_USER_INPUTS: [{
name: 'BUTTON',
className: 'ButtonInput'
}, {
name: 'MEDIA',
className: 'MediaInput'
}, {
name: 'FORM',
className: 'FormInput'
}]
};
LogicHookConsts.LOGIC_HOOK_INCLUDE;
LogicHookConsts.DEFAULT_ASSERTERS;
LogicHookConsts.DEFAULT_LOGIC_HOOKS;
LogicHookConsts.DEFAULT_USER_INPUTS;
const debug$m = debug__default["default"]('botium-core-asserterUtils');
const {
DEFAULT_ASSERTERS,
DEFAULT_LOGIC_HOOKS,
DEFAULT_USER_INPUTS
} = LogicHookConsts;
DEFAULT_ASSERTERS.forEach(asserter => {
asserter.Class = commonjsRequire(`./asserter/${asserter.className}`);
});
DEFAULT_LOGIC_HOOKS.forEach(logicHook => {
logicHook.Class = commonjsRequire(`./logichooks/${logicHook.className}`);
});
DEFAULT_USER_INPUTS.forEach(userInput => {
userInput.Class = commonjsRequire(`./userinput/${userInput.className}`);
});
var LogicHookUtils_1 = class LogicHookUtils {
constructor({
buildScriptContext,
caps
}) {
this.asserters = {};
this.globalAsserters = [];
this.logicHooks = {};
this.globalLogicHooks = [];
this.userInputs = {};
this.buildScriptContext = buildScriptContext;
this.caps = caps;
this._setDefaultAsserters();
this._setDefaultLogicHooks();
this._setDefaultUserInputs();
this._fetchAsserters();
this._fetchLogicHooks();
this._fetchUserInputs();
}
_setDefaultAsserters() {
DEFAULT_ASSERTERS.forEach(asserter => {
this.asserters[asserter.name] = new asserter.Class(this.buildScriptContext, this.caps);
});
}
_setDefaultLogicHooks() {
DEFAULT_LOGIC_HOOKS.forEach(lh => {
this.logicHooks[lh.name] = new lh.Class(this.buildScriptContext, this.caps);
});
}
_setDefaultUserInputs() {
DEFAULT_USER_INPUTS.forEach(ui => {
this.userInputs[ui.name] = new ui.Class(this.buildScriptContext, this.caps);
});
}
_fetchAsserters() {
this.caps[Capabilities.ASSERTERS].forEach(asserter => {
if (this.asserters[asserter.ref]) {
debug$m(`${asserter.ref} asserter already exists, overwriting.`);
}
this.asserters[asserter.ref] = this._loadClass(asserter, 'asserter');
if (asserter.global) {
this.globalAsserters.push(asserter.ref);
}
});
}
_fetchLogicHooks() {
this.caps[Capabilities.LOGIC_HOOKS].forEach(logicHook => {
if (this.logicHooks[logicHook.ref]) {
debug$m(`${logicHook.ref} logic hook already exists, overwriting.`);
}
this.logicHooks[logicHook.ref] = this._loadClass(logicHook, 'logichook');
if (logicHook.global) {
this.globalLogicHooks.push(logicHook.ref);
}
});
}
_fetchUserInputs() {
this.caps[Capabilities.USER_INPUTS].forEach(userInput => {
if (this.userInputs[userInput.ref]) {
debug$m(`${userInput.ref} userinput already exists, overwriting.`);
}
this.userInputs[userInput.ref] = this._loadClass(userInput, 'userinput');
});
}
getGlobalAsserter() {
return this.globalAsserters.map(name => this.asserters[name]);
}
getGlobalLogicHook() {
return this.globalLogicHooks.map(name => this.logicHooks[name]);
}
_loadClass({
src,
ref,
args
}, hookType) {
if (hookType !== 'asserter' && hookType !== 'logichook' && hookType !== 'userinput') {
throw Error(`Unknown hookType ${hookType}`);
}
// 1 gives possibility to use default asserter as global asserter
if (hookType === 'asserter') {
const asserter = DEFAULT_ASSERTERS.find(asserter => src === asserter.className || src === asserter.name);
if (asserter) {
return new asserter.Class({
ref,
...this.buildScriptContext
}, this.caps, args);
}
}
if (hookType === 'logichook') {
const lh = DEFAULT_LOGIC_HOOKS.find(lh => src === lh.className || src === lh.name);
if (lh) {
return new lh.Class({
ref,
...this.buildScriptContext
}, this.caps, args);
}
}
if (hookType === 'userinput') {
const ui = DEFAULT_USER_INPUTS.find(ui => src === ui.className || src === ui.name);
if (ui) {
return new ui.Class({
ref,
...this.buildScriptContext
}, this.caps, args);
}
}
const allowUnsafe = !!this.caps[Capabilities.SECURITY_ALLOW_UNSAFE];
if (!src) {
const packageName = `botium-${hookType}-${ref}`;
try {
const CheckClass = commonjsRequire(packageName);
if (isClass__default["default"](CheckClass)) {
return new CheckClass({
ref,
...this.buildScriptContext
}, this.caps, args);
} else if (lodash__default["default"].isFunction(CheckClass)) {
return CheckClass({
ref,
...this.buildScriptContext
}, this.caps, args);
} else if (isClass__default["default"](CheckClass.PluginClass)) {
return new CheckClass.PluginClass({
ref,
...this.buildScriptContext
}, this.caps, args);
} else {
throw new Error('Either class or function or PluginClass field expected');
}
} catch (err) {
throw new Error(`Logic Hook specification ${ref} ${hookType} (${packageName}) invalid: ${err.message}`);
}
}
if (isClass__default["default"](src)) {
try {
const CheckClass = src;
return new CheckClass({
ref,
...this.buildScriptContext
}, this.caps, args);
} catch (err) {
throw new Error(`Logic Hook specification ${ref} from class invalid: ${err.message}`);
}
}
if (lodash__default["default"].isFunction(src)) {
try {
return src({
ref,
...this.buildScriptContext
}, this.caps, args);
} catch (err) {
throw new Error(`Logic Hook specification ${ref} from function invalid: ${err.message}`);
}
}
if (lodash__default["default"].isObject(src) && !lodash__default["default"].isString(src)) {
try {
const hookObject = Object.keys(src).reduce((result, key) => {
result[key] = args => {
const script = src[key];
if (lodash__default["default"].isFunction(script)) {
return script(args);
} else {
throw new Error(`Script ${key} is not valid - only functions accepted`);
}
};
return result;
}, {});
return hookObject;
} catch (err) {
throw new Error(`Logic Hook specification ${ref} ${hookType} from provided src (${util__default["default"].inspect(src)}) invalid: ${err.message}`);
}
}
if (lodash__default["default"].isString(src)) {
const loadErr = [];
const tryLoads = [{
tryLoadPackageName: src,
tryLoadAsserterByName: null
}];
if (src.indexOf('/') >= 0) {
tryLoads.push({
tryLoadPackageName: src.substring(0, src.lastIndexOf('/')),
tryLoadAsserterByName: src.substring(src.lastIndexOf('/') + 1)
});
}
const tryLoadFromSource = (tryRequire, tryAsserterName) => {
let CheckClass = commonjsRequire();
if (CheckClass.default) {
CheckClass = CheckClass.default;
}
if (tryAsserterName) {
if (hookType === 'asserter' && CheckClass.PluginAsserters && CheckClass.PluginAsserters[tryAsserterName]) {
CheckClass = CheckClass.PluginAsserters[tryAsserterName];
} else if (hookType === 'logichook' && CheckClass.PluginLogicHooks && CheckClass.PluginLogicHooks[tryAsserterName]) {
CheckClass = CheckClass.PluginLogicHooks[tryAsserterName];
} else {
throw new Error(`Loaded ${tryRequire}, but ${tryAsserterName} ${hookType} not found.`);
}
}
if (isClass__default["default"](CheckClass)) {
return new CheckClass({
ref,
...this.buildScriptContext
}, this.caps, args);
} else if (lodash__default["default"].isFunction(CheckClass)) {
return CheckClass({
ref,
...this.buildScriptContext
}, this.caps, args);
} else if (isClass__default["default"](CheckClass.PluginClass)) {
return new CheckClass.PluginClass({
ref,
...this.buildScriptContext
}, this.caps, args);
} else if (lodash__default["default"].isFunction(CheckClass.PluginClass)) {
return CheckClass.PluginClass({
ref,
...this.buildScriptContext
}, this.caps, args);
} else {
throw new Error('Expected class or function');
}
};
for (const tryLoad of tryLoads) {
if (this.caps.SAFEDIR) {
const tryLoadFile = path__default["default"].resolve(this.caps.SAFEDIR, tryLoad.tryLoadPackageName);
if (tryLoadFile.startsWith(path__default["default"].resolve(this.caps.SAFEDIR))) {
if (fs__default["default"].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(tryLoad.tryLoadPackageName, tryLoad.tryLoadAsserterByName);
} catch (err) {
loadErr.push(`Logic Hook specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `);
}
}
}
loadErr.forEach(debug$m);
}
throw new Error(`Logic Hook specification ${ref} ${hookType} from "${util__default["default"].inspect(src)}" invalid : no loader available`);
}
};
var Constants