@loadmill/core 0.3.139 → 0.3.141

package/dist/parameters/extractors/ws-extractor.d.ts

@@ -0,0 +1,33 @@
+import { Parameters } from '../type';
+import { ParametrizedExtractor } from './parametrized-extractor';
+export declare class WsExtractor extends ParametrizedExtractor {
+    private readonly _messages;
+    private readonly _timeLimit;
+    private _regexp;
+    constructor(extractionData: WSExtractionData | undefined, parameters: Parameters);
+    extractResolved: (resolvedRegex: string) => Promise<string | undefined>;
+    /**
+     * Querying all received incoming WS messages by regexp.
+     * @returns A WS message that satisfies the given regexp. If none found, returns an empty string.
+     * @throws RequestFailuresError if the procedure timeouts before any relevant message found.
+     */
+    private queryMessage;
+    private readonly GIVE_WS_MSG_TIME_MS;
+    /**
+     * Get an incoming ws message that satisfies the given regex, out of all already received incoming ws messages.
+     *
+     * If can't find that message, then actively waiting, until procedure timeouts.
+     * @param regex To test the messages with
+     * @param timeout Milliseconds for the procedure to find a message
+     * @returns ws message as string or undefined if timed out
+     */
+    private getWSMessageOrTimeout;
+    private findMessageByRegex;
+    private getLastMessage;
+    private findLastMatchingMessage;
+}
+export declare const WS_TIMEOUT_MESSAGE = "Websocket waiting timeout expired";
+export declare type WSExtractionData = {
+    messages: string[];
+    timeLimit: number;
+};

package/dist/parameters/extractors/ws-extractor.js

@@ -0,0 +1,215 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WS_TIMEOUT_MESSAGE = exports.WsExtractor = void 0;
+var findLast_1 = __importDefault(require("lodash/findLast"));
+var errors_1 = require("@loadmill/universal/dist/errors");
+var log_1 = __importDefault(require("@loadmill/universal/dist/log"));
+var promise_utils_1 = require("@loadmill/universal/dist/promise-utils");
+var parameter_regex_providers_1 = require("../parameter-regex-providers");
+var parametrized_extractor_1 = require("./parametrized-extractor");
+var regex_matcher_1 = require("./regex-matcher");
+var WsExtractor = /** @class */ (function (_super) {
+    __extends(WsExtractor, _super);
+    function WsExtractor(extractionData, parameters) {
+        if (extractionData === void 0) { extractionData = { messages: [], timeLimit: 0 }; }
+        var _this = _super.call(this, parameters) || this;
+        Object.defineProperty(_this, "_messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_timeLimit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_regexp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "extractResolved", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (resolvedRegex) { return __awaiter(_this, void 0, void 0, function () {
+                var wsMessage;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            log_1.default.debug('Resolved WS extraction regex:', resolvedRegex);
+                            this._regexp = new RegExp(resolvedRegex || parameter_regex_providers_1.CAPTURE_ALL_REGEX);
+                            return [4 /*yield*/, this.queryMessage()];
+                        case 1:
+                            wsMessage = _a.sent();
+                            log_1.default.debug('WS message queried and found:', wsMessage === null || wsMessage === void 0 ? void 0 : wsMessage.toString());
+                            return [2 /*return*/, regex_matcher_1.matchRegex(this._regexp, wsMessage)];
+                    }
+                });
+            }); }
+        });
+        Object.defineProperty(_this, "GIVE_WS_MSG_TIME_MS", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 250
+        });
+        _this._messages = extractionData.messages;
+        _this._timeLimit = extractionData.timeLimit;
+        return _this;
+    }
+    /**
+     * Querying all received incoming WS messages by regexp.
+     * @returns A WS message that satisfies the given regexp. If none found, returns an empty string.
+     * @throws RequestFailuresError if the procedure timeouts before any relevant message found.
+     */
+    Object.defineProperty(WsExtractor.prototype, "queryMessage", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var res;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.getWSMessageOrTimeout()];
+                        case 1:
+                            res = _a.sent();
+                            if (!res) {
+                                throw new errors_1.WebsocketError(exports.WS_TIMEOUT_MESSAGE);
+                            }
+                            return [2 /*return*/, res];
+                    }
+                });
+            });
+        }
+    });
+    /**
+     * Get an incoming ws message that satisfies the given regex, out of all already received incoming ws messages.
+     *
+     * If can't find that message, then actively waiting, until procedure timeouts.
+     * @param regex To test the messages with
+     * @param timeout Milliseconds for the procedure to find a message
+     * @returns ws message as string or undefined if timed out
+     */
+    Object.defineProperty(WsExtractor.prototype, "getWSMessageOrTimeout", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var startTime, message, elapsedTime;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            startTime = Date.now();
+                            message = '';
+                            elapsedTime = 0;
+                            _a.label = 1;
+                        case 1:
+                            if (!(!message && elapsedTime < this._timeLimit)) return [3 /*break*/, 3];
+                            message = this.findMessageByRegex() || '';
+                            if (message) {
+                                return [3 /*break*/, 3];
+                            }
+                            return [4 /*yield*/, promise_utils_1.delay(this.GIVE_WS_MSG_TIME_MS)];
+                        case 2:
+                            _a.sent();
+                            elapsedTime = Date.now() - startTime;
+                            return [3 /*break*/, 1];
+                        case 3: return [2 /*return*/, message];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(WsExtractor.prototype, "findMessageByRegex", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            if (parameter_regex_providers_1.isCaptureAllRegExp(this._regexp)) {
+                return this.getLastMessage();
+            }
+            return this.findLastMatchingMessage();
+        }
+    });
+    Object.defineProperty(WsExtractor.prototype, "getLastMessage", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return this._messages[this._messages.length - 1];
+        }
+    });
+    Object.defineProperty(WsExtractor.prototype, "findLastMatchingMessage", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            return findLast_1.default(this._messages, function (msg) { return _this._regexp.test(msg); });
+        }
+    });
+    return WsExtractor;
+}(parametrized_extractor_1.ParametrizedExtractor));
+exports.WsExtractor = WsExtractor;
+exports.WS_TIMEOUT_MESSAGE = 'Websocket waiting timeout expired';
+//# sourceMappingURL=ws-extractor.js.map

