@loadmill/executer 0.1.36 → 0.1.40

package/dist/sequence.js

@@ -1,19 +1,4 @@
 "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 __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -100,7 +85,6 @@ var clamp_1 = __importDefault(require("lodash/clamp"));
 var find_1 = __importDefault(require("lodash/find"));
 var map_1 = __importDefault(require("lodash/map"));
 var filter_1 = __importDefault(require("lodash/filter"));
-var forEach_1 = __importDefault(require("lodash/forEach"));
 var asserter_1 = require("./asserter");
 var failures_1 = require("./failures");
 var request_stats_1 = require("./request-stats");
@@ -117,9 +101,12 @@ var errors_1 = require("@loadmill/universal/dist/errors");
 var parameters_1 = require("@loadmill/core/dist/parameters");
 var conf_1 = require("@loadmill/core/dist/conf");
 var DEFAULT_CACHE_CONTROL = conf_1.confDefaults.DEFAULT_CACHE_CONTROL, DEFAULT_REQUEST_DELAY = conf_1.confDefaults.DEFAULT_REQUEST_DELAY;
-var MAX_API_REQUEST_BODY_LENGTH = conf_1.confExtrema.MAX_API_REQUEST_BODY_LENGTH, MAX_LOAD_REQUEST_BODY_LENGTH = conf_1.confExtrema.MAX_LOAD_REQUEST_BODY_LENGTH, MAX_RESPONSE_BYTES = conf_1.confExtrema.MAX_RESPONSE_BYTES, MAX_RESPONSE_COLLECT = conf_1.confExtrema.MAX_RESPONSE_COLLECT, MIN_REQUEST_DELAY = conf_1.confExtrema.MIN_REQUEST_DELAY, MAX_REQUEST_LOOPS_ITERATIONS = conf_1.confExtrema.MAX_REQUEST_LOOPS_ITERATIONS;
+var MAX_RESPONSE_BYTES = conf_1.confExtrema.MAX_RESPONSE_BYTES, MAX_RESPONSE_COLLECT = conf_1.confExtrema.MAX_RESPONSE_COLLECT, MIN_REQUEST_DELAY = conf_1.confExtrema.MIN_REQUEST_DELAY, MAX_REQUEST_LOOPS_ITERATIONS = conf_1.confExtrema.MAX_REQUEST_LOOPS_ITERATIONS;
 var request_1 = require("@loadmill/core/dist/request");
 var test_run_event_emitter_1 = require("./test-run-event-emitter");
+var ws_1 = require("./ws");
+var errors_2 = require("./errors");
+var utils_1 = require("./utils");
 exports.reqIdParamName = 'loadmill-request-id';
 var SOCKET_TIMEOUT = request_1.DEFAULT_REQUEST_TIMEOUT + 5000; // deafult + some extra
 var isPerformance = typeof performance !== 'undefined';
@@ -205,6 +192,12 @@ var SequenceExecutor = /** @class */ (function () {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "wsHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "passStats", {
             enumerable: true,
             configurable: true,
@@ -218,6 +211,73 @@ var SequenceExecutor = /** @class */ (function () {
                 lastStartedIndex: _this.lastStartedIndex,
             }); }
         });
