@loadmill/core 0.3.51 → 0.3.52

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;
-}

package/src/parameters/generate-random.ts

@@ -1,114 +0,0 @@
-import uuid from 'uuid';
-import randomstring from 'randomstring';
-import clamp = require('lodash/clamp');
-import random = require('lodash/random');
-import { parameterValueToNumber } from './value-utils';
-import { PresentableError } from '@loadmill/universal/dist/errors';
-
-const MAX_RANDOM_LEN = 100;
-const DEFAULT_RANDOM_LEN = 10;
-// 2^32
-const DEFAULT_MAX_RANDOM_INT = 4294967296;
-
-export enum RandomTypes {
-  hex = 'hex',
-  uuid = 'uuid',
-  from = 'from',
-  chars = 'chars',
-  number = 'number',
-  digits = 'digits',
-  uppers = 'uppers',
-  lowers = 'lowers',
-  letters = 'letters',
-  boolean = 'boolean',
-}
-
-export function generateRandom(kind: string, arg1?: string, arg2?: string) {
-  if (!kind) {
-    return null;
-  }
-
-  if (kind === RandomTypes.uuid) {
-    return uuid.v4();
-  } else if (kind === RandomTypes.number) {
-    let min = 0,
-      max = DEFAULT_MAX_RANDOM_INT;
-
-    if (arg2) {
-      min = nonNegativeInt(arg1);
-      max = nonNegativeInt(arg2);
-
-      if (min > max) {
-        const temp = min;
-        min = max;
-        max = temp;
-      }
-    } else if (arg1) {
-      max = nonNegativeInt(arg1);
-    }
-
-    // Assumes both are integers!
-    return random(min, max);
-  } else if (kind === RandomTypes.boolean) {
-    const probability = nonNegativeInt(arg1, 50) / 100;
-
-    return (
-      probability >= 1 ||
-      (probability !== 0 && Math.random() <= probability)
-    ).toString();
-  } else {
-    const length = nonNegativeInt(
-      kind === RandomTypes.from ? arg2 : arg1,
-      DEFAULT_RANDOM_LEN
-    );
-    const options: { length; charset?; capitalization? } = {
-      length: clamp(length, 0, MAX_RANDOM_LEN),
-    };
-
-    if (kind === RandomTypes.chars) {
-      options.charset = 'alphanumeric';
-    } else if (kind === RandomTypes.digits) {
-      options.charset = 'numeric';
-    } else if (kind === RandomTypes.hex) {
-      options.charset = 'hex';
-    } else if (
-      kind === RandomTypes.letters ||
-      kind === RandomTypes.lowers ||
-      kind === RandomTypes.uppers
-    ) {
-      options.charset = 'alphabetic';
-
-      if (kind !== RandomTypes.letters) {
-        options.capitalization =
-          kind === RandomTypes.lowers ? 'lowercase' : 'uppercase';
-      }
-    } else if (kind === RandomTypes.from) {
-      if (!arg1) {
-        return null;
-      }
-      options.charset = arg1;
-    } else {
-      options.charset = kind;
-    }
-
-    return randomstring.generate(options);
-  }
-}
-
-function nonNegativeInt(arg?: string, def?: number) {
-  let value;
-
-  if (!arg) {
-    value = def;
-  } else {
-    value = parameterValueToNumber(arg, { integer: true, nonNegative: true });
-  }
-
-  if (value == null) {
-    throw new PresentableError(
-      'Argument must be a non-negative integer, instead found: ' + arg
-    );
-  }
-
-  return value;
-}