package/dist/parameters/extractors/ws-extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-extractor.js","sourceRoot":"","sources":["../../../src/parameters/extractors/ws-extractor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6DAAuC;AACvC,0DAAiE;AACjE,qEAA+C;AAC/C,wEAA+D;AAC/D,0EAAqF;AAErF,mEAAiE;AACjE,iDAA6C;AAE7C;IAAiC,+BAAqB;IAIpD,qBACE,cAAiE,EACjE,UAAsB;QADtB,+BAAA,EAAA,mBAAqC,QAAQ,EAAE,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE;QADnE,YAIE,kBAAM,UAAU,CAAC,SAGlB;QAVD;;;;;WAAqC;QACrC;;;;;WAAoC;QACpC;;;;;WAAwB;QAUxB;;;;mBAAkB,UAAO,aAAqB;;;;;4BAC5C,aAAG,CAAC,KAAK,CAAC,+BAA+B,EAAE,aAAa,CAAC,CAAC;4BAC1D,IAAI,CAAC,OAAO,GAAG,IAAI,MAAM,CAAC,aAAa,IAAI,6CAAiB,CAAC,CAAC;4BAC5C,qBAAM,IAAI,CAAC,YAAY,EAAE,EAAA;;4BAArC,SAAS,GAAG,SAAyB;4BAC3C,aAAG,CAAC,KAAK,CAAC,+BAA+B,EAAE,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,QAAQ,EAAE,CAAC,CAAC;4BAElE,sBAAO,0BAAU,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,EAAC;;;iBAC5C;WAAC;QAeF;;;;mBAAuC,GAAG;WAAC;QA1BzC,KAAI,CAAC,SAAS,GAAG,cAAc,CAAC,QAAQ,CAAC;QACzC,KAAI,CAAC,UAAU,GAAG,cAAc,CAAC,SAAS,CAAC;;IAC7C,CAAC;IAWD;;;;OAIG;;;;;eACH;;;;;gCACc,qBAAM,IAAI,CAAC,qBAAqB,EAAE,EAAA;;4BAAxC,GAAG,GAAG,SAAkC;4BAC9C,IAAI,CAAC,GAAG,EAAE;gCACR,MAAM,IAAI,uBAAc,CAAC,0BAAkB,CAAC,CAAC;6BAC9C;4BACD,sBAAO,GAAG,EAAC;;;;SACZ;;IAID;;;;;;;OAOG;;;;;eACH;;;;;;4BACQ,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;4BACzB,OAAO,GAAG,EAAE,CAAC;4BACb,WAAW,GAAG,CAAC,CAAC;;;iCAEb,CAAA,CAAC,OAAO,IAAI,WAAW,GAAG,IAAI,CAAC,UAAU,CAAA;4BAC9C,OAAO,GAAG,IAAI,CAAC,kBAAkB,EAAE,IAAI,EAAE,CAAC;4BAC1C,IAAI,OAAO,EAAE;gCACX,wBAAM;6BACP;4BAED,qBAAM,qBAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,EAAA;;4BAArC,SAAqC,CAAC;4BACtC,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;;gCAEvC,sBAAO,OAAO,EAAC;;;;SAChB;;;;;;eAED;YACE,IAAI,8CAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;gBACpC,OAAO,IAAI,CAAC,cAAc,EAAE,CAAC;aAC9B;YACD,OAAO,IAAI,CAAC,uBAAuB,EAAE,CAAC;QACxC,CAAC;;;;;;eAED;YACE,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACnD,CAAC;;;;;;eAED;YAAA,iBAEC;YADC,OAAO,kBAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,UAAA,GAAG,IAAI,OAAA,KAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAtB,CAAsB,CAAC,CAAC;QACjE,CAAC;;IACH,kBAAC;AAAD,CAAC,AA5ED,CAAiC,8CAAqB,GA4ErD;AA5EY,kCAAW;AA8EX,QAAA,kBAAkB,GAAG,mCAAmC,CAAC"}

