@loadmill/core 0.3.50 → 0.3.53

package/src/har/index.ts

@@ -1,81 +0,0 @@
-export interface Har {
-  log: HarLog;
-}
-
-export interface HarLog {
-  version: string;
-  entries: HarEntry[];
-}
-
-export interface HarEntry {
-  time: number;
-  request: HarRequest;
-  response: HarResponse;
-  startedDateTime: string;
-  _resourceType?: ResourceType;
-  _webSocketMessages?: WebSocketMessage[];
-}
-
-type ResourceType = 'main_frame' | 'sub_frame' | 'stylesheet' | 'script' | 'image' | 'font' |
-  'object' | 'xmlhttprequest' | 'ping' | 'csp_report' | 'media' | 'websocket' | 'other';
-
-export type WebSocketMessage = {
-  type: WebSocketMessageType,
-  time: number,
-  opcode: number,
-  data: string,
-};
-
-export type WebSocketMessageType = 'send' | 'receive';
-
-export interface HarRequest {
-  url: string;
-  method: string;
-  headers: HarHeaders;
-  bodySize: number;
-  postData?: HarPostData;
-  cookies: Cookie[]
-  queryString: { name: string, value: string }[];
-}
-
-export type HarHeaders = HarHeader[];
-
-export type HarHeader = {
-  name: string;
-  value: string;
-};
-
-export interface HarResponse {
-  status: number;
-  headers: HarHeaders;
-  statusText: string;
-
-  content: {
-    mimeType: string;
-    text?: string;
-    encoding?: string;
-  };
-}
-
-export type Cookie = {
-  name: string;
-  value: string;
-}
-
-export type HarPostData = {
-  mimeType: string;
-  text?: string;
-  params?: HarParam[];
-}
-
-export type HarParam = {
-  name: string;
-  value?: string;
-  fileName?: string;
-  contentType?: string;
-}
-
-export const isHar = (obj: any) => Boolean(obj.log) &&
-  typeof obj.log.version === 'string' &&
-  obj.log.version.startsWith('1.') &&
-  Array.isArray(obj.log.entries);

package/src/multipart-form-data/form-data-utils.ts

@@ -1,81 +0,0 @@
-import { HarParam } from '../har';
-import { PostFormData, PostFormDataEntry } from '../request';
-import { multipartFormDataTextToPostFormData } from './multipart-text-to-post-form-data';
-
-export class Form {
-  entries: HarParam[];
-  boundary: string;
-  constructor(entries?: HarParam[], boundary?: string) {
-    this.entries = entries || [];
-    this.boundary = boundary || this.generateBoundary();
-  }
-
-  generateBoundary = (): string => {
-    let boundary = '-'.repeat(26);
-    for (let i = 0; i < 24; i++) {
-      boundary += Math.floor(Math.random() * 10).toString(16);
-    }
-    return boundary;
-  };
-
-  append = (name: string, value: string, fileName?: string) => {
-    const entry: HarParam = { name, value };
-    fileName && (entry.fileName = fileName);
-    this.entries.push(entry);
-  };
-
-  toString = (): string => {
-    let result = '';
-    for (const { name, value, fileName, contentType } of this.entries) {
-      result += '--' + this.boundary + '\r\n';
-      result += `Content-Disposition: form-data; name="${name}"${this.addFileName(fileName)}${this.addContentType(contentType)}\r\n\r\n${value || ''}\r\n`;
-    }
-    result += '--' + this.boundary + '--\r\n';
-
-    return result;
-  };
-
-  private addFileName(fileName: string = '') {
-    let formattedFileName = '';
-    if (fileName) {
-      formattedFileName = `; filename="${fileName}"`;
-    }
-    return formattedFileName;
-  }
-
-  private addContentType = (contentType: string = ''): string => {
-    let formattedContentType = '';
-    if (contentType) {
-      formattedContentType = `\r\ncontent-type: ${contentType}`;
-    }
-    return formattedContentType;
-  }
-}
-
-export type FormEntry = { name: string, value: string, [other: string]: string };
-
-export function mapToMultipartFormData(request) {
-  const { postData: { params, text } } = request;
-  if (text) {
-    request.postFormData = multipartFormDataTextToPostFormData(text);
-  } else if (params) {
-    request.postFormData = multipartParamsToPostFormData(params);
-  }
-  delete request.postData;
-}
-
-const multipartParamsToPostFormData = (params: FormEntry[] = []) => {
-  const postFormData: PostFormData = [];
-  for (const p of params) {
-    const { name, value, fileName } = p;
-    const entry: PostFormDataEntry = { name, value };
-    if (fileName) {
-      entry.fileName = fileName;
-      entry.value = '';
-    }
-    postFormData.push(entry);
-  }
-  return postFormData;
-};
-
-export { multipartFormDataTextToPostFormData };