+        Object.defineProperty(this, "resolveAndSetWSReqData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (_a, reqIndex) {
+                var url = _a.url, headers = _a.headers, postData = _a.postData, _b = _a.timeout, timeout = _b === void 0 ? request_1.DEFAULT_REQUEST_TIMEOUT : _b, _c = _a.expectedStatus, expectedStatus = _c === void 0 ? 'SUCCESS' : _c;
+                var preparedUrl = _this.prepareWsUrl(url, reqIndex);
+                var preparedHeaders = _this.prepareWsHeaders(headers, reqIndex);
+                var preparedMessage = _this.prepareWsMessage(postData, reqIndex);
+                return {
+                    expectedStatus: expectedStatus,
+                    headers: preparedHeaders,
+                    message: preparedMessage,
+                    timeout: timeout,
+                    url: preparedUrl,
+                };
+            }
+        });
+        Object.defineProperty(this, "prepareWsUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (url, reqIndex) {
+                var resolvedUrl = _this.resolve(url, function (e) { return setParameterErrorHistogram(e, 'Failed to compute URL - '); });
+                _this.resolvedRequests[reqIndex].url = resolvedUrl;
+                return resolvedUrl;
+            }
+        });
+        Object.defineProperty(this, "prepareWsHeaders", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (headers, reqIndex) {
+                var resolvedHeadersObj = {};
+                var resolvedHeaders = [];
+                if (headers && !isEmpty_1.default(headers)) {
+                    resolvedHeaders.push.apply(resolvedHeaders, _this.resolveHeaders(headers));
+                    resolvedHeaders.forEach(function (_a) {
+                        var name = _a.name, value = _a.value;
+                        return resolvedHeadersObj[name] = value;
+                    });
+                }
+                _this.resolvedRequests[reqIndex].headers = resolvedHeaders;
+                return resolvedHeadersObj;
+            }
+        });
+        Object.defineProperty(this, "prepareWsMessage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (postData, reqIndex) {
+                var resolvedMessage = '';
+                if (postData) {
+                    resolvedMessage = _this.resolve(postData.text, function (err) {
+                        return setParameterErrorHistogram(err, 'Failed to compute Websocket message - ');
+                    });
+                    if (resolvedMessage && resolvedMessage.length > utils_1.getMaxRequestBodySize()) {
+                        throw new errors_2.RequestFailuresError('Websocket message size is too large');
+                    }
+                    _this.resolvedRequests[reqIndex].postData = {
+                        mimeType: postData.mimeType,
+                        text: resolvedMessage,
+                    };
+                }
+                return resolvedMessage;
+            }
+        });
         Object.defineProperty(this, "checkProgressEvent", {
             enumerable: true,
             configurable: true,
@@ -253,6 +313,7 @@ var SequenceExecutor = /** @class */ (function () {
             freeSocketTimeout: SOCKET_TIMEOUT / 2
         });
         this.postScriptRunner = new post_script_executor_1.PostScriptRunner();
+        this.wsHandler = new ws_1.WSSequenceHandler();
     }
     Object.defineProperty(SequenceExecutor.prototype, "startAndPass", {
         enumerable: false,
@@ -318,11 +379,14 @@ var SequenceExecutor = /** @class */ (function () {
                                 log_1.default.info(reason, error_1);
                                 log_1.default.info('Unexpected error info:', unexpectedError);
                             }
+                            this.wsHandler.closeAllConnections();
                             throw error_1;
                         case 6:
                             ++reqIndex;
                             return [3 /*break*/, 1];
-                        case 7: return [2 /*return*/];
+                        case 7:
+                            this.wsHandler.closeAllConnections();
+                            return [2 /*return*/];
                     }
                 });
             });
@@ -407,7 +471,7 @@ var SequenceExecutor = /** @class */ (function () {
                                 : rawDelay)), MIN_REQUEST_DELAY, Infinity);
                             problem = conf_1.validateIntegerDelay(delay, false);
                             if (problem) {
-                                throw new RequestFailuresError("Invalid Request Delay: " + problem);
+                                throw new errors_2.RequestFailuresError("Invalid Request Delay: " + problem);
                             }
                             return [4 /*yield*/, promiseUtils.delay(delay)];
                         case 1:
@@ -438,9 +502,10 @@ var SequenceExecutor = /** @class */ (function () {
                         case 0:
                             loopIteration = 0;
                             maxIterations = getLoopIterations(requestConf.loop);
+                            this.wsHandler.clearMessages();
                             _b.label = 1;
                         case 1:
-                            if (!(loopIteration < maxIterations)) return [3 /*break*/, 8];
+                            if (!(loopIteration < maxIterations)) return [3 /*break*/, 9];
                             loopIteration++;
                             request = this.prepareRequest(requestConf, index);
                             return [4 /*yield*/, this.sendRequest(request, index)];
@@ -450,32 +515,35 @@ var SequenceExecutor = /** @class */ (function () {
                             resTime = Number(this.parameters.__responseTime);
                             _a = requestConf.timeout, timeout = _a === void 0 ? request_1.DEFAULT_REQUEST_TIMEOUT : _a;
                             if (resTime > timeout) {
-                                throw new RequestFailuresError("Response received after timeout of " + timeout + "ms exceeded");
+                                throw new errors_2.RequestFailuresError("Response received after timeout of " + timeout + "ms exceeded");
                             }
-                            failedAssertionsHistogram = this.processSuccessfulResponse(index, requestConf, res);
+                            res.wsExtractionData = { messages: this.wsHandler.messages, timeLimit: timeout - resTime };
+                            return [4 /*yield*/, this.processSuccessfulResponse(index, requestConf, res)];
+                        case 3:
+                            failedAssertionsHistogram = _b.sent();
                             this.resolvedRequests[index].retried = loopIteration > 1 ? loopIteration - 1 : undefined;
-                            if (!(loopIteration < maxIterations)) return [3 /*break*/, 6];
-                            if (!this.shouldStopLooping(requestConf.loop)) return [3 /*break*/, 3];
-                            return [3 /*break*/, 8];
-                        case 3: return [4 /*yield*/, promiseUtils.delay(1000)];
-                        case 4:
+                            if (!(loopIteration < maxIterations)) return [3 /*break*/, 7];
+                            if (!this.shouldStopLooping(requestConf.loop)) return [3 /*break*/, 4];
+                            return [3 /*break*/, 9];
+                        case 4: return [4 /*yield*/, promiseUtils.delay(1000)];
+                        case 5:
                             _b.sent(); // todo yigal - make this configrable?
-                            _b.label = 5;
-                        case 5: return [3 /*break*/, 7];
-                        case 6:
+                            _b.label = 6;
+                        case 6: return [3 /*break*/, 8];
+                        case 7:
                             if (this.hasLoopingFailed(requestConf.loop)) {
-                                throw new RequestFailuresError("Request failed to meet loop condition for " + maxIterations + " iterations");
+                                throw new errors_2.RequestFailuresError("Request failed to meet loop condition for " + maxIterations + " iterations");
                             }
-                            _b.label = 7;
-                        case 7: return [3 /*break*/, 1];
-                        case 8:
+                            _b.label = 8;
+                        case 8: return [3 /*break*/, 1];
+                        case 9:
                             if (!isEmpty_1.default(failedAssertionsHistogram)) {
                                 message = 'Request failed due to assertions.';
                                 log_1.default.debug(message, {
                                     failedAssertionsHistogram: failedAssertionsHistogram,
                                     parameters: this.parameters,
                                 });
-                                throw new RequestFailuresError(message, failedAssertionsHistogram);
+                                throw new errors_2.RequestFailuresError(message, failedAssertionsHistogram);
                             }
                             this.onRequestSuccess(index, resTime);
                             return [2 /*return*/];
@@ -600,7 +668,7 @@ var SequenceExecutor = /** @class */ (function () {
                         case 7:
                             reportedReason = errors_1.unknownStatusCorsError;
                             _c.label = 8;
-                        case 8: throw new RequestFailuresError(message, (_b = {}, _b[reportedReason] = 1, _b));
+                        case 8: throw new errors_2.RequestFailuresError(message, (_b = {}, _b[reportedReason] = 1, _b));
                         case 9:
                             failure = this.failures[reqIndex];
                             if (failure) {
@@ -614,6 +682,27 @@ var SequenceExecutor = /** @class */ (function () {
         }
     });
     Object.defineProperty(SequenceExecutor.prototype, "prepareRequest", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (requestConf, reqIndex) {
+            if (this.isWSRequest(requestConf) && !envUtils.isBrowser()) {
+                return this.prepareWSRequest(requestConf, reqIndex);
+            }
+            return this.prepareHttpRequest(requestConf, reqIndex);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "isWSRequest", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_a) {
+            var url = _a.url;
+            var resolvedUrl = this.resolve(url, function (e) { return setParameterErrorHistogram(e, 'Failed to compute URL - '); });
+            return resolvedUrl.startsWith('ws://') || resolvedUrl.startsWith('wss://');
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "prepareHttpRequest", {
         enumerable: false,
         configurable: true,
         writable: true,
@@ -651,8 +740,11 @@ var SequenceExecutor = /** @class */ (function () {
             if (auth != null && request._header['authorization'] == null) {
                 request.auth(auth.user || '', auth.password || '');
             }
-            var postData = requestConf.postData;
-            if (postData) {
+            var postData = requestConf.postData, postFormData = requestConf.postFormData;
+            if (postFormData) {
+                this.preparePostFormData(postFormData, request, reqIndex);
+            }
+            else if (postData) {
                 // It is CRUCIAL that the type is set before the body:
                 var mimeType = postData.mimeType;
                 if (mimeType && request._header['content-type'] == null) {
@@ -662,8 +754,8 @@ var SequenceExecutor = /** @class */ (function () {
                 var data = this.resolve(postData.text, function (err) {
                     return setParameterErrorHistogram(err, 'Failed to compute request body - ');
                 });
-                if (data && data.length > getMaxRequestBodySize()) {
-                    throw new RequestFailuresError('Request body size is too large');
+                if (data && data.length > utils_1.getMaxRequestBodySize()) {
+                    throw new errors_2.RequestFailuresError('Request body size is too large');
                 }
                 // This invocation will behave differently according to different types set on the request:
                 request.send(data);
@@ -721,7 +813,7 @@ var SequenceExecutor = /** @class */ (function () {
                 request.on('progress', progressHandler);
                 // This makes superagent populate res.text regardless of the response's content type:
                 request.buffer();
-                // Otherwise we expose superagent and its version - 
+                // Otherwise we expose superagent and its version -
                 // better have something more general (in case the user didnt set one):
                 var uaHeader = request.get('User-Agent');
                 if (!uaHeader || uaHeader.startsWith('node-superagent')) {
@@ -733,6 +825,49 @@ var SequenceExecutor = /** @class */ (function () {
             return request;
         }
     });
+    Object.defineProperty(SequenceExecutor.prototype, "preparePostFormData", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (postFormData, request, reqIndex) {
+            var resolvedPostFormData = [];
+            var size = 0;
+            var MAX_BODY_SIZE = utils_1.getMaxRequestBodySize();
+            for (var _i = 0, postFormData_1 = postFormData; _i < postFormData_1.length; _i++) {
+                var entry = postFormData_1[_i];
+                var name_1 = entry.name, value = entry.value, fileName = entry.fileName;
+                var resolvedName = this.resolve(name_1, function (err) { return setParameterErrorHistogram(err, 'Failed to resolve form-data key - '); });
+                size += resolvedName.length;
+                if (fileName) {
+                    var resolvedFileName = this.resolve(fileName, function (err) { return setParameterErrorHistogram(err, 'Failed to resolve form-data fileName - '); });
+                    size += (resolvedFileName.length + value.length);
+                    var buffer = Buffer.from(value, 'binary');
+                    request.attach(resolvedName, buffer, resolvedFileName);
+                    resolvedPostFormData.push({ name: resolvedName, value: value, fileName: resolvedFileName });
+                }
+                else {
+                    var resolvedValue = this.resolve(value, function (err) { return setParameterErrorHistogram(err, 'Failed to resolve form-data value - '); });
+                    size += resolvedValue.length;
+                    request.field(resolvedName, resolvedValue);
+                    resolvedPostFormData.push({ name: resolvedName, value: resolvedValue });
+                }
+                if (size > MAX_BODY_SIZE) {
+                    throw new errors_2.RequestFailuresError('Form Data size is too large');
+                }
+            }
+            this.resolvedRequests[reqIndex].postFormData = resolvedPostFormData;
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "prepareWSRequest", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (requestConf, reqIndex) {
+            var _this = this;
+            var wsRequestArgs = this.resolveAndSetWSReqData(requestConf, reqIndex);
+            return new ws_1.WSRequest(wsRequestArgs, this.wsHandler, function (e) { return _this.setSingleFailure(reqIndex, 'Websocket error: ' + e.message); });
+        }
+    });
     Object.defineProperty(SequenceExecutor.prototype, "validateDomain", {
         enumerable: false,
         configurable: true,
@@ -741,15 +876,15 @@ var SequenceExecutor = /** @class */ (function () {
             var _a, _b, _c;
             if (isEmpty_1.default(domain)) {
                 var message = 'HTTP request domain name is empty';
-                throw new RequestFailuresError(message, (_a = {}, _a[message] = 1, _a));
+                throw new errors_2.RequestFailuresError(message, (_a = {}, _a[message] = 1, _a));
             }
             if (conf_1.validate.isUrl(domain)) {
                 var message = "HTTP request domain name [" + domain + "] is not valid";
-                throw new RequestFailuresError(message, (_b = {}, _b[message] = 1, _b));
+                throw new errors_2.RequestFailuresError(message, (_b = {}, _b[message] = 1, _b));
             }
             else if (!uriUtils.isVerified(domain, this.domainsWhiteList)) {
                 var message = "HTTP request domain name [" + domain + "] is not on white list";
-                throw new RequestFailuresError(message, (_c = {}, _c[message] = 1, _c));
+                throw new errors_2.RequestFailuresError(message, (_c = {}, _c[message] = 1, _c));
             }
         }
     });
@@ -783,21 +918,32 @@ var SequenceExecutor = /** @class */ (function () {
         configurable: true,
         writable: true,
         value: function (reqIndex, requestConf, res) {
-            // modifies parameters:
-            this.handleExtractions(requestConf, res);
-            if (!envUtils.isBrowser()) {
-                this.handlePostScript(requestConf, res);
-            }
-            this.setPostParameters(reqIndex);
-            var assertionResults = this.handleAssertions(requestConf) || [];
-            log_1.default.trace('Assertion results: ', assertionResults);
-            var failuresHistogram = {};
-            assertionResults.forEach(function (result, index) {
-                if (!result) {
-                    failuresHistogram[index] = 1;
-                }
+            return __awaiter(this, void 0, void 0, function () {
+                var assertionResults, failuresHistogram;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: 
+                        // modifies parameters:
+                        return [4 /*yield*/, this.handleExtractions(requestConf, res)];
+                        case 1:
+                            // modifies parameters:
+                            _a.sent();
+                            if (!envUtils.isBrowser()) {
+                                this.handlePostScript(requestConf, res);
+                            }
+                            this.setPostParameters(reqIndex);
+                            assertionResults = this.handleAssertions(requestConf) || [];
+                            log_1.default.trace('Assertion results: ', assertionResults);
+                            failuresHistogram = {};
+                            assertionResults.forEach(function (result, index) {
+                                if (!result) {
+                                    failuresHistogram[index] = 1;
+                                }
+                            });
+                            return [2 /*return*/, failuresHistogram];
+                    }
+                });
             });
-            return failuresHistogram;
         }
     });
     Object.defineProperty(SequenceExecutor.prototype, "setPostParameters", {
@@ -813,10 +959,26 @@ var SequenceExecutor = /** @class */ (function () {
         configurable: true,
         writable: true,
         value: function (requestConf, res) {
-            var _this = this;
-            var _a;
-            (_a = requestConf.extract) === null || _a === void 0 ? void 0 : _a.forEach(function (extractions) {
-                return _this.extractInScope(res, extractions);
+            return __awaiter(this, void 0, void 0, function () {
+                var _i, _a, extractions;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _i = 0, _a = (requestConf.extract || []);
+                            _b.label = 1;
+                        case 1:
+                            if (!(_i < _a.length)) return [3 /*break*/, 4];
+                            extractions = _a[_i];
+                            return [4 /*yield*/, this.extractInScope(res, extractions)];
+                        case 2:
+                            _b.sent();
+                            _b.label = 3;
+                        case 3:
+                            _i++;
+                            return [3 /*break*/, 1];
+                        case 4: return [2 /*return*/];
+                    }
+                });
             });
         }
     });
@@ -825,11 +987,28 @@ var SequenceExecutor = /** @class */ (function () {
         configurable: true,
         writable: true,
         value: function (res, extractions) {
-            var _this = this;
-            var contextParameters = Object.assign({}, this.parameters);
-            var extractionCombiner = new extraction_combiner_1.ExtractionCombiner(contextParameters, res);
-            forEach_1.default(extractions, function (extraction, name) {
-                return _this.extract(name, extraction, extractionCombiner);
+            return __awaiter(this, void 0, void 0, function () {
+                var contextParameters, extractionCombiner, _i, _a, _b, name_2, extraction;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            contextParameters = Object.assign({}, this.parameters);
+                            extractionCombiner = new extraction_combiner_1.ExtractionCombiner(contextParameters, res, res.wsExtractionData);
+                            _i = 0, _a = Object.entries(extractions);
+                            _c.label = 1;
+                        case 1:
+                            if (!(_i < _a.length)) return [3 /*break*/, 4];
+                            _b = _a[_i], name_2 = _b[0], extraction = _b[1];
+                            return [4 /*yield*/, this.extract(name_2, extraction, extractionCombiner)];
+                        case 2:
+                            _c.sent();
+                            _c.label = 3;
+                        case 3:
+                            _i++;
+                            return [3 /*break*/, 1];
+                        case 4: return [2 /*return*/];
+                    }
+                });
             });
         }
     });
@@ -838,31 +1017,46 @@ var SequenceExecutor = /** @class */ (function () {
         configurable: true,
         writable: true,
         value: function (parameterName, extraction, extractionCombiner) {
-            log_1.default.trace('Parameter extraction start: ', { parameterName: parameterName, extraction: extraction });
-            var combinedExtractor = extractionCombiner.combine(extraction);
-            var result;
-            try {
-                result = combinedExtractor();
-            }
-            catch (error) {
-                var genericMessage = "Failed to extract value for parameter \"" + parameterName + "\"";
-                log_1.default.debug(genericMessage, error);
-                var prettyMessage = error.prettyMessage;
-                var publicMessage = prettyMessage
-                    ? genericMessage + " - " + prettyMessage
-                    : genericMessage;
-                throw new RequestFailuresError(publicMessage);
-            }
-            if (result != null) {
-                this.parameters[parameterName] = result;
-            }
-            else if (this.parameters[parameterName] == null) {
-                // Existing parameter value acts as default. If no such value exists,
-                // we set the value to be an empty string to differentiate it from undefined parameters.
-                // Otherwise, this parameter's usages would stay untouched, e.g. "${paramName}".
-                this.parameters[parameterName] = '';
-            }
-            log_1.default.trace('Parameter value:', this.parameters[parameterName]);
+            return __awaiter(this, void 0, void 0, function () {
+                var combinedExtractor, result, error_3, genericMessage, prettyMessage, publicMessage;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            log_1.default.trace('Parameter extraction start: ', { parameterName: parameterName, extraction: extraction });
+                            return [4 /*yield*/, extractionCombiner.combine(extraction)];
+                        case 1:
+                            combinedExtractor = _a.sent();
+                            _a.label = 2;
+                        case 2:
+                            _a.trys.push([2, 4, , 5]);
+                            return [4 /*yield*/, combinedExtractor()];
+                        case 3:
+                            result = _a.sent();
+                            return [3 /*break*/, 5];
+                        case 4:
+                            error_3 = _a.sent();
+                            genericMessage = "Failed to extract value for parameter \"" + parameterName + "\"";
+                            log_1.default.debug(genericMessage, error_3);
+                            prettyMessage = error_3.prettyMessage;
+                            publicMessage = prettyMessage
+                                ? genericMessage + " - " + prettyMessage
+                                : genericMessage;
+                            throw new errors_2.RequestFailuresError(publicMessage);
+                        case 5:
+                            if (result != null) {
+                                this.parameters[parameterName] = result;
+                            }
+                            else if (this.parameters[parameterName] == null) {
+                                // Existing parameter value acts as default. If no such value exists,
+                                // we set the value to be an empty string to differentiate it from undefined parameters.
+                                // Otherwise, this parameter's usages would stay untouched, e.g. "${paramName}".
+                                this.parameters[parameterName] = '';
+                            }
+                            log_1.default.trace('Parameter value:', this.parameters[parameterName]);
+                            return [2 /*return*/];
+                    }
+                });
+            });
         }
     });
     Object.defineProperty(SequenceExecutor.prototype, "resolve", {
@@ -888,7 +1082,7 @@ var SequenceExecutor = /** @class */ (function () {
                 }
                 catch (e) {
                     var message = ['Post Script', e.name + ':', e.message].join(' ');
-                    throw new RequestFailuresError(message);
+                    throw new errors_2.RequestFailuresError(message);
                 }
                 test_run_event_emitter_1.testRunEventsEmitter.postScript.finished();
             }
@@ -968,9 +1162,6 @@ function isSimpleRequest(headers) {
             key !== 'content-type';
     });
 }
-var getMaxRequestBodySize = function () {
-    return envUtils.isBrowser() ? MAX_LOAD_REQUEST_BODY_LENGTH : MAX_API_REQUEST_BODY_LENGTH;
-};
 var getLoopIterations = function (LoopConf) {
     var declared = (LoopConf && LoopConf.iterations) || 1;
     return Math.min(MAX_REQUEST_LOOPS_ITERATIONS, declared);
@@ -987,7 +1178,7 @@ var extendResponseHeaders = function (headers, redirectHeaders) {
 var isExpectedStatus = function (_a, status) {
     var expectedStatus = _a.expectedStatus, url = _a.url;
     if (expectedStatus === request_1.ALLOWED_RESPONSE_STATUSES.SUCCESS) {
-        return 200 <= status && status < 400;
+        return (200 <= status && status < 400) || status === 101;
     }
     else if (expectedStatus === request_1.ALLOWED_RESPONSE_STATUSES.ERROR) {
         log_1.default.debug('user asked to fail this request', url);
@@ -1023,22 +1214,4 @@ var setTCPReuse = function (request, agent, sslAgent) {
         _oldRequest.apply.apply(_oldRequest, __spreadArray([this], args));
     };
 };
-var RequestFailuresError = /** @class */ (function (_super) {
-    __extends(RequestFailuresError, _super);
-    function RequestFailuresError(message, histogram) {
-        var _a;
-        if (histogram === void 0) { histogram = (_a = {}, _a[message] = 1, _a); }
-        var _this = _super.call(this, message) || this;
-        Object.defineProperty(_this, "histogram", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: histogram
-        });
-        // Workaround suggested in: https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
-        Object.setPrototypeOf(_this, RequestFailuresError.prototype);
-        return _this;
-    }
-    return RequestFailuresError;
-}(Error));
 //# sourceMappingURL=sequence.js.map