@loadmill/core 0.3.109 → 0.3.110

package/dist/parameters/extractors/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XPathExtractor = exports.WsExtractor = exports.RegexExtractor = exports.ParametrizedExtractor = exports.JsonPathExtractor = exports.HeaderExtractor = exports.ExpressionExtractor = exports.CheerioExtractor = void 0;
+var cheerio_extractor_1 = require("./cheerio-extractor");
+Object.defineProperty(exports, "CheerioExtractor", { enumerable: true, get: function () { return cheerio_extractor_1.CheerioExtractor; } });
+var expression_extractor_1 = require("./expression-extractor");
+Object.defineProperty(exports, "ExpressionExtractor", { enumerable: true, get: function () { return expression_extractor_1.ExpressionExtractor; } });
+var header_extractor_1 = require("./header-extractor");
+Object.defineProperty(exports, "HeaderExtractor", { enumerable: true, get: function () { return header_extractor_1.HeaderExtractor; } });
+var json_path_extractor_1 = require("./json-path-extractor");
+Object.defineProperty(exports, "JsonPathExtractor", { enumerable: true, get: function () { return json_path_extractor_1.JsonPathExtractor; } });
+var parametrized_extractor_1 = require("./parametrized-extractor");
+Object.defineProperty(exports, "ParametrizedExtractor", { enumerable: true, get: function () { return parametrized_extractor_1.ParametrizedExtractor; } });
+var regex_extractor_1 = require("./regex-extractor");
+Object.defineProperty(exports, "RegexExtractor", { enumerable: true, get: function () { return regex_extractor_1.RegexExtractor; } });
+var ws_extractor_1 = require("./ws-extractor");
+Object.defineProperty(exports, "WsExtractor", { enumerable: true, get: function () { return ws_extractor_1.WsExtractor; } });
+var x_path_extractor_1 = require("./x-path-extractor");
+Object.defineProperty(exports, "XPathExtractor", { enumerable: true, get: function () { return x_path_extractor_1.XPathExtractor; } });
+//# sourceMappingURL=index.js.map

package/dist/parameters/extractors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/parameters/extractors/index.ts"],"names":[],"mappings":";;;AAAA,yDAAuD;AAU9C,iGAVA,oCAAgB,OAUA;AATzB,+DAA6D;AASlC,oGATlB,0CAAmB,OASkB;AAP9C,uDAAqD;AAOM,gGAPlD,kCAAe,OAOkD;AAN1E,6DAA0D;AAMkB,kGANnE,uCAAiB,OAMmE;AAL7F,mEAAiE;AAK8B,sGALtF,8CAAqB,OAKsF;AAJpH,qDAAmD;AAImE,+FAJ7G,gCAAc,OAI6G;AAHpI,+CAA6C;AAGyF,4FAH7H,0BAAW,OAG6H;AAFjJ,uDAAoD;AAE+F,+FAF1I,iCAAc,OAE0I"}

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

@@ -0,0 +1,11 @@
+import { Parameters } from '../type';
+import { ParametrizedExtractor } from './parametrized-extractor';
+export declare class JsonPathExtractor extends ParametrizedExtractor {
+    private obj;
+    private parseError?;
+    _validateObj: () => void;
+    _isHTML: (str: any) => boolean;
+    constructor(target: any, parameters: Parameters);
+    extractResolved: (jsonPath: string, full?: any) => any;
+    apply: (jsonPath: string, value: any) => string;
+}

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

