@loadmill/core 0.3.49 → 0.3.52

package/src/parameters/parameter-functions/textual-parameter-functions.ts

@@ -1,464 +0,0 @@
-import defaultTo = require('lodash/defaultTo');
-import isEmpty = require('lodash/isEmpty');
-import isEqual = require('lodash/isEqual');
-import uniqWith = require('lodash/uniqWith');
-import escapeRegExp = require('lodash/escapeRegExp');
-import isNaN = require('lodash/isNaN');
-
-import { RegexExtractor } from '../extractors/regex-extractor';
-import { CheerioExtractor } from '../extractors/cheerio-extractor';
-import { BasicParameterFunction } from './parameter-function-utils';
-import { JsonPathExtractor } from '../extractors/json-path-extractor';
-import {
-  isTruthyParameterValue,
-  parameterValueToNumber,
-  pickRandom,
-  RANDOM_SELECT_OPT,
-} from '../value-utils';
-import isUUID from 'validator/lib/isUUID';
-import * as uriUtils from '@loadmill/universal/dist/uri-utils';
-import { PresentableError } from '@loadmill/universal/dist/errors';
-import { nodeBtoa } from '@loadmill/universal/dist/string-utils';
-import { applyJSONSchema } from './json-schema';
-import { toSha, toHMAC, FORMATS, HASH } from './crypto';
-
-const MAX_NOW_LENGTH = 13; // max length UTC until 2286
-
-const nowParameterFunction = new BasicParameterFunction((length) => {
-  const now = Date.now();
-  if (length && +length > 0) {
-    return ('' + now).substring(0, Math.min(+length, MAX_NOW_LENGTH));
-  }
-  return now;
-}, 0, 1);
-
-const nodeAtob = (text = '') => Buffer.from(text, 'base64').toString('utf8');
-export const base64decode = typeof atob !== 'undefined' ? atob : nodeAtob;
-
-export const base64encode = typeof btoa !== 'undefined' ? btoa : nodeBtoa;
-
-export const textualParameterFunctions = {
-  __usd: new BasicParameterFunction(() => '$', 0, 0),
-
-  __eq: new BasicParameterFunction((x, y) => x === y, 2, 2),
-  __neq: new BasicParameterFunction((x, y) => x !== y, 2, 2),
-  __eqi: new BasicParameterFunction(
-    (x, y) => x.toLowerCase() === y.toLowerCase(),
-    2,
-    2
-  ),
-  __neqi: new BasicParameterFunction(
-    (x, y) => x.toLowerCase() !== y.toLowerCase(),
-    2,
-    2
-  ),
-  __to_number: new BasicParameterFunction((str) => Number(str), 1, 1),
-  __matches: new BasicParameterFunction(
-    (target, regexStr) => new RegExp(regexStr).test(target),
-    2,
-    2
-  ),
-
-  __array_matches: new BasicParameterFunction(
-    (arrayAsStr, regex) => {
-      const arr: Array<string> = toArray(arrayAsStr);
-      return arr.length === 0 ? false : arr.every(a => RegExp(regex).test(JSON.stringify(a)));
-    },
-    2,
-    2
-  ),
-
-  __array_pluck: new BasicParameterFunction(
-    (arrayAsStr, ...keys) => {
-      if (!arrayAsStr) {
-        return JSON.stringify([]);
-      }
-      const arr: Array<object> = toArray(arrayAsStr);
-      return JSON.stringify(arr.length === 0 ? [] : arr.map((o => mapObject(o, keys))));
-    },
-    2
-  ),
-
-  __array_in_range: new BasicParameterFunction(
-    (arrayAsStr, start, end) => {
-      const arr: Array<string> = toArray(arrayAsStr);
-      return arr.length === 0 ? false : arr.every(el => Number(el) >= Number(start) && Number(el) <= Number(end));
-    },
-    3,
-    3
-  ),
-
-  // all parts of target are in src
-  __array_includes: new BasicParameterFunction(
-    (srcArrayAsStr, targetArrayAsStr) => {
-      const srcArr = toArray(srcArrayAsStr);
-      const tarArr = toArray(targetArrayAsStr);
-      return tarArr.every(el => srcArr.some(el2 => isEqual(el, el2)));
-    },
-    2,
-    2
-  ),
-
-  __array_sum: new BasicParameterFunction(
-    (arrayAsStr) => {
-      const arr = toArray(arrayAsStr);
-      return arr.reduce((x, y) => x + Number(y), 0);
-    },
-    1,
-    1
-  ),
-
-  __array_sort: new BasicParameterFunction(
-    (arrayAsStr) => {
-      const arr = toArray(arrayAsStr);
-      return JSON.stringify(arr.sort());
-    },
-    1,
-    1
-  ),
-
-  __array_sort_numbers: new BasicParameterFunction(
-    (arrayAsStr) => {
-      const arr = toNumbersArray(arrayAsStr);
-      return JSON.stringify(arr.sort(numbersComparator));
-    },
-    1,
-    1
-  ),
-
-  __array_is_unique: new BasicParameterFunction(
-    (arrayAsStr) => {
-      const arr = toArray(arrayAsStr);
-      return uniqWith(arr, isEqual).length === arr.length;
-    },
-    1,
-    1
-  ),
-
-  __contains: new BasicParameterFunction(
-    (str1, str2) => contains(str1, str2),
-    2,
-    2
-  ),
-  __containsi: new BasicParameterFunction(
-    (str1, str2) => contains(str1, str2, { ignoreCase: true }),
-    2,
-    2
-  ),
-
-  __is_uuid: new BasicParameterFunction((x) => isUUID(x), 1, 1),
-
-  __is_number: new BasicParameterFunction((x) => x != '' && !isNaN(Number(x)), 1, 1),
-
-  __length: new BasicParameterFunction((x) => x.length, 1, 1),
-
-  __array_length: new BasicParameterFunction((str) => toArray(str).length, 1, 1),
-
-  __escape_regexp: new BasicParameterFunction((x) => escapeRegExp(x), 1, 1),
-
-  __escape_quotes: new BasicParameterFunction(
-    (x) =>
-      x
-        .replace(/"/g, '\\$&')
-        //.replace(/\b/g, '\\b')
-        //.replace(/\f/g, '\\f')
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r')
-        .replace(/\t/g, '\\t'),
-    //.replace(/\\/g, '\\\\')
-    1,
-    1
-  ),
-
-  __encode_url: new BasicParameterFunction(uriUtils.encodePart, 1, 1),
-  __decode_url: new BasicParameterFunction(uriUtils.decodePart, 1, 1),
-
-  __decode_base64: new BasicParameterFunction(base64decode, 1, 1),
-  __encode_base64: new BasicParameterFunction(base64encode, 1, 1),
-
-  __lower: new BasicParameterFunction((x) => x.toLowerCase(), 1, 1),
-  __upper: new BasicParameterFunction((x) => x.toUpperCase(), 1, 1),
-
-  __if_then_else: new BasicParameterFunction(
-    (condition, onTrue, onFalse) =>
-      isTruthyParameterValue(condition) ? onTrue : onFalse,
-    3,
-    3
-  ),
-
-  __switch: new BasicParameterFunction(
-    (target, ...pairsAndDef) => switchSelect(target, pairsAndDef),
-    1
-  ),
-  __switchi: new BasicParameterFunction(
-    (target, ...pairsAndDef) =>
-      switchSelect(target, pairsAndDef, { ignoreCase: true }),
-    1
-  ),
-
-  __pick: new BasicParameterFunction(
-    (selection, ...pickFrom) => pick(selection, pickFrom),
-    2
-  ),
-
-  __pick_random: new BasicParameterFunction(
-    (...args) => pick(RANDOM_SELECT_OPT, args),
-    1
-  ),
-
-  __sha1: new BasicParameterFunction(
-    (secret, secretFormat = FORMATS.UTF8) => toSha(secret, HASH.SHA1, secretFormat),
-    1,
-    2
-  ),
-
-  __sha256: new BasicParameterFunction(
-    (secret, secretFormat = FORMATS.UTF8) => toSha(secret, HASH.SHA256, secretFormat),
-    1,
-    2
-  ),
-
-  __hmacSha1: new BasicParameterFunction(
-    (secret, secretFormat = FORMATS.UTF8, salt = '') => toHMAC(secret, HASH.SHA1, secretFormat, salt),
-    1,
-    3
-  ),
-
-  __hmacSha256: new BasicParameterFunction(
-    (secret, secretFormat = FORMATS.UTF8, salt = '') => toHMAC(secret, HASH.SHA256, secretFormat, salt),
-    1,
-    3
-  ),
-
-  __split_pick: new BasicParameterFunction(
-    (str: string, delim: string, selection = '0') =>
-      pick(selection, str.split(delim)),
-    2,
-    3
-  ),
-
-  __slice: new BasicParameterFunction(
-    (str, begin?, end?) => {
-      let beg;
-      if (begin != null) {
-        beg = toIndex('begin', begin);
-      }
-
-      let en;
-      if (end != null) {
-        en = toIndex('end', end);
-      }
-
-      return str.slice(beg, en);
-    },
-    1,
-    3
-  ),
-
-  __regexp: new BasicParameterFunction(
-    (target, query, def = '') => {
-      return defaultTo(
-        new RegexExtractor(() => target, {}).extractResolved(query),
-        def
-      );
-    },
-    2,
-    3
-  ),
-
-  __json_keys: new BasicParameterFunction(
-    (target, def = '') => defaultTo(objectStrToObjectKeysStr(target), def),
-    1,
-    2
-  ),
-
-  __jsonpath_keys: new BasicParameterFunction(
-    (target, query, def = '') => {
-      return defaultTo(
-        (() => {
-          const json = defaultTo(
-            new JsonPathExtractor(target, {}).extractResolved(query),
-            '{}'
-          );
-          return objectStrToObjectKeysStr(json);
-        })(),
-        def
-      );
-    },
-    2,
-    3
-  ),
-
-  __jsonpath: new BasicParameterFunction(
-    (target, query, def = '') => {
-      return defaultTo(
-        new JsonPathExtractor(target, {}).extractResolved(query),
-        def
-      );
-    },
-    2,
-    3
-  ),
-
-  __jsonpath_all: new BasicParameterFunction(
-    (target, query, def = '') => {
-      return defaultTo(
-        new JsonPathExtractor(target, {}).extractResolved(query, true),
-        def
-      );
-    },
-    2,
-    3
-  ),
-
-  __jsonpath_apply: new BasicParameterFunction(
-    (target, query, value) => {
-      return new JsonPathExtractor(target, {}).apply(query, value);
-    },
-    3,
-    3
-  ),
-
-  __jsonschema: new BasicParameterFunction(
-    (instance, schema) => {
-      return applyJSONSchema(instance, schema);
-    },
-    2,
-    2
-  ),
-
-  __jquery: new BasicParameterFunction(
-    (target, query, selection?, attr?, def = '') => {
-      return defaultTo(
-        new CheerioExtractor(target, {}).extractResolved(
-          query,
-          selection,
-          attr
-        ),
-        def
-      );
-    },
-    2,
-    5
-  ),
-
-  __now: nowParameterFunction,
-
-  __now_ms: nowParameterFunction,
-
-  __now_iso: new BasicParameterFunction(
-    (addedMinutes = '0') => new Date(new Date().getTime() + (Number(addedMinutes) * 1000 * 60)).toISOString(),
-    0,
-    1
-  ),
-
-  __date_iso: new BasicParameterFunction(
-    (addedDays = '0') => new Date(new Date().getTime() + (Number(addedDays) * 1000 * 60 * 60 * 24)).toISOString().substring(0, 10),
-    0,
-    1
-  ),
-};
-
-function pick(selection: string, pickFrom: any[]) {
-  if (selection === RANDOM_SELECT_OPT) {
-    return pickRandom(pickFrom);
-  } else {
-    const selectionIndex = toIndex('selection', selection);
-    if (pickFrom[selectionIndex] !== undefined) {
-      //empty string is ok to return
-      return pickFrom[selectionIndex];
-    } else {
-      throw new PresentableError(`Invalid selection index '${selection}'`);
-    }
-  }
-}
-
-function switchSelect(
-  target,
-  pairsAndDef: string[],
-  { ignoreCase } = { ignoreCase: false }
-) {
-  let matches = (key) => key === target;
-
-  if (ignoreCase) {
-    const compareTarget = target.toLowerCase();
-    matches = (key) => key.toLowerCase() === compareTarget;
-  }
-
-  const def = pairsAndDef.length % 2 > 0 ? pairsAndDef.pop() : '';
-
-  while (!isEmpty(pairsAndDef)) {
-    const [key, value, ...rest] = pairsAndDef;
-
-    if (matches(key)) {
-      return value;
-    }
-
-    pairsAndDef = rest;
-  }
-
-  return def;
-}
-
-function contains(str1, str2, { ignoreCase } = { ignoreCase: false }) {
-  if (ignoreCase) {
-    return str1.toLowerCase().includes(str2.toLowerCase());
-  } else {
-    return str1.includes(str2);
-  }
-}
-
-function toIndex(name: string, value: string) {
-  const numeric = parameterValueToNumber(value, { integer: true });
-
-  if (numeric == null) {
-    throw new PresentableError(`Invalid ${name} index '${value}'`);
-  }
-
-  return numeric;
-}
-
-const toNumbersArray = (arrayAsStr: string): number[] => {
-  const arr = toArray(arrayAsStr);
-  const numbersArr = arr.map(Number);
-  if (numbersArr.some(x => isNaN(x))) {
-    throw new PresentableError('Elements must be numbers [1,2] or numerical strings ["1","2"] or combination of both [1,"2"]');
-  }
-  return numbersArr;
-};
-
-const toArray = (arrayAsStr: string): Array<any> => {
-  try {
-    const arr: Array<any> = JSON.parse(arrayAsStr);
-    if (!Array.isArray(arr)) {
-      throw new PresentableError('must be a valid array: ex. [ 1, "str", true, null ]');
-    }
-    return arr;
-  } catch {
-    throw new PresentableError('must be a valid array: ex. [ 1, "str", true, null ]');
-  }
-};
-
-const objectStrToObjectKeysStr = (stringifiedObject: string): string => {
-  try {
-    const json = JSON.parse(stringifiedObject);
-    return JSON.stringify(Object.keys(json));
-  } catch {
-    throw new PresentableError('Not a valid JSON object');
-  }
-};
-
-const mapObject = (srcObj: object, keys: string[]) => {
-  const result = {};
-  for (const key of keys) {
-    if (key.includes(':')) {
-      const [src, target] = key.split(':');
-      result[target] = srcObj[src];
-    } else {
-      result[key] = srcObj[key];
-    }
-  }
-  return result;
-};
-
-const numbersComparator = (x: number, y: number) => x - y;

package/src/parameters/parameter-regex-providers.ts

@@ -1,74 +0,0 @@
-import { operators } from './operators';
-
-class OneOffRegExpProvider {
-  constructor(private regExp: RegExp) {}
-
-  use = (callback) => {
-    this.regExp.lastIndex = 0;
-    return callback(this.regExp);
-  };
-}
-
-const SPACES = '(?: +)';
-const LITERAL = '(?:\'[^,\'\\s]*\')';
-
-export const LEGAL_PARAM_CHARS = '_a-zA-Z0-9';
-const PARAMETER = '(?:[_a-zA-Z][' + LEGAL_PARAM_CHARS + ']*)';
-const PARAMETER_OR_LITERAL = `(?:${PARAMETER}|${LITERAL})`;
-
-const EXPRESSION = `(?:${LITERAL}|(?:(?:${PARAMETER}(?:\\((?:${PARAMETER_OR_LITERAL}(?:,${PARAMETER_OR_LITERAL})*)?\\))?)))`;
-
-const OPERATOR =
-  '(?:' + Object.values(operators).map((op) => op.regexSymbol).join('|') + ')';
-export const SPACED_OPERATOR = `${SPACES}${OPERATOR}${SPACES}`;
-
-// Capture groups designed to work with code mirror parser - be minded!
-export const PARAMETER_USAGE_PATTERN = `(\\\${)((?: *)(?:${EXPRESSION}(?:${SPACED_OPERATOR}${EXPRESSION})*)(?: *))(})`;
-
-export const spacesRegExpProvider = new OneOffRegExpProvider(
-  new RegExp(SPACES)
-);
-export const usageRegExpProvider = new OneOffRegExpProvider(
-  new RegExp(PARAMETER_USAGE_PATTERN)
-);
-export const globalUsageRegExpProvider = new OneOffRegExpProvider(
-  new RegExp(PARAMETER_USAGE_PATTERN, 'g')
-);
-
-const PARAM_USAGE_REGEXP_PREFIX = '\\${(.[^}]*)?';
-const PARAM_USAGE_REGEXP_SUFFIX = '([\\),\\s].*?)?}';
-
-const PARAM_GROUPING_REGEXP_PREFIX = '(?<pre>\\${.*?[\\(,])(?<param>';
-const PARAM_GROUPING_REGEXP_SUFFIX = ')(?<suff>[\\),].*?})';
-
-const PARAM_OPERATORS_GROUPING_REGEXP_PREFIX = `\\\${(?<pre>.*?${SPACED_OPERATOR}.*)?(?<param>.*`;
-const PARAM_OPERATORS_GROUPING_REGEXP_SUFFIX = `)(?<suff>${SPACED_OPERATOR}.*)?}`;
-
-export const getParameterUsageRegexp = (parameterName) =>
-  new RegExp(
-    `${PARAM_USAGE_REGEXP_PREFIX}${parameterName}${PARAM_USAGE_REGEXP_SUFFIX}`,
-    'g'
-  );
-
-export const getParameterfunctionGroupingRegexp = (parameterName) =>
-  new RegExp(
-    `${PARAM_GROUPING_REGEXP_PREFIX}${parameterName}${PARAM_GROUPING_REGEXP_SUFFIX}`
-  );
-
-export const getParameterOperatorsGroupingRegexp = (parameterName) =>
-  new RegExp(
-    `${PARAM_OPERATORS_GROUPING_REGEXP_PREFIX}${parameterName}${PARAM_OPERATORS_GROUPING_REGEXP_SUFFIX}`
-  );
-
-export const CAPTURE_REGEX = /(([^\\]\(|^\().*[^\\]\))/;
-
-export const PARAM_USAGE_REGEXP = /\$\{(.+)\}/;
-
-export const CAPTURE_ALL_REGEX = /(.*)/;
-
-export function isCaptureAllRegExp(regexp: RegExp): boolean {
-  return String(CAPTURE_ALL_REGEX) === String(regexp);
-}
-
-export const CSRF_REGEXP = '[^,; ]*?[cCxX](?:srf|SRF)[^\'" =:]*? *\\\\?["\']?(?:=|:) *\\\\?["\']([^\'"]+?)\\\\?["\']';
-export const getCsrfTokenByRegexp = (data: string) => new RegExp(CSRF_REGEXP).exec(data);

package/src/parameters/resolvers/random-parameters-resolver.ts

@@ -1,8 +0,0 @@
-import { generateRandom } from '../generate-random';
-
-export function resolveRandomParameter(parameterName: string) {
-  if (parameterName.startsWith('__random_')) {
-    const [, , , kind, arg1, arg2] = parameterName.split('_');
-    return generateRandom(kind, arg1, arg2);
-  }
-}

package/src/parameters/type.ts

@@ -1,7 +0,0 @@
-export type Parameters = { [name: string]: string | string[] };
-export type SequenceExecutorParameters = { [name: string]: any };
-
-export enum ParametersScope {
-    SUITE = 'SUITE',
-    FLOW = 'FLOW',
-  }

package/src/parameters/value-utils.ts

@@ -1,47 +0,0 @@
-import random = require('lodash/random');
-
-export const RANDOM_SELECT_OPT = 'random';
-
-const FALSY_AS_LOWERCASE_STRINGS = ['undefined','null','false','nan'];
-
-export function isTruthyParameterValue(value: any): boolean {
-  if (value && typeof value === 'string') {
-    const str = value.toLowerCase();
-    return !FALSY_AS_LOWERCASE_STRINGS.includes(str);
-  }
-  return !!value;
-}
-
-export function isFalsyParameterValue(value?: string | boolean) {
-  return (
-    value == null ||
-    value === false ||
-    (typeof value === 'string' && value.toLowerCase() === 'false') ||
-    value === ''
-  );
-}
-
-export function pickRandom(array: any[]) {
-  return array[random(0, array.length - 1)];
-}
-
-export function parameterValueToNumber(value?: string | null, options?) {
-  if (value == null || value === '') {
-    return null;
-  }
-
-  const numeric = Number(value);
-
-  if (Number.isFinite(numeric)) {
-    if (
-      options &&
-      ((options.integer && !Number.isSafeInteger(numeric)) ||
-        (options.nonNegative && numeric < 0))
-    ) {
-      return null;
-    }
-    return numeric;
-  } else {
-    return null;
-  }
-}