package/dist/parameters/extractors/x-path-extractor.d.ts

@@ -0,0 +1,9 @@
+import { Parameters } from '../type';
+import { ParametrizedExtractor } from './parametrized-extractor';
+export declare class XPathExtractor extends ParametrizedExtractor {
+    private $;
+    private select;
+    constructor(target: string, parameters: Parameters);
+    extractResolved: (resolvedXPath: string) => string;
+    private getSelectUsingNameSpaces;
+}

package/dist/parameters/extractors/x-path-extractor.js

@@ -0,0 +1,77 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XPathExtractor = void 0;
+var xpath_1 = __importDefault(require("xpath"));
+var xmldom_1 = require("@xmldom/xmldom");
+var parametrized_extractor_1 = require("./parametrized-extractor");
+var errors_1 = require("@loadmill/universal/dist/errors");
+var XPathExtractor = /** @class */ (function (_super) {
+    __extends(XPathExtractor, _super);
+    function XPathExtractor(target, parameters) {
+        var _this = _super.call(this, parameters) || this;
+        Object.defineProperty(_this, "$", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "select", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "extractResolved", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (resolvedXPath) {
+                var res = _this.select(resolvedXPath, _this.$).toString();
+                return res;
+            }
+        });
+        try {
+            _this.$ = new xmldom_1.DOMParser().parseFromString(target, 'text/xml');
+        }
+        catch (e) {
+            throw new errors_1.PresentableError("Failed to parse XML: " + e.message);
+        }
+        _this.select = _this.getSelectUsingNameSpaces();
+        return _this;
+    }
+    Object.defineProperty(XPathExtractor.prototype, "getSelectUsingNameSpaces", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var namespaces = {};
+            var namespaceAttributes = xpath_1.default.select('//@*[starts-with(name(), \'xmlns\')]', this.$);
+            namespaceAttributes.forEach(function (attr) {
+                var prefix = attr.nodeName.startsWith('xmlns:') ? attr.nodeName.split(':')[1] : 'default';
+                namespaces[prefix] = attr.nodeValue;
+            });
+            return xpath_1.default.useNamespaces(namespaces);
+        }
+    });
+    return XPathExtractor;
+}(parametrized_extractor_1.ParametrizedExtractor));
+exports.XPathExtractor = XPathExtractor;
+//# sourceMappingURL=x-path-extractor.js.map