@@ -0,0 +1,117 @@
+"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.JsonPathExtractor = void 0;
+var jsonpath_1 = __importDefault(require("jsonpath"));
+var parametrized_extractor_1 = require("./parametrized-extractor");
+var errors_1 = require("@loadmill/universal/dist/errors");
+var log_1 = __importDefault(require("@loadmill/universal/dist/log"));
+var JsonPathExtractor = /** @class */ (function (_super) {
+    __extends(JsonPathExtractor, _super);
+    function JsonPathExtractor(target, parameters) {
+        var _this = _super.call(this, parameters) || this;
+        Object.defineProperty(_this, "obj", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "parseError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_validateObj", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function () {
+                var parseError = _this.parseError;
+                if (parseError) {
+                    throw new errors_1.PresentableError(parseError);
+                }
+            }
+        });
+        Object.defineProperty(_this, "_isHTML", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (str) {
+                var pattern = /<[^>]+>/;
+                return pattern.test(str);
+            }
+        });
+        Object.defineProperty(_this, "extractResolved", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (jsonPath, full) {
+                _this._validateObj();
+                var jsonPathResult;
+                if (jsonPath === '$') {
+                    jsonPathResult = _this.obj;
+                }
+                else {
+                    jsonPathResult = full ? jsonpath_1.default.query(_this.obj, jsonPath) : jsonpath_1.default.value(_this.obj, jsonPath);
+                }
+                if (jsonPathResult != null) {
+                    return typeof jsonPathResult === 'object'
+                        ? JSON.stringify(jsonPathResult)
+                        : jsonPathResult.toString();
+                }
+            }
+        });
+        Object.defineProperty(_this, "apply", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (jsonPath, value) {
+                _this._validateObj();
+                log_1.default.debug('JSONPath parameter apply:', { jsonPath: jsonPath, value: value });
+                jsonpath_1.default.apply(_this.obj, jsonPath, function () {
+                    try {
+                        return JSON.parse(value);
+                    }
+                    catch (error) {
+                        return value;
+                    }
+                });
+                log_1.default.debug('JSONPath parameter apply result:', { obj: _this.obj });
+                return JSON.stringify(_this.obj);
+            }
+        });
+        try {
+            _this.obj = JSON.parse(target);
+        }
+        catch (e) {
+            if (_this._isHTML(target)) {
+                _this.parseError = 'The response body looks like HTML and not JSON. Check if your authentication is configured correctly.';
+            }
+            else {
+                _this.parseError = 'Response body is not a valid JSON: ' + e.message;
+            }
+        }
+        return _this;
+    }
+    return JsonPathExtractor;
+}(parametrized_extractor_1.ParametrizedExtractor));
+exports.JsonPathExtractor = JsonPathExtractor;
+//# sourceMappingURL=json-path-extractor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json-path-extractor.js","sourceRoot":"","sources":["../../../src/parameters/extractors/json-path-extractor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,sDAAgC;AAEhC,mEAAiE;AACjE,0DAAmE;AACnE,qEAA+C;AAE/C;IAAuC,qCAAqB;IAgB1D,2BAAY,MAAM,EAAE,UAAsB;QAA1C,YACE,kBAAM,UAAU,CAAC,SAUlB;QA1BD;;;;;WAAY;QACZ;;;;;WAAoB;QAEpB;;;;mBAAe;gBACL,IAAA,UAAU,GAAK,KAAI,WAAT,CAAU;gBAC5B,IAAI,UAAU,EAAE;oBACd,MAAM,IAAI,yBAAgB,CAAC,UAAU,CAAC,CAAC;iBACxC;YACH,CAAC;WAAC;QAEF;;;;mBAAU,UAAC,GAAG;gBACZ,IAAM,OAAO,GAAG,SAAS,CAAC;gBAC1B,OAAO,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC3B,CAAC;WAAC;QAeF;;;;mBAAkB,UAAC,QAAgB,EAAE,IAAK;gBAExC,KAAI,CAAC,YAAY,EAAE,CAAC;gBAEpB,IAAI,cAAc,CAAC;gBACnB,IAAI,QAAQ,KAAK,GAAG,EAAE;oBACpB,cAAc,GAAG,KAAI,CAAC,GAAG,CAAC;iBAC3B;qBACI;oBACH,cAAc,GAAG,IAAI,CAAC,CAAC,CAAC,kBAAQ,CAAC,KAAK,CAAC,KAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,kBAAQ,CAAC,KAAK,CAAC,KAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;iBACjG;gBAED,IAAI,cAAc,IAAI,IAAI,EAAE;oBAC1B,OAAO,OAAO,cAAc,KAAK,QAAQ;wBACvC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC;wBAChC,CAAC,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC;iBAC/B;YACH,CAAC;WAAC;QAEF;;;;mBAAQ,UAAC,QAAgB,EAAE,KAAK;gBAC9B,KAAI,CAAC,YAAY,EAAE,CAAC;gBAEpB,aAAG,CAAC,KAAK,CAAC,2BAA2B,EAAE,EAAE,QAAQ,UAAA,EAAE,KAAK,OAAA,EAAE,CAAC,CAAC;gBAE5D,kBAAQ,CAAC,KAAK,CAAC,KAAI,CAAC,GAAG,EAAE,QAAQ,EAAE;oBACjC,IAAI;wBACF,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;qBAC1B;oBAAC,OAAO,KAAK,EAAE;wBACd,OAAO,KAAK,CAAC;qBACd;gBACH,CAAC,CAAC,CAAC;gBAEH,aAAG,CAAC,KAAK,CAAC,kCAAkC,EAAE,EAAE,GAAG,EAAE,KAAI,CAAC,GAAG,EAAE,CAAC,CAAC;gBAEjE,OAAO,IAAI,CAAC,SAAS,CAAC,KAAI,CAAC,GAAG,CAAC,CAAC;YAClC,CAAC;WAAC;QA9CA,IAAI;YACF,KAAI,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;SAC/B;QAAC,OAAO,CAAC,EAAE;YACV,IAAI,KAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBACxB,KAAI,CAAC,UAAU,GAAG,uGAAuG,CAAC;aAC3H;iBAAM;gBACL,KAAI,CAAC,UAAU,GAAG,qCAAqC,GAAG,CAAC,CAAC,OAAO,CAAC;aACrE;SACF;;IACH,CAAC;IAsCH,wBAAC;AAAD,CAAC,AAjED,CAAuC,8CAAqB,GAiE3D;AAjEY,8CAAiB"}

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