package/src/multipart-form-data/multipart-text-to-post-form-data.ts

@@ -1,89 +0,0 @@
-import { PostFormData, PostFormDataEntry } from '../request';
-
-export const multipartFormDataTextToPostFormData = (multipartFormDataText: string): PostFormData => {
-  const result: PostFormData = [];
-
-  const lines = getLines(multipartFormDataText);
-  for (const line of lines) {
-    const postFormDataEntry: PostFormDataEntry = extractPostFormDataEntry(line);
-    result.push(postFormDataEntry);
-  }
-  return result;
-};
-
-const getLines = (multipartFormDataText: string) => {
-  const boundary = getBoundary(multipartFormDataText);
-  const boundaryRegex = splitByBoundaryRegex(boundary);
-  const linesSplittedByBoundary = multipartFormDataText.split(boundaryRegex);
-  return removeEmptyLines(linesSplittedByBoundary);
-};
-
-const getBoundary = (multipartFormDataText: string): string => {
-  return multipartFormDataText.substring(0, multipartFormDataText.indexOf('\r\n'));
-};
-
-const splitByBoundaryRegex = (boundary: string) => {
-  const normalBoundary = boundary + '\r\n';
-  const lastBoundary = boundary + '--\r\n';
-  return new RegExp(`${normalBoundary}|${lastBoundary}`);
-};
-
-const removeEmptyLines = (lines: string[]): string[] => lines.filter(Boolean);
-
-const extractPostFormDataEntry = (line: string): PostFormDataEntry => {
-  const indexOfFirst2Newlines = line.indexOf('\r\n\r\n');
-
-  const fields = extractFields(line, indexOfFirst2Newlines);
-  const value = calculateValue(fields, line, indexOfFirst2Newlines);
-
-  const postFormDataEntry: PostFormDataEntry = { name: fields.name, value };
-  fields.fileName && (postFormDataEntry.fileName = fields.fileName);
-
-  return postFormDataEntry;
-};
-
-type Fields = Pick<PostFormDataEntry, 'name' | 'fileName'>;
-
-const extractFields = (line: string, indexOfFirst2Newlines: number): Fields => {
-  const rawFields = extractRawFields(line, indexOfFirst2Newlines);
-  const res: Fields = { name: '' };
-  const onlyRawNameFields = rawFields.split('\r\n')[0];
-  const tokens = onlyRawNameFields.split(';').map(t => t.trim());
-  for (const token of tokens) {
-    const [k, v] = token.split('=');
-    if (k === 'name') {
-      res.name = removeDoubleQuotes(v);
-    } else if (k === 'filename') {
-      res.fileName = removeDoubleQuotes(v);
-    }
-  }
-  return res;
-};
-
-const extractRawFields = (line: string, indexOfFieldsValueSeperator: number): string => {
-  return line.substring(0, indexOfFieldsValueSeperator);
-};
-
-const removeDoubleQuotes = (v: string): string => {
-  return v.replace(/"/g, '');
-};
-
-function calculateValue(fields: Fields, line: string, indexOfFirst2Newlines: number): string | '' {
-  return fields.fileName ? '' : extractValue(line, indexOfFirst2Newlines);
-}
-
-const extractValue = (line: string, indexOfFieldsValueSeperator: number): string => {
-  const value = line.substring(indexOfFieldsValueSeperator + 4);
-  return removeEndingNewline(value);
-};
-
-const removeEndingNewline = (s: string): string => {
-  if (s.endsWith('\r\n')) {
-    s = removeLast2Chars(s);
-  }
-  return s;
-};
-
-const removeLast2Chars = (s: string) => {
-  return s.substring(0, s.length - 2);
-};

package/src/parameters/extractions.ts

@@ -1,51 +0,0 @@
-import { Extractions } from '../request';
-import { parameterUtils } from '.';
-const { getParameterName } = parameterUtils;
-
-/**
- * Gets an extractions instance which looks like this: { [paramName]: string }.
- *
- * If it's an assign extraction, i.e { [paramName]: string }
- * OR { [paramName]: { jsonPath/jQuery/...: string } }
- * OR { [paramName]: { jQuery: { query: string, attr?: string } } }}}
- * And spreads this object into its parts.
- *
- * Example:
- * input ext = { my_ext: { jsonPath: '$["users"][0]["id"]' } }
- * output = { name: 'my_ext', value: '$["users"][0]["name"]', type: 'jsonPath' }
- *
- * @param ext The extraction object to take a part
- * @returns The spreaded parts of the given extraction object
- */
-export function getExtractionParts(ext: Extractions): {
-  name: string,
-  value: string | {
-    query: string;
-    attr?: string;
-  }
-  type?: string,
-} {
-  const name = getParameterName(ext);
-  const extContent = ext[name];
-  if (typeof extContent === 'string') {
-    return { name, value: extContent };
-  }
-  const [type] = Object.keys(extContent);
-  const value = ext[name][type];
-  return { name, value, type };
-}
-
-export function requestsExtractionsArr(requests, toIndex: number) {
-  const extractionParamNames = [] as string[];
-  for (let i = 0; i <= toIndex; i++) {
-    if (requests[i].extract) {
-      for (const param of requests[i].extract) {
-        const paramName = Object.keys(param)[0];
-        if (paramName && extractionParamNames.indexOf(paramName) < 0) {
-          extractionParamNames.push(paramName);
-        }
-      }
-    }
-  }
-  return extractionParamNames;
-}

package/src/parameters/extractors/cheerio-extractor.ts

@@ -1,57 +0,0 @@
-import cheerio from 'cheerio';
-import random = require('lodash/random');
-import { parameterValueToNumber, RANDOM_SELECT_OPT } from '../value-utils';
-import { Parameters } from '../type';
-import { ParametrizedExtractor } from './parametrized-extractor';
-import { PresentableError } from '@loadmill/universal/dist/errors';
-
-export class CheerioExtractor extends ParametrizedExtractor {
-  private $;
-
-  constructor(target, parameters: Parameters) {
-    super(parameters);
-    this.$ = cheerio.load(target);
-  }
-
-  extractResolved = (
-    resolvedJQuery: string,
-    selection: string = '0',
-    resolvedAttrName?: string
-  ) => {
-    let jQueryResult;
-
-    const matched = this.$(resolvedJQuery);
-    const numMatched = matched.length;
-
-    if (numMatched === 0) {
-      jQueryResult = null;
-    } else {
-      const index = getIndex(selection, numMatched);
-      const element = matched.eq(index);
-
-      if (resolvedAttrName) {
-        const attr = element.attr(resolvedAttrName);
-        jQueryResult = attr != null ? attr.toString() : null;
-      } else {
-        jQueryResult = element.html();
-      }
-    }
-
-    // log.debug('jQuery extraction:', { resolvedJQuery, jQueryResult });
-
-    return jQueryResult;
-  };
-}
-
-function getIndex(selection: string, len) {
-  let index: number | null;
-  if (selection === RANDOM_SELECT_OPT) {
-    index = random(0, len - 1);
-  } else {
-    index = parameterValueToNumber(selection, { integer: true });
-    if (index == null) {
-      throw new PresentableError('Invalid index: ' + selection);
-    }
-  }
-  return index;
-}

package/src/parameters/extractors/expression-extractor.ts

@@ -1,13 +0,0 @@
-import { Parameters } from '../type';
-import { ParametrizedExtractor } from './parametrized-extractor';
-
-export class ExpressionExtractor extends ParametrizedExtractor {
-  constructor(parameters: Parameters) {
-    super(parameters);
-  }
-
-  extractResolved = (resolvedQuery: string) => {
-    // log.debug('Expression extraction resolved:', resolvedQuery);
-    return resolvedQuery;
-  };
-}

package/src/parameters/extractors/extractor.ts

@@ -1,3 +0,0 @@
-export interface Extractor {
-  extract(query: string | string[]): (string | undefined) | Promise<string | undefined>;
-}

package/src/parameters/extractors/header-extractor.ts

@@ -1,24 +0,0 @@
-import { Parameters } from '../type';
-import { ParametrizedExtractor } from './parametrized-extractor';
-
-export class HeaderExtractor extends ParametrizedExtractor {
-  private headers;
-
-  constructor(res, parameters: Parameters) {
-    super(parameters);
-    this.headers = res.header;
-  }
-
-  extractResolved = (headerName: string) => {
-    const lowerCaseHeaderName = headerName.toLowerCase();
-    let headerValue = this.headers[lowerCaseHeaderName];
-
-    // some servers return more than one 'set-cookie' headers. For extractions we will merge them.
-    if (lowerCaseHeaderName === 'set-cookie' && Array.isArray(headerValue)) {
-      headerValue = headerValue.join('; ');
-    }
-    // log.debug('Header extraction:', { headerName, headerValue });
-
-    return headerValue;
-  };
-}

package/src/parameters/extractors/index.ts

@@ -1,10 +0,0 @@
-import { CheerioExtractor } from './cheerio-extractor';
-import { ExpressionExtractor } from './expression-extractor';
-import { Extractor } from './extractor';
-import { HeaderExtractor } from './header-extractor';
-import { JsonPathExtractor } from './json-path-extractor';
-import { ParametrizedExtractor } from './parametrized-extractor';
-import { RegexExtractor } from './regex-extractor';
-import { WsExtractor } from './ws-extractor';
-
-export { CheerioExtractor, ExpressionExtractor, Extractor, HeaderExtractor, JsonPathExtractor, ParametrizedExtractor, RegexExtractor, WsExtractor };

package/src/parameters/extractors/json-path-extractor.ts

@@ -1,63 +0,0 @@
-import jsonpath from 'jsonpath';
-import { Parameters } from '../type';
-import { ParametrizedExtractor } from './parametrized-extractor';
-import { PresentableError } from '@loadmill/universal/dist/errors';
-import log from '@loadmill/universal/dist/log';
-
-export class JsonPathExtractor extends ParametrizedExtractor {
-  private obj;
-  private parseError?;
-
-  _validateObj = () => {
-    const { parseError } = this;
-    if (parseError) {
-      throw new PresentableError(parseError);
-    }
-  };
-
-  constructor(target, parameters: Parameters) {
-    super(parameters);
-    try {
-      this.obj = JSON.parse(target);
-    } catch (e) {
-      this.parseError = e.message || 'Response body is not a valid JSON';
-    }
-  }
-
-  extractResolved = (jsonPath: string, full?) => {
-
-    this._validateObj();
-
-    let jsonPathResult;
-    if (jsonPath === '$') {
-      jsonPathResult = this.obj;
-    }
-    else {
-      jsonPathResult = full ? jsonpath.query(this.obj, jsonPath) : jsonpath.value(this.obj, jsonPath);
-    }
-
-    if (jsonPathResult != null) {
-      return typeof jsonPathResult === 'object'
-        ? JSON.stringify(jsonPathResult)
-        : jsonPathResult.toString();
-    }
-  };
-
-  apply = (jsonPath: string, value) => {
-    this._validateObj();
-
-    log.debug('JSONPath parameter apply:', { jsonPath, value });
-
-    jsonpath.apply(this.obj, jsonPath, () => {
-      try {
-        return JSON.parse(value);
-      } catch (error) {
-        return value;
-      }
-    });
-
-    log.debug('JSONPath parameter apply result:', { obj: this.obj });
-
-    return JSON.stringify(this.obj);
-  }
-}

package/src/parameters/extractors/parametrized-extractor.ts

@@ -1,27 +0,0 @@
-import { Extractor } from './extractor';
-import { parameterUtils } from '../';
-import { Parameters } from '../type';
-
-export abstract class ParametrizedExtractor implements Extractor {
-  abstract extractResolved: ResolvedExtracter;
-
-  constructor(private parameters: Parameters) {}
-
-  extract = (parametrizedQuery: string | string[]) => {
-    if (!Array.isArray(parametrizedQuery)) {
-      parametrizedQuery = [parametrizedQuery];
-    }
-
-    const resolvedQuery = parametrizedQuery.map(
-      (q) => q && parameterUtils.resolveExpression(q, this.parameters)
-    );
-    /* log.debug('Parametrized query resolution:', {
-      parametrizedQuery,
-      resolvedQuery,
-    }); */
-
-    return this.extractResolved(...resolvedQuery);
-  };
-}
-
-type ResolvedExtracter = ((...resolvedQuery: string[]) => string | undefined | Promise<string | undefined>);

package/src/parameters/extractors/regex-extractor.ts

@@ -1,18 +0,0 @@
-import { ParametrizedExtractor } from './parametrized-extractor';
-import { Parameters } from '../type';
-import { matchRegex } from './regex-matcher';
-
-export class RegexExtractor extends ParametrizedExtractor {
-  constructor(
-    private targetProvider: () => string | undefined,
-    parameters: Parameters
-  ) {
-    super(parameters);
-  }
-
-  extractResolved = (regex: string) => {
-    const target = this.targetProvider() || '';
-    const regExp = new RegExp(regex);
-    return matchRegex(regExp, target);
-  };
-}

package/src/parameters/extractors/regex-matcher.ts

@@ -1,17 +0,0 @@
-import log from '@loadmill/universal/dist/log';
-
-const MAX_STR_LENGTH = 500;
-
-export const matchRegex = (regExp: RegExp, target: string) => {
-  const matchArray = regExp.exec(target);
-
-  log.debug('Regex parameter extraction:', {
-    regExp,
-    type: typeof target,
-    target: typeof target === 'string' && target.substring(0, MAX_STR_LENGTH),
-  });
-
-  if (matchArray && matchArray[1]) {
-    return matchArray[1];
-  }
-};

package/src/parameters/extractors/ws-extractor.ts

@@ -1,91 +0,0 @@
-import findLast from 'lodash/findLast';
-import { PresentableError } from '@loadmill/universal/dist/errors';
-import log from '@loadmill/universal/dist/log';
-import { delay } from '@loadmill/universal/dist/promise-utils';
-import { CAPTURE_ALL_REGEX, isCaptureAllRegExp } from '../parameter-regex-providers';
-import { Parameters } from '../type';
-import { ParametrizedExtractor } from './parametrized-extractor';
-import { matchRegex } from './regex-matcher';
-
-export class WsExtractor extends ParametrizedExtractor {
-  private readonly _messages: string[];
-  private readonly _timeLimit: number;
-  private _regexp: RegExp;
-  constructor(
-    extractionData: WSExtractionData = { messages: [], timeLimit: 0 },
-    parameters: Parameters,
-  ) {
-    super(parameters);
-    this._messages = extractionData.messages;
-    this._timeLimit = extractionData.timeLimit;
-  }
-
-  extractResolved = async (resolvedRegex: string) => {
-    log.debug('Resolved WS extraction regex:', resolvedRegex);
-    this._regexp = new RegExp(resolvedRegex || CAPTURE_ALL_REGEX);
-    const wsMessage = await this.queryMessage();
-    log.debug('WS message queried and found:', wsMessage);
-
-    return matchRegex(this._regexp, wsMessage);
-  };
-
-  /**
-   * 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 async queryMessage(): Promise<string> {
-    const res = await this.getWSMessageOrTimeout();
-    if (!res) {
-      throw new PresentableError('Websocket waiting timeout expired');
-    }
-    return res;
-  }
-
-  private readonly GIVE_WS_MSG_TIME_MS = 250;
-
-  /**
-   * 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 async getWSMessageOrTimeout(): Promise<string | undefined> {
-    const startTime = Date.now();
-    let message = '';
-    let elapsedTime = 0;
-
-    while (!message && elapsedTime < this._timeLimit) {
-      message = this.findMessageByRegex() || '';
-      if (message) {
-        break;
-      }
-
-      await delay(this.GIVE_WS_MSG_TIME_MS);
-      elapsedTime = Date.now() - startTime;
-    }
-    return message;
-  }
-
-  private findMessageByRegex(): string | undefined {
-    if (isCaptureAllRegExp(this._regexp)) {
-      return this.getLastMessage();
-    }
-    return this.findLastMatchingMessage();
-  }
-
-  private getLastMessage(): string | undefined {
-    return this._messages[this._messages.length - 1];
-  }
-
-  private findLastMatchingMessage(): string | undefined {
-    return findLast(this._messages, msg => this._regexp.test(msg));
-  }
-}
-
-export type WSExtractionData = {
-  messages: string[];
-  timeLimit: number;
-}