package/dist/parameters/extractors/x-path-extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-path-extractor.js","sourceRoot":"","sources":["../../../src/parameters/extractors/x-path-extractor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,gDAA0B;AAC1B,yCAA2C;AAG3C,mEAAiE;AACjE,0DAAmE;AAEnE;IAAoC,kCAAqB;IAIvD,wBAAY,MAAc,EAAE,UAAsB;QAAlD,YACE,kBAAM,UAAU,CAAC,SAOlB;QAXD;;;;;WAAoB;QACpB;;;;;WAAkC;QAYlC;;;;mBAAkB,UAChB,aAAqB;gBAErB,IAAM,GAAG,GAAG,KAAI,CAAC,MAAM,CAAC,aAAa,EAAE,KAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;gBAC1D,OAAO,GAAG,CAAC;YACb,CAAC;WAAC;QAbA,IAAI;YACF,KAAI,CAAC,CAAC,GAAG,IAAI,kBAAS,EAAE,CAAC,eAAe,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;SAC9D;QAAC,OAAO,CAAC,EAAE;YACV,MAAM,IAAI,yBAAgB,CAAC,0BAAwB,CAAC,CAAC,OAAS,CAAC,CAAC;SACjE;QACD,KAAI,CAAC,MAAM,GAAG,KAAI,CAAC,wBAAwB,EAAE,CAAC;;IAChD,CAAC;;;;;eASD;YACE,IAAM,UAAU,GAAG,EAAE,CAAC;YACtB,IAAM,mBAAmB,GAAG,eAAK,CAAC,MAAM,CAAC,sCAAsC,EAAE,IAAI,CAAC,CAAC,CAAW,CAAC;YAEnG,mBAAmB,CAAC,OAAO,CAAC,UAAA,IAAI;gBAC9B,IAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;gBAC5F,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC;YACtC,CAAC,CAAC,CAAC;YAEH,OAAO,eAAK,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;QACzC,CAAC;;IACH,qBAAC;AAAD,CAAC,AAhCD,CAAoC,8CAAqB,GAgCxD;AAhCY,wCAAc"}

package/dist/parameters/generate-random.d.ts

@@ -0,0 +1,13 @@
+export declare enum RandomTypes {
+    hex = "hex",
+    uuid = "uuid",
+    from = "from",
+    chars = "chars",
+    number = "number",
+    digits = "digits",
+    uppers = "uppers",
+    lowers = "lowers",
+    letters = "letters",
+    boolean = "boolean"
+}
+export declare function generateRandom(kind: string, arg1?: string, arg2?: string): any;

package/dist/parameters/generate-random.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandom = exports.RandomTypes = void 0;
+var uuid_1 = __importDefault(require("uuid"));
+var randomstring_1 = __importDefault(require("randomstring"));
+var clamp = require("lodash/clamp");
+var random = require("lodash/random");
+var value_utils_1 = require("./value-utils");
+var errors_1 = require("@loadmill/universal/dist/errors");
+var MAX_RANDOM_LEN = 100;
+var DEFAULT_RANDOM_LEN = 10;
+// 2^32
+var DEFAULT_MAX_RANDOM_INT = 4294967296;
+var RandomTypes;
+(function (RandomTypes) {
+    RandomTypes["hex"] = "hex";
+    RandomTypes["uuid"] = "uuid";
+    RandomTypes["from"] = "from";
+    RandomTypes["chars"] = "chars";
+    RandomTypes["number"] = "number";
+    RandomTypes["digits"] = "digits";
+    RandomTypes["uppers"] = "uppers";
+    RandomTypes["lowers"] = "lowers";
+    RandomTypes["letters"] = "letters";
+    RandomTypes["boolean"] = "boolean";
+})(RandomTypes = exports.RandomTypes || (exports.RandomTypes = {}));
+function generateRandom(kind, arg1, arg2) {
+    if (!kind) {
+        return null;
+    }
+    if (kind === RandomTypes.uuid) {
+        return uuid_1.default.v4();
+    }
+    else if (kind === RandomTypes.number) {
+        var min = 0, max = DEFAULT_MAX_RANDOM_INT;
+        if (arg2) {
+            min = nonNegativeInt(arg1);
+            max = nonNegativeInt(arg2);
+            if (min > max) {
+                var temp = min;
+                min = max;
+                max = temp;
+            }
+        }
+        else if (arg1) {
+            max = nonNegativeInt(arg1);
+        }
+        // Assumes both are integers!
+        return random(min, max);
+    }
+    else if (kind === RandomTypes.boolean) {
+        var probability = nonNegativeInt(arg1, 50) / 100;
+        return (probability >= 1 ||
+            (probability !== 0 && Math.random() <= probability)).toString();
+    }
+    else {
+        var length_1 = nonNegativeInt(kind === RandomTypes.from ? arg2 : arg1, DEFAULT_RANDOM_LEN);
+        var options = {
+            length: clamp(length_1, 0, MAX_RANDOM_LEN),
+        };
+        if (kind === RandomTypes.chars) {
+            options.charset = 'alphanumeric';
+        }
+        else if (kind === RandomTypes.digits) {
+            options.charset = 'numeric';
+        }
+        else if (kind === RandomTypes.hex) {
+            options.charset = 'hex';
+        }
+        else if (kind === RandomTypes.letters ||
+            kind === RandomTypes.lowers ||
+            kind === RandomTypes.uppers) {
+            options.charset = 'alphabetic';
+            if (kind !== RandomTypes.letters) {
+                options.capitalization =
+                    kind === RandomTypes.lowers ? 'lowercase' : 'uppercase';
+            }
+        }
+        else if (kind === RandomTypes.from) {
+            if (!arg1) {
+                return null;
+            }
+            options.charset = arg1;
+        }
+        else {
+            options.charset = kind;
+        }
+        return randomstring_1.default.generate(options);
+    }
+}
+exports.generateRandom = generateRandom;
+function nonNegativeInt(arg, def) {
+    var value;
+    if (!arg) {
+        value = def;
+    }
+    else {
+        value = value_utils_1.parameterValueToNumber(arg, { integer: true, nonNegative: true });
+    }
+    if (value == null) {
+        throw new errors_1.PresentableError('Argument must be a non-negative integer, instead found: ' + arg);
+    }
+    return value;
+}
+//# sourceMappingURL=generate-random.js.map