@@ -0,0 +1,10 @@
+import { Extractor } from './extractor';
+import { Parameters } from '../type';
+export declare abstract class ParametrizedExtractor implements Extractor {
+    private parameters;
+    abstract extractResolved: ResolvedExtracter;
+    constructor(parameters: Parameters);
+    extract: (parametrizedQuery: string | string[]) => string | Promise<string | undefined> | undefined;
+}
+declare type ResolvedExtracter = ((...resolvedQuery: string[]) => string | undefined | Promise<string | undefined>);
+export {};

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParametrizedExtractor = void 0;
+var __1 = require("../");
+var ParametrizedExtractor = /** @class */ (function () {
+    function ParametrizedExtractor(parameters) {
+        var _this = this;
+        Object.defineProperty(this, "parameters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: parameters
+        });
+        Object.defineProperty(this, "extract", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (parametrizedQuery) {
+                if (!Array.isArray(parametrizedQuery)) {
+                    parametrizedQuery = [parametrizedQuery];
+                }
+                var resolvedQuery = parametrizedQuery.map(function (q) { return q && __1.parameterUtils.resolveExpression(q, _this.parameters); });
+                /* log.debug('Parametrized query resolution:', {
+                  parametrizedQuery,
+                  resolvedQuery,
+                }); */
+                return _this.extractResolved.apply(_this, resolvedQuery);
+            }
+        });
+    }
+    return ParametrizedExtractor;
+}());
+exports.ParametrizedExtractor = ParametrizedExtractor;
+//# sourceMappingURL=parametrized-extractor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parametrized-extractor.js","sourceRoot":"","sources":["../../../src/parameters/extractors/parametrized-extractor.ts"],"names":[],"mappings":";;;AACA,yBAAqC;AAGrC;IAGE,+BAAoB,UAAsB;QAA1C,iBAA8C;;;;;mBAA1B;;QAEpB;;;;mBAAU,UAAC,iBAAoC;gBAC7C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE;oBACrC,iBAAiB,GAAG,CAAC,iBAAiB,CAAC,CAAC;iBACzC;gBAED,IAAM,aAAa,GAAG,iBAAiB,CAAC,GAAG,CACzC,UAAC,CAAC,IAAK,OAAA,CAAC,IAAI,kBAAc,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAI,CAAC,UAAU,CAAC,EAAzD,CAAyD,CACjE,CAAC;gBACF;;;sBAGM;gBAEN,OAAO,KAAI,CAAC,eAAe,OAApB,KAAI,EAAoB,aAAa,EAAE;YAChD,CAAC;WAAC;IAhB2C,CAAC;IAiBhD,4BAAC;AAAD,CAAC,AApBD,IAoBC;AApBqB,sDAAqB"}

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

@@ -0,0 +1,7 @@
+import { ParametrizedExtractor } from './parametrized-extractor';
+import { Parameters } from '../type';
+export declare class RegexExtractor extends ParametrizedExtractor {
+    private targetProvider;
+    constructor(targetProvider: () => string | undefined, parameters: Parameters);
+    extractResolved: (regex: string) => string | undefined;
+}

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

