@loadmill/executer 0.1.50 → 0.1.53

package/src/sequence.ts

@@ -1,1107 +0,0 @@
-import URI from 'urijs';
-const HTTPSAgent = require('agentkeepalive').HttpsAgent;
-const HTTPAgent = require('agentkeepalive');
-import randomstring from 'randomstring';
-import BluebirdPromise from 'bluebird';
-
-import isEmpty from 'lodash/isEmpty';
-import flatMap from 'lodash/flatMap';
-import clamp from 'lodash/clamp';
-import find from 'lodash/find';
-import map from 'lodash/map';
-import filter from 'lodash/filter';
-
-import { ResolvedRequest } from './request-sequence-result';
-import { Asserter } from './asserter';
-import { Failures, Histogram, OneFailure } from './failures';
-import { PerRequestStats, setReqStats } from './request-stats';
-import { millVersionString } from './mill-version';
-import { ExtractionCombiner } from './extraction-combiner';
-import { PostScriptRunner } from './post-script/post-script-executor';
-
-import log from '@loadmill/universal/dist/log';
-import * as envUtils from '@loadmill/universal/dist/env-utils';
-import * as mathUtils from '@loadmill/universal/dist/math-utils';
-import * as uriUtils from '@loadmill/universal/dist/uri-utils';
-import * as promiseUtils from '@loadmill/universal/dist/promise-utils';
-import * as manipulationUtils from '@loadmill/universal/dist/manipulation-utils';
-import {
-  corsErrorStatusPrefix,
-  corsPreFlightErrorStatusPrefix,
-  superagentCorsError,
-  unknownStatusCorsError,
-} from '@loadmill/universal/dist/errors';
-
-import {
-  parameterFunctionOperations,
-  Parameters,
-  parameterUtils,
-  SequenceExecutorParameters,
-  valueUtils,
-  BUILT_IN_VOLATILE_PARAMS,
-} from '@loadmill/core/dist/parameters';
-import {
-  isParameterCandidate,
-  validateIntegerDelay,
-  confExtrema,
-  confDefaults,
-  validate,
-} from '@loadmill/core/dist/conf';
-const {
-  DEFAULT_CACHE_CONTROL,
-  DEFAULT_REQUEST_DELAY,
-} = confDefaults;
-const {
-  MAX_RESPONSE_BYTES,
-  MAX_RESPONSE_COLLECT,
-  MIN_REQUEST_DELAY,
-  MAX_REQUEST_LOOPS_ITERATIONS,
-} = confExtrema;
-import {
-  Assertion,
-  Extraction,
-  ExtractionObj,
-  Extractions,
-  findRequestIndex,
-  LoadmillHeaders,
-  LoadmillRequest,
-  resolveUrl,
-  ALLOWED_RESPONSE_STATUSES,
-  LoopConf,
-  DEFAULT_REQUEST_TIMEOUT,
-  CachePenetrationModes,
-  RequestPostData,
-  PostFormData
-} from '@loadmill/core/dist/request';
-
-import { testRunEventsEmitter } from './test-run-event-emitter';
-import { WSRequest, WSRequestArguments, WSSequenceHandler, WSMimeType } from './ws';
-import { RequestFailuresError } from './errors';
-import { getMaxRequestBodySize } from './utils';
-import { WSExtractionData } from '@loadmill/core/dist/parameters/extractors/ws-extractor';
-
-export const reqIdParamName = 'loadmill-request-id';
-
-declare const Promise: typeof BluebirdPromise; // This is a hack for the loadmill-runner. I hate TypeScript.
-
-declare const loadmillClearResponses: undefined | (() => Promise<void>);
-
-declare const loadmillGetResponse:
-  | undefined
-  | ((
-    requestId: string
-  ) => Promise<{
-    text: string;
-    status: number;
-    preFlight: boolean;
-    headers: { [name: string]: string };
-    requestHeaders: { [name: string]: string };
-  }>);
-
-const SOCKET_TIMEOUT = DEFAULT_REQUEST_TIMEOUT + 5000; // deafult + some extra
-
-const isPerformance = typeof performance !== 'undefined';
-log.debug('isPerformance =', isPerformance);
-
-export const sequence = {
-  execute(
-    httpAgent,
-    requests: LoadmillRequest[],
-    parameters: Parameters[],
-    domainsWhiteList: string[],
-  ) {
-    const sequenceExecutor = new SequenceExecutor(
-      httpAgent,
-      parameters,
-      domainsWhiteList,
-    );
-    return sequenceExecutor.startAndPass(requests);
-  },
-};
-
-class SequenceExecutor {
-  parameters: SequenceExecutorParameters;
-  postScriptRunner: PostScriptRunner;
-
-  avgResTime = 0;
-  successfulHits = 0;
-  lastStartedIndex = 0;
-  failures: Failures = {};
-  requestStats: PerRequestStats = {};
-  resolvedRequests: ResolvedRequest[] = [];
-  keepaliveHTTPSAgent;
-  keepaliveHTTPAgent;
-  wsHandler: WSSequenceHandler;
-
-  constructor(
-    private httpAgent,
-    parameters: Parameters[],
-    private domainsWhiteList: string[],
-  ) {
-    this.parameters = parameterUtils.resolveAllExpressions(parameters);
-    this.keepaliveHTTPSAgent = new HTTPSAgent({
-      timeout: SOCKET_TIMEOUT,
-      freeSocketTimeout: SOCKET_TIMEOUT / 2
-    });
-    this.keepaliveHTTPAgent = new HTTPAgent({
-      timeout: SOCKET_TIMEOUT,
-      freeSocketTimeout: SOCKET_TIMEOUT / 2
-    });
-    this.postScriptRunner = new PostScriptRunner();
-    this.wsHandler = new WSSequenceHandler();
-  }
-
-  startAndPass(requests: LoadmillRequest[]) {
-    return this.start(requests).then(this.passStats, this.passStats);
-  }
-
-  passStats = () => ({
-    failures: this.failures,
-    avgResTime: this.avgResTime,
-    requestStats: this.requestStats,
-    successfulHits: this.successfulHits,
-    resolvedRequests: this.resolvedRequests,
-    lastStartedIndex: this.lastStartedIndex,
-  });
-
-  async start(requests: LoadmillRequest[]) {
-    for (let reqIndex = 0; reqIndex < requests.length; ++reqIndex) {
-      const request = requests[reqIndex];
-
-      this.resolvedRequests[reqIndex] = {};
-
-      try {
-        const skipIndex = this.getSkipIndexIfShould(
-          request,
-          reqIndex,
-          requests
-        );
-
-        if (skipIndex != null) {
-          reqIndex = skipIndex - 1;
-          continue;
-        }
-
-        if (this.shouldStop(request)) {
-          return;
-        }
-
-        await this.waitBeforeRequest(request);
-
-        this.lastStartedIndex = reqIndex;
-        await this.executeRequest(request, reqIndex);
-
-      } catch (error) {
-        if (error.histogram) {
-          this.setRequestFailure(reqIndex, error.histogram);
-        }
-
-        // Failures could be set before error was thrown,
-        // i.e. !error.histogram && !_.isEmpty(this.failures[reqIndex])
-        // CAN be true:
-        if (isEmpty(this.failures[reqIndex])) {
-          // Reaching here indicates a bug!
-          const reason = 'Unexpected sampler error';
-
-          this.setSingleFailure(reqIndex, reason);
-
-          const { stack, message } = error;
-
-          const unexpectedError = {
-            message,
-            stack: '' + stack,
-            properties: JSON.stringify(error),
-          };
-
-          this.resolvedRequests[reqIndex].unexpectedError = unexpectedError;
-
-          log.info(reason, error);
-          log.info('Unexpected error info:', unexpectedError);
-        }
-
-        this.wsHandler.closeAllConnections();
-        throw error;
-      }
-    }
-    this.wsHandler.closeAllConnections();
-  }
-
-  shouldStop(request: LoadmillRequest) {
-    return this.isTruthyParameter('stop', request.stopBefore);
-  }
-
-  shouldStopLooping(loop?: LoopConf) {
-    const asserter = new Asserter(this.parameters);
-    return loop && loop.assert && asserter.assert(loop.assert);
-  }
-
-  hasLoopingFailed(loop?: LoopConf) {
-    const asserter = new Asserter(this.parameters);
-    return loop && loop.assert && !asserter.assert(loop.assert);
-  }
-
-  isTruthyParameter(conditionType, parameterName?: string) {
-    const value =
-      parameterName &&
-      parameterUtils.resolveParameter(parameterName, this.parameters, (err) =>
-        setParameterErrorHistogram(
-          err,
-          `Failed to compute ${conditionType} condition - `
-        )
-      );
-    return valueUtils.isTruthyParameterValue(value);
-  }
-
-  getSkipIndexIfShould(
-    request: LoadmillRequest,
-    reqIndex: number,
-    requests: LoadmillRequest[]
-  ) {
-    const { skipBefore, disabled } = request;
-
-    if (disabled) {
-      return reqIndex + 1;
-    }
-
-    if (skipBefore) {
-      const { goTo, negate, condition } = skipBefore;
-
-      const shouldSkip = this.isTruthyParameter('skip', condition);
-      if ((shouldSkip && !negate) || (!shouldSkip && negate)) {
-        if (goTo) {
-          return findRequestIndex(requests, goTo);
-        } else {
-          return reqIndex + 1;
-        }
-      }
-    }
-  }
-
-  async waitBeforeRequest(request: LoadmillRequest) {
-    const rawDelay = request.delay || DEFAULT_REQUEST_DELAY;
-    const delay = clamp(
-      Math.round(
-        Number(
-          isParameterCandidate(rawDelay)
-            ? parameterUtils.resolveParameter(
-              rawDelay,
-              this.parameters,
-              (err) =>
-                setParameterErrorHistogram(
-                  err,
-                  'Failed to compute request delay - '
-                )
-            )
-            : rawDelay
-        )
-      ),
-
-      MIN_REQUEST_DELAY,
-      Infinity
-    );
-
-    const problem = validateIntegerDelay(delay, false);
-
-    if (problem) {
-      throw new RequestFailuresError(`Invalid Request Delay: ${problem}`);
-    }
-
-    await promiseUtils.delay(delay);
-  }
-
-  setRequestFailure(index: number, histogram: Histogram) {
-    this.failures[index] = OneFailure(histogram);
-  }
-
-  async executeRequest(requestConf: LoadmillRequest, index: number) {
-    let failedAssertionsHistogram, resTime;
-    let loopIteration = 0;
-    const maxIterations = getLoopIterations(requestConf.loop);
-
-    while (loopIteration < maxIterations) {
-      loopIteration++;
-      this.initVolatileParameters();
-      const request = this.prepareRequest(requestConf, index);
-
-      const res = await this.sendRequest(request, index);
-
-      // Setting now to avoid possible user overwrite:
-      resTime = Number(this.parameters.__responseTime);
-
-      const { timeout = DEFAULT_REQUEST_TIMEOUT } = requestConf;
-      if (resTime > timeout) {
-        throw new RequestFailuresError(
-          `Response received after timeout of ${timeout}ms exceeded`
-        );
-      }
-
-      res.wsExtractionData = { messages: this.wsHandler.messages, timeLimit: timeout - resTime } as WSExtractionData;
-
-      failedAssertionsHistogram = await this.processSuccessfulResponse(
-        index,
-        requestConf,
-        res
-      );
-
-      this.resolvedRequests[index].retried = loopIteration > 1 ? loopIteration - 1 : undefined;
-      if (loopIteration < maxIterations) {
-        if (this.shouldStopLooping(requestConf.loop)) {
-          break;
-        } else {
-          await promiseUtils.delay(1000); // todo yigal - make this configrable?
-        }
-      } else {
-        if (this.hasLoopingFailed(requestConf.loop)) {
-          throw new RequestFailuresError(
-            `Request failed to meet loop condition for ${maxIterations} iterations`
-          );
-        }
-      }
-    }
-
-    if (!isEmpty(failedAssertionsHistogram)) {
-      const message = 'Request failed due to assertions.';
-
-      log.debug(message, {
-        failedAssertionsHistogram,
-        parameters: this.parameters,
-      });
-
-      throw new RequestFailuresError(message, failedAssertionsHistogram);
-    }
-
-    this.onRequestSuccess(index, resTime);
-    this.removeVolatilePostParameters(index);
-  }
-
-  onRequestSuccess(index: number, resTime: number) {
-    this.avgResTime = mathUtils.calcAvg(this.avgResTime, this.successfulHits, resTime, 1);
-    ++this.successfulHits;
-
-    setReqStats(this.requestStats, index, resTime);
-  }
-
-  initVolatileParameters() {
-    Object.values(BUILT_IN_VOLATILE_PARAMS)
-      .forEach((param: string) => this.parameters[param] = '');
-  }
-
-  setVolatileParameters(param, val) {
-    this.parameters[param] = val;
-  }
-
-  removeVolatilePostParameters(idx: number) {
-    Object.values(BUILT_IN_VOLATILE_PARAMS).forEach((val: string) => {
-      const postParams = this.resolvedRequests[idx].postParameters;
-      if (postParams) {
-        const toRemove = postParams.findIndex(param => !isEmpty(param[val]));
-        toRemove >=0 && postParams.splice(toRemove, 1);
-      }
-    });
-  }
-
-  async sendRequest(request, reqIndex: number) {
-    let res, reqId;
-    const redirectHeaders: any = [];
-    const requestStartTime = Date.now();
-
-    const beforeTime = isPerformance ? performance.now() : requestStartTime;
-
-    if (typeof loadmillClearResponses === 'function') {
-      await loadmillClearResponses();
-      reqId = randomstring.generate(30);
-      request.query({ [reqIdParamName]: reqId });
-    }
-
-    const setTimeParams = () => {
-      const responseEndTime = Date.now();
-
-      const afterTime = isPerformance ? performance.now() : responseEndTime;
-
-      this.parameters.__requestStartTime = '' + requestStartTime;
-      this.parameters.__responseEndTime = '' + responseEndTime;
-      this.parameters.__responseTime = '' + Math.round(afterTime - beforeTime);
-    };
-
-    const setResolvedResponse = ({
-      text,
-      type,
-      status,
-      headers,
-      statusText = '',
-      resRequest,
-    }) => {
-      text = text || '';
-      type = type || '';
-      statusText = statusText || '';
-
-      this.parameters.__status = '' + status;
-      this.parameters.__statusText = statusText;
-
-      if (text.length > MAX_RESPONSE_COLLECT) {
-        text = text.slice(0, MAX_RESPONSE_COLLECT - 1) + '\n...';
-      }
-
-      this.resolvedRequests[reqIndex].response = {
-        type,
-        text,
-        status,
-        statusText,
-        headers: manipulationUtils.objToSingletonArray(headers),
-      };
-
-      // add the request! cookies in case we have any
-      const requestHeaders: LoadmillHeaders[] | undefined = this.resolvedRequests[reqIndex]?.headers;
-      if (requestHeaders) {
-        if (resRequest._headers && resRequest._headers.cookie) {
-          const cookie = { 'cookie': resRequest._headers.cookie };
-          const idx = requestHeaders.findIndex(item => Object.keys(item).includes('cookie'));
-          requestHeaders[idx > 0 ? idx : requestHeaders.length] = cookie;
-        }
-      }
-
-      // May be reset after extractions.
-      // This way it is set for failed statuses as well:
-      this.setPostParameters(reqIndex);
-    };
-
-    request.on('redirect', res => {
-      redirectHeaders.push(res.headers.location);
-    });
-
-    try {
-      res = await request.ok((res) => {
-        const status = res.status;
-
-        setTimeParams();
-        setResolvedResponse({
-          status,
-          type: res.type,
-          text: res.text,
-          headers: extendResponseHeaders(res.header, redirectHeaders),
-          statusText: res.xhr ? res.xhr.statusText : res.res!.statusMessage,
-          resRequest: res.req
-        });
-
-        return isExpectedStatus(request, status);
-      });
-    } catch (error) {
-      log.debug('Request failed:', error);
-      const { status, message } = error;
-
-      const prefix = status ? `HTTP status ${status} - ` : '';
-      let reportedReason = prefix + message;
-
-      if (message === superagentCorsError) {
-        if (typeof loadmillGetResponse === 'function') {
-          setTimeParams();
-
-          const response = await loadmillGetResponse(reqId);
-          log.debug(
-            'Got response from oracle:',
-            JSON.stringify({ reqId, response })
-          );
-
-          reportedReason =
-            (response.preFlight
-              ? corsPreFlightErrorStatusPrefix
-              : corsErrorStatusPrefix) + response.status;
-
-          this.resolvedRequests[reqIndex].headers = manipulationUtils.objToSingletonArray(
-            response.requestHeaders
-          );
-          setResolvedResponse({
-            ...(response as any),
-            type: response.headers['content-type'],
-          });
-        } else {
-          reportedReason = unknownStatusCorsError;
-        }
-      }
-
-      throw new RequestFailuresError(message, { [reportedReason]: 1 });
-    }
-
-    const failure = this.failures[reqIndex];
-    if (failure) {
-      log.debug('Request aborted due to failures:', failure.histogram);
-      throw Error('Request aborted');
-    }
-
-    return res;
-  }
-
-  prepareRequest(requestConf: LoadmillRequest, reqIndex: number) {
-    if (this.isWSRequest(requestConf) && !envUtils.isBrowser()) {
-      return this.prepareWSRequest(requestConf, reqIndex);
-    }
-    return this.prepareHttpRequest(requestConf, reqIndex);
-  }
-  private isWSRequest({ url }: LoadmillRequest) {
-    const resolvedUrl = this.resolve(url, (e) => setParameterErrorHistogram(e, 'Failed to compute URL - '));
-    return resolvedUrl.startsWith('ws://') || resolvedUrl.startsWith('wss://');
-  }
-  private prepareHttpRequest(requestConf: LoadmillRequest, reqIndex: number) {
-    const urlObj = new URI(
-      resolveUrl(requestConf.url, this.parameters, (err: Error) =>
-        setParameterErrorHistogram(err, 'Failed to compute URL - ')
-      )
-    );
-
-    // these are empty strings when missing!
-    const user = urlObj.username();
-    const password = urlObj.password();
-
-    if (user || password) {
-      // null to make sure they won't be part of the URL no more:
-      urlObj.username(null as any);
-      urlObj.password(null as any);
-      requestConf.auth = { user, password };
-    }
-
-    const url = urlObj.toString();
-    this.resolvedRequests[reqIndex].url = url;
-
-    this.validateDomain(uriUtils.getDomain(url));
-
-    const method = requestConf.method.toLowerCase();
-
-    const request = this.httpAgent[method](url);
-    if (!envUtils.isBrowser()) {
-      setTCPReuse(request, this.keepaliveHTTPAgent, this.keepaliveHTTPSAgent);
-    }
-
-    request.timeout(requestConf.timeout);
-    requestConf.noRedirects && request.redirects(0);
-
-    const auth = requestConf.auth;
-
-    if (auth != null && request._header['authorization'] == null) {
-      request.auth(auth.user || '', auth.password || '');
-    }
-
-    this.preparePostData(requestConf, request, reqIndex);
-
-    // todo itay: instead we should collect from all extractions but some kind of `defer` flag to header extractors:
-    const extractionHeaders = flatMap(
-      requestConf.extract,
-      this.collectExtractionHeaders
-    ).filter(isNonSimpleResponseHeader);
-
-    if (!isEmpty(extractionHeaders)) {
-      // this is not required in a node environment but also does not matter
-      // thus we prefer to keep it in order to reduce dissimilarities:
-      //todo itay: allow users to overwrite / disable this headers?
-      request.set(
-        'Loadmill-Request-Expose-Headers',
-        extractionHeaders.join(',')
-      );
-    }
-
-    // Prevent large downloads:
-    const progressHandler = (event) =>
-      this.checkProgressEvent(reqIndex, request, event);
-
-    if (envUtils.isBrowser()) {
-      // Because superagent adds upload handlers which cause
-      // requests to be non-simple (in Firefox) we use the XHR object directly:
-      request.on('request', ({ xhr }) => (xhr.onprogress = progressHandler));
-
-      // Disable parsing:
-      request.parse(() => null);
-
-      if (requestConf.useCookies) {
-        log.trace('Enabling cookies for CORS client.');
-        request.withCredentials();
-      }
-
-      // Penetrate browser cache:
-      if (method === 'get') {
-        const simpleRequest = isSimpleRequest(request._header);
-        const cachePenetration = requestConf.cachePenetration || {};
-        const mode = cachePenetration.mode || CachePenetrationModes.def;
-
-        if (
-          mode === CachePenetrationModes.alwaysQuery ||
-          (mode === CachePenetrationModes.def && simpleRequest)
-        ) {
-          // Avoid pre-flight:
-          request.query({ 'loadmill-cache-key': randomstring.generate(15) });
-        } else if (
-          request._header['cache-control'] == null &&
-          (mode === CachePenetrationModes.alwaysHeader ||
-            (mode === CachePenetrationModes.def && !simpleRequest))
-        ) {
-          // Since request is pre-flighted anyway, adding this header shouldn't hurt.
-          // It is better in this case because pre-flight response can be cached:
-          request.set(
-            'Cache-Control',
-            cachePenetration.cacheControl || DEFAULT_CACHE_CONTROL
-          );
-        }
-      }
-    } else {
-      // todo itay: consider using `_maxResponseSize` in node:
-      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 -
-      // better have something more general (in case the user didnt set one):
-      const uaHeader = request.get('User-Agent');
-      if (!uaHeader || uaHeader.startsWith('node-superagent')) {
-        request.set('User-Agent', 'loadmill/v' + millVersionString);
-      }
-    }
-
-    this.resolvedRequests[reqIndex].headers = manipulationUtils.objToSingletonArray(
-      request.header
-    );
-
-    request.expectedStatus = requestConf.expectedStatus || ALLOWED_RESPONSE_STATUSES.SUCCESS;
-
-    return request;
-  }
-
-  private setHeaders(headers: LoadmillHeaders[] | undefined, request: any, filter = (_h: LoadmillHeaders) => true) {
-    if (headers && !isEmpty(headers)) {
-      this.resolveHeaders(headers)
-        .filter(filter)
-        .forEach(({ name, value }) => request.set(name, value));
-    }
-  }
-
-  private preparePostData(requestConf: LoadmillRequest, request: any, reqIndex: number) {
-
-    // Order matters! It is CRUCIAL that the type is set before the body.
-    // So first, set only the content-type header, after set the body, then volatiles and then the rest of the headers
-    // Rest of the headers should be set after the postData so we can use the body in headers
-
-    const headers = requestConf.headers;
-    this.setHeaders(headers, request, (h) => h.name.toLowerCase() === 'content-type');
-
-    const { postData, postFormData } = requestConf;
-    let data;
-    if (postFormData) {
-      data = this.preparePostFormData(postFormData, request, reqIndex);
-    }
-    else if (postData) {
-      data = this.prepareRawPostData(postData, request, data, reqIndex);
-    }
-
-    this.setVolatileParameters(BUILT_IN_VOLATILE_PARAMS.requestBody, data);
-    this.setHeaders(headers, request, (h) => h.name.toLowerCase() !== 'content-type');
-  }
-
-  private prepareRawPostData(postData: RequestPostData, request: any, data: any, reqIndex: number) {
-    // It is CRUCIAL that the type is set before the body:
-    const mimeType = postData.mimeType;
-    if (mimeType && request._header['content-type'] == null) {
-      // set Content-Type header if not already present:
-      request.type(mimeType);
-    }
-
-    data = this.resolve(postData.text, (err) => setParameterErrorHistogram(err, 'Failed to compute request body - ')
-    );
-
-    if (data && data.length > getMaxRequestBodySize()) {
-      throw new RequestFailuresError('Request body size is too large');
-    }
-
-    // This invocation will behave differently according to different types set on the request:
-    request.send(data);
-
-    this.resolvedRequests[reqIndex].postData = {
-      mimeType,
-      text: data,
-    };
-    return data;
-  }
-
-  private preparePostFormData(postFormData: PostFormData, request: any, reqIndex: number) {
-    const resolvedPostFormData: PostFormData = [];
-    let size = 0;
-    const MAX_BODY_SIZE = getMaxRequestBodySize();
-    for (const entry of postFormData) {
-      const { name, value, fileName } = entry;
-      const resolvedName = this.resolve(name, (err) => setParameterErrorHistogram(err, 'Failed to resolve form-data key - '));
-      size += resolvedName.length;
-      if (fileName) {
-        const resolvedFileName = this.resolve(fileName, (err) => setParameterErrorHistogram(err, 'Failed to resolve form-data fileName - '));
-        size += (resolvedFileName.length + value.length);
-        const buffer = Buffer.from(value, 'binary');
-        request.attach(resolvedName, buffer, resolvedFileName);
-        resolvedPostFormData.push({ name: resolvedName, value, fileName: resolvedFileName });
-      } else {
-        const resolvedValue = this.resolve(value, (err) => 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 RequestFailuresError('Form Data size is too large');
-      }
-    }
-
-    this.resolvedRequests[reqIndex].postFormData = resolvedPostFormData;
-    return resolvedPostFormData;
-  }
-
-  prepareWSRequest(requestConf: LoadmillRequest, reqIndex: number) {
-    const wsRequestArgs = this.resolveAndSetWSReqData(requestConf, reqIndex);
-
-    return new WSRequest(
-      wsRequestArgs,
-      this.wsHandler,
-      (e: Error) => this.setSingleFailure(reqIndex, 'Websocket error: ' + e.message),
-    );
-  }
-
-  resolveAndSetWSReqData = (
-    { url, headers, postData, timeout = DEFAULT_REQUEST_TIMEOUT, expectedStatus = 'SUCCESS' }: LoadmillRequest,
-    reqIndex: number
-  ): WSRequestArguments => {
-    const preparedUrl = this.prepareWsUrl(url, reqIndex);
-
-    // order matters. headers should be set after the message so we can use the message in headers
-    const { resolvedMessage: preparedMessage, mimeType } = this.prepareWsMessage(postData, reqIndex);
-    const preparedHeaders = this.prepareWsHeaders(headers, reqIndex);
-
-    return {
-      expectedStatus,
-      headers: preparedHeaders,
-      message: preparedMessage,
-      mimeType,
-      timeout,
-      url: preparedUrl,
-    };
-  };
-
-  prepareWsUrl = (url: string, reqIndex: number) => {
-    const resolvedUrl = this.resolve(url, (e: Error) => setParameterErrorHistogram(e, 'Failed to compute URL - '));
-    this.resolvedRequests[reqIndex].url = resolvedUrl;
-    return resolvedUrl;
-  };
-
-  prepareWsHeaders = (headers: LoadmillHeaders[] | undefined, reqIndex: number) => {
-    const resolvedHeadersObj: LoadmillHeaders = {};
-    if (headers && !isEmpty(headers)) {
-      this.resolveHeaders(headers)
-        .forEach(({ name, value }) => resolvedHeadersObj[name] = value);
-    }
-    this.resolvedRequests[reqIndex].headers = manipulationUtils.objToSingletonArray(resolvedHeadersObj);
-    return resolvedHeadersObj;
-  };
-
-  prepareWsMessage = (postData: RequestPostData | undefined, reqIndex: number): { resolvedMessage: string, mimeType: WSMimeType} => {
-    let resolvedMessage: string = '';
-    const mimeType = postData?.mimeType === 'binary' ? 'binary' : 'text';
-    if (postData) {
-      resolvedMessage = this.resolve(postData.text, (err: Error) =>
-        setParameterErrorHistogram(err, 'Failed to compute Websocket message - ')
-      );
-      if (resolvedMessage && resolvedMessage.length > getMaxRequestBodySize()) {
-        throw new RequestFailuresError('Websocket message size is too large');
-      }
-      this.resolvedRequests[reqIndex].postData = {
-        mimeType,
-        text: resolvedMessage,
-      };
-    }
-    this.setVolatileParameters(BUILT_IN_VOLATILE_PARAMS.requestBody, resolvedMessage);
-    return { resolvedMessage, mimeType };
-  };
-
-  checkProgressEvent = (
-    requestIndex: number,
-    request,
-    { total = 0, loaded }
-  ) => {
-    log.trace('Progress:', { total, loaded });
-
-    if ((total || loaded) >= MAX_RESPONSE_BYTES) {
-      this.setSingleFailure(requestIndex, 'Response size is too large');
-      request.abort();
-    }
-  };
-
-  private validateDomain(domain: string) {
-    if (isEmpty(domain)) {
-      const message = 'HTTP request domain name is empty';
-      throw new RequestFailuresError(message, { [message]: 1 });
-    }
-
-    if (validate.isUrl(domain)) {
-      const message = `HTTP request domain name [${domain}] is not valid`;
-      throw new RequestFailuresError(message, { [message]: 1 });
-    }
-
-    else if (!uriUtils.isVerified(domain, this.domainsWhiteList)) {
-      const message = `HTTP request domain name [${domain}] is not on white list`;
-      throw new RequestFailuresError(message, { [message]: 1 });
-    }
-  }
-
-  setSingleFailure(reqIndex, reason: string) {
-    return this.setRequestFailure(reqIndex, { [reason]: 1 });
-  }
-
-  resolveHeaders(headers: LoadmillHeaders[]) {
-    return flatMap(headers, (aHeaders) =>
-      map(aHeaders, (value, name) => ({
-        name,
-        value: this.resolve(value, (err) =>
-          setParameterErrorHistogram(
-            err,
-            `Failed to compute ${name} header value - `
-          )
-        ),
-      }))
-    );
-  }
-
-  collectExtractionHeaders = (extractions: Extractions) =>
-    filter(
-      extractions,
-      (extraction: any) => extraction.header != null
-    ).map((extraction: ExtractionObj) =>
-      this.resolve(extraction.header!, (err) =>
-        setParameterErrorHistogram(
-          err,
-          `Failed to compute extraction header ${extraction.header} - `
-        )
-      )
-    );
-
-  async processSuccessfulResponse(reqIndex, requestConf: LoadmillRequest, res) {
-    // modifies parameters:
-    await this.handleExtractions(requestConf, res);
-
-    if (!envUtils.isBrowser()) {
-      this.handlePostScript(requestConf, res);
-    }
-
-    this.setPostParameters(reqIndex);
-
-    const assertionResults = this.handleAssertions(requestConf) || [];
-    log.trace('Assertion results: ', assertionResults);
-
-    const failuresHistogram: any = {};
-
-    assertionResults.forEach((result, index) => {
-      if (!result) {
-        failuresHistogram[index] = 1;
-      }
-    });
-
-    return failuresHistogram;
-  }
-
-  setPostParameters(reqIndex: number) {
-    this.resolvedRequests[reqIndex].postParameters = manipulationUtils.objToSingletonArray(
-      this.parameters
-    ).filter(p => !isEmpty(p)); // cleaning param values that are function or undefined which resolves to empty object {}
-  }
-
-  async handleExtractions(requestConf: LoadmillRequest, res) {
-    for (const extractions of (requestConf.extract || [])) {
-      await this.extractInScope(res, extractions);
-    }
-  }
-
-  async extractInScope(res, extractions: Extractions) {
-    const contextParameters = Object.assign({}, this.parameters);
-    const extractionCombiner = new ExtractionCombiner(contextParameters, res, res.wsExtractionData);
-
-    for (const [name, extraction] of Object.entries(extractions)) {
-      await this.extract(name, extraction, extractionCombiner);
-    }
-  }
-
-  async extract(
-    parameterName: string,
-    extraction: Extraction,
-    extractionCombiner: ExtractionCombiner
-  ) {
-    log.trace('Parameter extraction start: ', { parameterName, extraction });
-
-    const combinedExtractor = await extractionCombiner.combine(extraction);
-    let result;
-
-    try {
-      result = await combinedExtractor();
-    } catch (error) {
-      const genericMessage = `Failed to extract value for parameter "${parameterName}"`;
-      log.debug(genericMessage, error);
-
-      const { prettyMessage } = error;
-      const 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.trace('Parameter value:', this.parameters[parameterName]);
-  }
-
-  resolve(parametrized: string, onError) {
-    return parameterUtils.resolveExpression(
-      parametrized,
-      this.parameters,
-      onError
-    );
-  }
-
-  handlePostScript({ postScript }: LoadmillRequest, { text = '' }) {
-    if (postScript) {
-      testRunEventsEmitter.postScript.started();
-
-      try {
-        const result = this.runPostScript(postScript, text);
-        Object.assign(this.parameters, result);
-      } catch (e) {
-        const message = ['Post Script', e.name + ':', e.message].join(' ');
-        throw new RequestFailuresError(message);
-      }
-
-      testRunEventsEmitter.postScript.finished();
-    }
-  }
-
-  private runPostScript(postScript: string, text: string) {
-    const staticContext = this.getStaticContext(text);
-    return this.postScriptRunner.run({ staticContext }, this.parameters, postScript);
-  }
-
-  private getStaticContext(text: string) {
-    let $ = {};
-    try {
-      $ = JSON.parse(text);
-    } catch (e) {
-      log.debug('res text (body) cannot be JSON parsed', e.name, e.message);
-    }
-    return { $, __: parameterFunctionOperations };
-  }
-
-  handleAssertions(requestConf: LoadmillRequest) {
-    const asserter = new Asserter(this.parameters);
-    return requestConf.assert?.map((assertion: Assertion, index) => {
-      try {
-        return asserter.assert(assertion);
-      } catch (e) {
-        setParameterErrorHistogram(
-          e,
-          `Failed to compute assertion #${index + 1} - `
-        );
-        throw e;
-      }
-    });
-  }
-}
-
-function setParameterErrorHistogram(err, prefix) {
-  err.histogram = { [prefix + (err.prettyMessage || 'Parameter error')]: 1 };
-}
-
-function isNonSimpleResponseHeader(headerName: string) {
-  const normalized = headerName.toLowerCase();
-
-  return (
-    normalized !== 'cache-control' &&
-    normalized !== 'content-language' &&
-    normalized !== 'content-type' &&
-    normalized !== 'expires' &&
-    normalized !== 'last-modified' &&
-    normalized !== 'pragma'
-  );
-}
-
-function isSimpleRequest(headers) {
-  const contentType = headers['content-type'];
-
-  if (contentType) {
-    const [type] = contentType.split(';');
-
-    if (
-      type !== 'text/plain' &&
-      type !== 'multipart/form-data' &&
-      type !== 'application/x-www-form-urlencoded'
-    ) {
-      return false;
-    }
-  }
-
-  return !find(
-    headers,
-    (_, key: string) =>
-      key !== 'accept' &&
-      key !== 'accept-language' &&
-      key !== 'content-language' &&
-      key !== 'content-type'
-  );
-}
-
-const getLoopIterations = (LoopConf?: LoopConf) => {
-  const declared = (LoopConf && LoopConf.iterations) || 1;
-  return Math.min(MAX_REQUEST_LOOPS_ITERATIONS, declared);
-};
-
-const extendResponseHeaders = (headers, redirectHeaders) => {
-  if (!isEmpty(redirectHeaders) && headers) {
-    redirectHeaders.forEach((loc, idx) => {
-      headers[`location_${idx + 1}`] = loc;
-    });
-    headers.location = redirectHeaders[redirectHeaders.length - 1]; // stroe the last one as location
-  }
-  return headers;
-};
-
-const isExpectedStatus = ({ expectedStatus, url }, status: number) => {
-  if (expectedStatus === ALLOWED_RESPONSE_STATUSES.SUCCESS) {
-    return (200 <= status && status < 400) || status === 101;
-  }
-  else if (expectedStatus === ALLOWED_RESPONSE_STATUSES.ERROR) {
-    log.debug('user asked to fail this request', url);
-    return 400 <= status && status < 600;
-  }
-  else if (expectedStatus === ALLOWED_RESPONSE_STATUSES.ANY) {
-    return true;
-  }
-  log.warn('Expected status is not valid, expectedStatus');
-  return false;
-};
-
-/**
- * Superagent reuse the same request when redirecting and they are overiding the URL
- * So, we are setting the agent after the URL is overrided because there might be a change of protocols
- * Well done Omril
- */
-const setTCPReuse = (request, agent, sslAgent) => {
-
-  const _oldRequest = request.request;
-  request.request = function (...args) {
-    // first intercept the request and do our stuff
-    const { url } = this;
-
-    if (url.startsWith('https:')) {
-      this.agent(sslAgent);
-    } else {
-      this.agent(agent);
-    }
-
-    // then continue with superagent logic
-    _oldRequest.apply(this, ...args);
-  };
-
-};