package/dist/parameters/generate-random.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-random.js","sourceRoot":"","sources":["../../src/parameters/generate-random.ts"],"names":[],"mappings":"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"}

package/dist/parameters/html-utils.d.ts

@@ -0,0 +1 @@
+export declare const getCsrfTokensByRegexp: (data: string) => RegExpExecArray[];

package/dist/parameters/html-utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCsrfTokensByRegexp = void 0;
+var parameter_regex_providers_1 = require("./parameter-regex-providers");
+var MAX_CSRF_REGEX_ITERATIONS = 1000;
+var getCsrfTokensByRegexp = function (data) {
+    var regex = new RegExp(parameter_regex_providers_1.CSRF_REGEXP, 'gm');
+    var matches = [];
+    var match = regex.exec(data);
+    var iterations = 0;
+    while (match && iterations++ < MAX_CSRF_REGEX_ITERATIONS) {
+        matches.push(match);
+        match = regex.exec(data);
+    }
+    return matches;
+};
+exports.getCsrfTokensByRegexp = getCsrfTokensByRegexp;
+//# sourceMappingURL=html-utils.js.map

package/dist/parameters/html-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-utils.js","sourceRoot":"","sources":["../../src/parameters/html-utils.ts"],"names":[],"mappings":";;;AAAA,yEAA0D;AAE1D,IAAM,yBAAyB,GAAG,IAAI,CAAC;AAChC,IAAM,qBAAqB,GAAG,UAAC,IAAY;IAChD,IAAM,KAAK,GAAG,IAAI,MAAM,CAAC,uCAAW,EAAE,IAAI,CAAC,CAAC;IAC5C,IAAM,OAAO,GAAsB,EAAE,CAAC;IACtC,IAAI,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7B,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,OAAO,KAAK,IAAI,UAAU,EAAE,GAAG,yBAAyB,EAAE;QACxD,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpB,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;KAC1B;IACD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAVW,QAAA,qBAAqB,yBAUhC"}

package/dist/parameters/index.d.ts