@@ -0,0 +1,46 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegexExtractor = void 0;
+var parametrized_extractor_1 = require("./parametrized-extractor");
+var regex_matcher_1 = require("./regex-matcher");
+var RegexExtractor = /** @class */ (function (_super) {
+    __extends(RegexExtractor, _super);
+    function RegexExtractor(targetProvider, parameters) {
+        var _this = _super.call(this, parameters) || this;
+        Object.defineProperty(_this, "targetProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: targetProvider
+        });
+        Object.defineProperty(_this, "extractResolved", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (regex) {
+                var target = _this.targetProvider() || '';
+                var regExp = new RegExp(regex);
+                return regex_matcher_1.matchRegex(regExp, target);
+            }
+        });
+        return _this;
+    }
+    return RegexExtractor;
+}(parametrized_extractor_1.ParametrizedExtractor));
+exports.RegexExtractor = RegexExtractor;
+//# sourceMappingURL=regex-extractor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"regex-extractor.js","sourceRoot":"","sources":["../../../src/parameters/extractors/regex-extractor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA,mEAAiE;AAEjE,iDAA6C;AAE7C;IAAoC,kCAAqB;IACvD,wBACU,cAAwC,EAChD,UAAsB;QAFxB,YAIE,kBAAM,UAAU,CAAC,SAClB;;;;;mBAJS;;QAMV;;;;mBAAkB,UAAC,KAAa;gBAC9B,IAAM,MAAM,GAAG,KAAI,CAAC,cAAc,EAAE,IAAI,EAAE,CAAC;gBAC3C,IAAM,MAAM,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;gBACjC,OAAO,0BAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YACpC,CAAC;WAAC;;IANF,CAAC;IAOH,qBAAC;AAAD,CAAC,AAbD,CAAoC,8CAAqB,GAaxD;AAbY,wCAAc"}

package/dist/parameters/extractors/regex-matcher.d.ts

@@ -0,0 +1 @@
+export declare const matchRegex: (regExp: RegExp, target: string) => string | undefined;

package/dist/parameters/extractors/regex-matcher.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchRegex = void 0;
+var log_1 = __importDefault(require("@loadmill/universal/dist/log"));
+var MAX_STR_LENGTH = 500;
+var matchRegex = function (regExp, target) {
+    var matchArray = regExp.exec(target);
+    log_1.default.debug('Regex parameter extraction:', {
+        regExp: regExp,
+        type: typeof target,
+        target: typeof target === 'string' && target.substring(0, MAX_STR_LENGTH),
+    });
+    if (matchArray && matchArray[1]) {
+        return matchArray[1];
+    }
+};
+exports.matchRegex = matchRegex;
+//# sourceMappingURL=regex-matcher.js.map

package/dist/parameters/extractors/regex-matcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex-matcher.js","sourceRoot":"","sources":["../../../src/parameters/extractors/regex-matcher.ts"],"names":[],"mappings":";;;;;;AAAA,qEAA+C;AAE/C,IAAM,cAAc,GAAG,GAAG,CAAC;AAEpB,IAAM,UAAU,GAAG,UAAC,MAAc,EAAE,MAAc;IACvD,IAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAEvC,aAAG,CAAC,KAAK,CAAC,6BAA6B,EAAE;QACvC,MAAM,QAAA;QACN,IAAI,EAAE,OAAO,MAAM;QACnB,MAAM,EAAE,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,cAAc,CAAC;KAC1E,CAAC,CAAC;IAEH,IAAI,UAAU,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE;QAC/B,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC;KACtB;AACH,CAAC,CAAC;AAZW,QAAA,UAAU,cAYrB"}

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);
+                            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,CAAC,CAAC;4BAEtD,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,71 @@
+"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 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;
+            }
+        });
+        _this.$ = new xmldom_1.DOMParser().parseFromString(target, 'text/xml');
+        _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;AAEjE;IAAoC,kCAAqB;IAIvD,wBAAY,MAAc,EAAE,UAAsB;QAAlD,YACE,kBAAM,UAAU,CAAC,SAGlB;QAPD;;;;;WAAoB;QACpB;;;;;WAAkC;QAQlC;;;;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;QATA,KAAI,CAAC,CAAC,GAAG,IAAI,kBAAS,EAAE,CAAC,eAAe,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAC7D,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,AA5BD,CAAoC,8CAAqB,GA4BxD;AA5BY,wCAAc"}