@@ -0,0 +1,94 @@
+import { Parameters, ParametersScope, SequenceExecutorParameters } from './type';
+import * as valueUtils from './value-utils';
+import { parameterFunctionOperations } from './parameter-functions/parameter-functions';
+import { usageRegExpProvider, LEGAL_PARAM_CHARS, CAPTURE_REGEX, CSRF_REGEXP, CSRF_REGEXP_SUFFIX } from './parameter-regex-providers';
+import { PresentableError } from '@loadmill/universal/dist/errors';
+import { Assertions } from '../assertions';
+import { Extractions } from '../extractions';
+import { TestConfLike } from '../conf';
+import { getLongestJsonPathToken } from './json-path-utils';
+import { replaceInvalidCharactersParamName, humanizeJSONPath, ordinal, pathToArray } from './parameter-name-utils';
+import { getCsrfTokensByRegexp } from './html-utils';
+import { Step } from '../step/step-type';
+export declare const BUILT_IN_VOLATILE_PARAMS: {
+    requestBody: string;
+    requestURL: string;
+    requestMethod: string;
+    responseBody: string;
+};
+export declare const BUILT_IN_PARAMS: {
+    requestBody: string;
+    requestURL: string;
+    requestMethod: string;
+    responseBody: string;
+    testDraftId: string;
+    launchedBy: string;
+    launchedByUserId: string;
+    launchedByTeamId: string;
+    requestStartTime: string;
+    responseEndTime: string;
+    responseTime: string;
+    status: string;
+    statusText: string;
+    testRunId: string;
+    testStartTime: string;
+};
+export declare const MAX_PARAM_ARRAY_SIZE = 100;
+export { CAPTURE_REGEX, getLongestJsonPathToken, LEGAL_PARAM_CHARS, parameterFunctionOperations, Parameters, ParametersScope, PresentableError, SequenceExecutorParameters, usageRegExpProvider, valueUtils, CSRF_REGEXP, CSRF_REGEXP_SUFFIX, getCsrfTokensByRegexp, replaceInvalidCharactersParamName, humanizeJSONPath, ordinal, pathToArray };
+export declare class ParameterError extends PresentableError {
+    readonly prettyError: string;
+    readonly parameter: Parameters;
+    constructor(prettyError: string, parameter: Parameters);
+}
+export declare const parameterUtils: {
+    isParametrized(expression: string): any;
+    resolveAllExpressions(parameters: Parameters[]): Parameters;
+    resolveParameter(parameterName: string, parameters: Parameters, onError?: any): any;
+    resolveExpression(parametrized: string, parameters: Parameters | Parameters[], onError?: any): string;
+    addParamToArray(key: any, value: any, arr: any): void;
+    findIndex(key: any, arr: any): any;
+    getParametersRegexGroups(src: string): {
+        functionGroupingRegexp: RegExp;
+        operatorsGroupingRegexp: RegExp;
+    };
+    suggestNewParamName(paramKey: any, flowConfParameters: any): any;
+    /**  Search any parameters with the following patterns:
+     *   ${param1}
+     *   ${__encode_url(param1)}
+     *   ${__if_then_else(param12,'good','bad')}
+     */
+    searchParameterizedExpressionOccurrences(parameterName: string, data: string): Array<string>;
+    getUsedConfParams(conf: TestConfLike, parameters: Parameters[]): Parameters[];
+    getUsedStepParams(step: Step, parameters: Parameters[]): Parameters[];
+    getValueByKeyFromArr(key: string, parameters?: Parameters[] | undefined, returnArray?: boolean): any;
+    pickFirstValue(p: Parameters): Parameters;
+    getParameterValue(parameter: Parameters): string | string[];
+    getParameterName(parameter: Parameters | Extractions): string;
+    getParametersNames(parameters: Parameters[]): string[];
+    setParameterValue(name: string, value: string | string[], parameters: Parameters[]): void;
+    getUsedRequestParamNames(stringifiedRequest: string): string[];
+    deleteAllSrcElementsFromParamArr(paramArr: any, src: any): void;
+    removeParameterFromArrayByKey(src: any, paramArr: any): void;
+    isParamKeyInArr(key: any, arr: any): boolean;
+    /**
+     * Returns a Parameter ({name:value}) obj with the given value to search for.
+     * if non found, returns undefined
+     * @param value string | string[]
+     * @param arr Parameters[]
+     */
+    findParamValueInArr(value: any, arr: any): any;
+    findParametersSimilarityByRegex(value: any, arr: Parameters[] | undefined, regex: any): Parameters | undefined;
+    findUsedParameters(suiteParameters: Parameters[], param: Parameters, usedParameters: Parameters[]): Parameters[];
+    applyJSONSchema(instance: any, schema: any): boolean;
+    isUsingParameterizedValue(value: string): boolean;
+    getRunPostParameters(redactableResult: any): any;
+};
+export declare const stripToFunctionAndArgs: (s: string) => string[];
+export declare const stripParam: (s: string) => string;
+export declare const searchExpressionOccurrences: (s: string) => string[];
+export declare const getTokensWithoutOperators: (paramOccurrence: string) => string[];
+export declare function isParamUsedInConf(paramName: string, conf: TestConfLike, stringifyConf: string): boolean;
+export declare function isParamNameUsedInAssertionValue(paramName: string, assertions?: Assertions): boolean;
+export declare function removeNonStringParameters(conf: any): void;
+export declare const DATA_REDACTED = "Redacted";
+export declare function redactPostParameters(postParameters?: Parameters[], sensitiveKeys?: string[]): void;