@loadmill/core 0.3.50 → 0.3.53

package/src/parameters/index.ts

@@ -1,621 +0,0 @@
-import isEmpty = require('lodash/isEmpty');
-import isEqual = require('lodash/isEqual');
-import uniqWith = require('lodash/uniqWith');
-import { Parameters, ParametersScope, SequenceExecutorParameters } from './type';
-import { pickRandom } from './value-utils';
-import * as valueUtils from './value-utils';
-import { operators, operatorsAsStrings } from './operators';
-import { resolveRandomParameter } from './resolvers/random-parameters-resolver';
-import {
-  canHaveNullParameterValue,
-  getParameterFunction,
-  parameterFunctionOperations,
-} from './parameter-functions/parameter-functions';
-import {
-  globalUsageRegExpProvider,
-  spacesRegExpProvider,
-  getParameterUsageRegexp,
-  getParameterfunctionGroupingRegexp,
-  getParameterOperatorsGroupingRegexp,
-  usageRegExpProvider,
-  PARAMETER_USAGE_PATTERN,
-  LEGAL_PARAM_CHARS,
-  CAPTURE_REGEX,
-  PARAM_USAGE_REGEXP,
-  CSRF_REGEXP,
-  getCsrfTokenByRegexp
-} from './parameter-regex-providers';
-import * as arrayUtils from '@loadmill/universal/dist/array-utils';
-import { PresentableError } from '@loadmill/universal/dist/errors';
-import { applyJSONSchema } from './parameter-functions/json-schema';
-import { Assertions, Extractions, RequestLike } from '../request';
-import { TestConfLike, validate } from '../conf';
-import { getLongestJsonPathToken } from './json-path-utils';
-
-class ParameterFunctionError extends PresentableError {
-  constructor(
-    public readonly functionName: string,
-    public readonly prettyError: string
-  ) {
-    super(`Error in function '${functionName}': ${prettyError}`);
-
-    // 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, ParameterFunctionError.prototype);
-  }
-}
-
-export const BUILT_IN_VOLATILE_PARAMS = {
-  requestBody: '__requestBody',
-};
-
-export const MAX_PARAM_ARRAY_SIZE = 100;
-export {
-  CAPTURE_REGEX,
-  getLongestJsonPathToken,
-  LEGAL_PARAM_CHARS,
-  parameterFunctionOperations,
-  Parameters,
-  ParametersScope,
-  PresentableError,
-  SequenceExecutorParameters,
-  usageRegExpProvider,
-  valueUtils,
-  CSRF_REGEXP,
-  getCsrfTokenByRegexp
-};
-export class ParameterError extends PresentableError {
-  constructor(
-    public readonly prettyError: string,
-    public readonly parameter: Parameters
-  ) {
-    super(`Error in parameter ${parameterUtils.getParameterName(parameter)}: ${prettyError}`);
-
-    // 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, ParameterError.prototype);
-  }
-}
-
-// Order of resolving!
-const parameterResolvers = [
-  resolveNoArgFunctionParameter,
-  // This one is legacy for e.g. __random_boolean_75:
-  resolveRandomParameter,
-  resolvePlainParameter,
-];
-
-export const parameterUtils = {
-  isParametrized(expression: string) {
-    return globalUsageRegExpProvider.use((regExp) => regExp.test(expression));
-  },
-
-  resolveAllExpressions(parameters: Parameters[]): Parameters {
-    const context: Parameters = {};
-
-    parameters.forEach((currentParameters: Parameters, index) => {
-      const temp: Parameters = {};
-
-      Object.keys(currentParameters).forEach(name => {
-        try {
-          const value = currentParameters[name];
-          temp[name] = parameterUtils.resolveExpression(
-            pickValue(value),
-            context
-          );
-        } catch (e) {
-          e['parameterName'] = name;
-          e['parameterIndex'] = index;
-          throw e;
-        }
-      });
-
-      Object.assign(context, temp);
-    });
-
-    return context;
-  },
-
-  resolveParameter(parameterName: string, parameters: Parameters, onError?) {
-    try {
-      for (const resolver of parameterResolvers) {
-        const value = resolver(parameterName, parameters);
-
-        if (value != null) {
-          return value;
-        }
-      }
-    } catch (e) {
-      if (onError) {
-        onError(e);
-      }
-
-      throw e;
-    }
-  },
-
-  resolveExpression(
-    parametrized: string,
-    parameters: Parameters | Parameters[],
-    onError?
-  ): string {
-    try {
-      if (Array.isArray(parameters)) {
-        parameters = parameterUtils.resolveAllExpressions(parameters);
-      }
-
-      return globalUsageRegExpProvider.use((usageRegExp) => typeof parametrized !== 'string' ? parametrized :
-        parametrized.replace(usageRegExp, (usage: string) => {
-          // No ${}:
-          const strippedExpression = usage.slice(2, -1).trim();
-
-          // [expression, ...[operator, expression, ...]]
-          const tokens = spacesRegExpProvider.use((spacesRegExp) =>
-            strippedExpression.split(spacesRegExp)
-          );
-
-          // null if undefined or invalid parameters:
-          const value = resolveTokens(tokens, parameters as Parameters);
-
-          /* log.trace(`Parameter found in [${parametrized}]:`, {
-            usage,
-            tokens,
-            value,
-          }); */
-          return value != null ? value : usage;
-        })
-      );
-    } catch (e) {
-      if (onError) {
-        onError(e);
-      }
-
-      throw e;
-    }
-  },
-
-  addParamToArray(key, value, arr) {
-    arr.push({ [key]: value });
-  },
-
-  findIndex(key, arr) {
-    return arr.findIndex((obj) => {
-      return Object.keys(obj)[0] === key;
-    });
-  },
-
-  getParametersRegexGroups(src: string) {
-    return {
-      functionGroupingRegexp: getParameterfunctionGroupingRegexp(
-        src
-      ),
-      operatorsGroupingRegexp: getParameterOperatorsGroupingRegexp(
-        src
-      )
-    };
-  },
-
-  suggestNewParamName(paramKey, flowConfParameters) {
-    let flowIndex;
-    do {
-      let suffix = parseInt(
-        paramKey.substr(paramKey.length - 1, paramKey.length),
-        10
-      );
-      if (Number.isInteger(suffix)) {
-        suffix += 1;
-        paramKey = paramKey.substr(0, paramKey.length - 1) + suffix;
-      } else {
-        paramKey = paramKey + '_1';
-      }
-
-      flowIndex = this.findIndex(paramKey, flowConfParameters); // new name might exist in flow conf
-    } while (flowIndex > -1);
-
-    return paramKey;
-  },
-
-  /**  Search any parameters with the following patterns:
-   *   ${param1}
-   *   ${__encode_url(param1)}
-   *   ${__if_then_else(param12,'good','bad')}
-   */
-  searchParameterizedExpressionOccurrences(
-    parameterName: string,
-    data: string
-  ): Array<string> {
-    return data.match(getParameterUsageRegexp(parameterName)) || [];
-  },
-
-  getUsedConfParams(conf: TestConfLike, parameters: Parameters[]): Parameters[] {
-    let usedParameters: Parameters[] = [];
-    if (parameters) {
-      const stringifyConf = JSON.stringify(conf);
-      parameters.forEach((p) => {
-        const paramName = this.getParameterName(p);
-        if (isParamUsedInConf(paramName, conf, stringifyConf)) {
-          const currentUsedParams = this.findUsedParameters(parameters ,p, []);
-          usedParameters = usedParameters.concat(currentUsedParams);
-        }
-      });
-    }
-    return uniqWith(usedParameters, isEqual);
-  },
-
-  getUsedRequestParams(request, parameters: Parameters[]): Parameters[] {
-    return this.getUsedConfParams({ requests: [request] }, parameters);
-  },
-
-  getValueByKeyFromArr(key: string, parameters: Parameters[], returnArray: boolean = false) {
-    let res;
-    const param = getParameterByKey(key, parameters);
-    if (param) {
-      res = this.getParameterValue(param);
-      if (Array.isArray(res)) {
-        if (returnArray && res.length > 1) {
-          return res;
-        }
-        return res[0];
-      }
-    }
-    return res;
-  },
-
-  pickFirstValue(p: Parameters): Parameters {
-    const name = parameterUtils.getParameterName(p);
-    const value = parameterUtils.getParameterValue(p);
-    if (Array.isArray(value) && value.length > 0) {
-      return { [name]: value[0] };
-    }
-    return { [name]: value };
-  },
-  getParameterValue(parameter: Parameters) {
-    const [value] = Object.values(parameter);
-    return value;
-  },
-  getParameterName(parameter: Parameters | Extractions): string {
-    const [name] = Object.keys(parameter);
-    return name;
-  },
-  getParametersNames(parameters: Parameters[]) {
-    return parameters.map((p) => {
-      const [pName] = Object.keys(p);
-      return pName;
-    });
-  },
-  setParameterValue(name: string, value: string| string[], parameters: Parameters[]) {
-    const index = this.findIndex(name, parameters);
-    parameters[index][name] = value;
-  },
-  getUsedRequestParamNames(stringifiedRequest: string): string[] {
-    const usedParams: string[] = [];
-
-    const allParametersOccurrences = searchExpressionOccurrences(
-      stringifiedRequest
-    );
-
-    allParametersOccurrences.map((paramOccurrence) => {
-      const tokensWithoutOperators = getTokensWithoutOperators(paramOccurrence);
-      for (const token of tokensWithoutOperators) {
-        if (isBuiltInFunction(token)) {
-          if (hasLeftParenthesis(token)) {
-            const [ , ...args] = stripToFunctionAndArgs(token);
-            for (const arg of args) {
-              if (!isSingleQuoted(arg)) {
-                usedParams.push(arg);
-              }
-            }
-          }
-        } else {
-          if (!isSingleQuoted(token)) {
-            usedParams.push(token);
-          }
-        }
-      }
-    });
-
-    return usedParams;
-  },
-  deleteAllSrcElementsFromParamArr(paramArr, src) {
-    let isSrcInParamArr = this.isParamKeyInArr(src, paramArr);
-    while (isSrcInParamArr) {
-      this.removeParameterFromArrayByKey(src, paramArr);
-      isSrcInParamArr = this.isParamKeyInArr(src, paramArr);
-    }
-  },
-  removeParameterFromArrayByKey(src, paramArr) {
-    const index = this.findIndex(src, paramArr);
-    paramArr.splice(index, 1);
-  },
-  isParamKeyInArr(key, arr) {
-    return this.findIndex(key, arr) >= 0;
-  },
-  /**
-   * Returns a Parameter ({name:value}) obj with the given value to search for.
-   * if non found, returns undefined
-   * @param value string | string[]
-   * @param arr Parameters[]
-   */
-  findParamValueInArr(value, arr) {
-    return arr.find(p => isEqual(this.getParameterValue(p), value));
-  },
-  findUsedParameters(
-    suiteParameters: Parameters[], param: Parameters, usedParameters: Parameters[]
-  ) {
-    try {
-      return findUsedParametersRecursively(suiteParameters, param, usedParameters).reverse();
-    }
-    catch (error) {
-      if (error instanceof RangeError) {
-        throw new ParameterError(
-          'circular dependency value' , param
-        );
-      } else {
-        throw new Error(error);
-      }
-    }
-  },
-  applyJSONSchema(instance, schema) {
-    return applyJSONSchema(instance, schema);
-  },
-  isUsingParameterizedValue(value: string) {
-    return PARAM_USAGE_REGEXP.test(value);
-  },
-};
-
-function resolvePlainParameter(parameterName: string, parameters) {
-  if (parameters.hasOwnProperty(parameterName)) {
-    return pickValue(parameters[parameterName]);
-  }
-}
-
-function resolveNoArgFunctionParameter(parameterName: string, parameters) {
-  return applyParameterFunction(
-    parameterName,
-    getParameterFunction(parameterName),
-    [],
-    parameters
-  );
-}
-
-function pickValue(parameterValue: string | string[]) {
-  return Array.isArray(parameterValue)
-    ? pickRandom(parameterValue)
-    : parameterValue;
-}
-
-function resolveTokens(tokens: string[], parameters: Parameters) {
-  const [leftSide, operator, ...rest] = tokens;
-
-  const leftSideValue = resolveArgument(leftSide, parameters);
-
-  if (!operator) {
-    return leftSideValue;
-  }
-
-  if (leftSideValue == null) {
-    throw new ParameterFunctionError(
-      operator,
-      `No value for left side operand '${leftSide}'`
-    );
-  }
-
-  const rightSideValue = resolveTokens(rest, parameters);
-
-  if (rightSideValue == null) {
-    throw new ParameterFunctionError(
-      operator,
-      `No value for right side operand '${rest[0]}'`
-    );
-  }
-
-  return applyParameterFunction(operator, resolveOperator(operator), [
-    leftSideValue,
-    rightSideValue,
-  ]);
-}
-
-function resolveArgument(arg: string, parameters: Parameters) {
-  if (arg.startsWith('\'')) {
-    return resolveLiteral(arg);
-  } else if (arg.includes('(')) {
-    return resolveParameterFunction(arg, parameters);
-  } else {
-    return parameterUtils.resolveParameter(arg, parameters);
-  }
-}
-
-function resolveLiteral(literal: string) {
-  return literal.slice(1, -1);
-}
-
-function resolveParameterFunction(
-  functionUsage: string,
-  parameters: Parameters
-) {
-  let [functionName, ...args] = functionUsage
-    .replace(/\(/, ',')
-    .slice(0, -1)
-    .split(',');
-
-  if (args.length === 1 && args[0] === '') {
-    /// No args case, e.g. ${func()}
-    args = [];
-  }
-
-  return applyParameterFunction(
-    functionName,
-    getParameterFunction(functionName),
-    args,
-    parameters
-  );
-}
-
-function applyParameterFunction(
-  functionName: string,
-  parameterFunction,
-  args,
-  parameters?
-) {
-  if (parameterFunction) {
-    const { minArgs, maxArgs, operate } = parameterFunction;
-
-    if (minArgs != null && args.length < minArgs) {
-      throw new ParameterFunctionError(
-        functionName,
-        `Must have at least ${minArgs} arguments`
-      );
-    } else if (maxArgs != null && args.length > maxArgs) {
-      throw new ParameterFunctionError(
-        functionName,
-        `Cannot have more than ${maxArgs} arguments`
-      );
-    }
-
-    if (parameters) {
-      args = args.map((arg, index) => {
-        const value = resolveArgument(arg, parameters);
-
-        if (value == null) {
-          if (canHaveNullParameterValue(functionName)) {
-            return '';
-          }
-          throw new ParameterFunctionError(
-            functionName,
-            `No value for '${arg}' at index ${index}`
-          );
-        }
-
-        return value;
-      });
-    }
-    try {
-      return operate(...args);
-    } catch (e) {
-      // log.debug('Parameter function error caught:', { functionName }, e);
-      throw new ParameterFunctionError(
-        functionName,
-        e.prettyMessage || 'Unexpected error'
-      );
-    }
-  }
-}
-
-function resolveOperator(opSymbol: string) {
-  return operators[opSymbol].parameterFunction;
-}
-
-function findUsedParametersRecursively(
-  suiteParameters: Parameters[], param: Parameters, usedParameters: Parameters[]
-) : Parameters[] {
-  const paramValueStringified = JSON.stringify(parameterUtils.getParameterValue(param));
-  const currentUsedParameterNames = parameterUtils.getUsedRequestParamNames(paramValueStringified);
-
-  if (!usedParameters.some(p => isEqual(p, param))) {
-    const smallestIndex = getSmallestIndexInParamArr(currentUsedParameterNames, usedParameters);
-    usedParameters.splice(smallestIndex, 0, param);
-  }
-  if (isEmpty(currentUsedParameterNames)) {
-    return usedParameters;
-  }
-  for (const paramName of currentUsedParameterNames) {
-    const newParam = getParameterByKey(paramName, suiteParameters);
-    if (newParam) {
-      findUsedParametersRecursively(suiteParameters, newParam, usedParameters);
-    }
-  }
-  return usedParameters;
-}
-
-const getSmallestIndexInParamArr = (paramNames: string[], parameters: Parameters[]): number => {
-  let smallestIndex = 0;
-  if (arrayUtils.isNonEmptyArray(parameters)) {
-    smallestIndex = parameters.length;
-    for (const name of paramNames) {
-      const candidateIndex = parameterUtils.findIndex(name, parameters);
-      if (candidateIndex > -1 && candidateIndex < smallestIndex) {
-        smallestIndex = candidateIndex;
-      }
-    }
-  }
-  return smallestIndex;
-};
-
-const getParameterByKey = (key: string, parameters: Parameters[]): Parameters | null => {
-  const index = parameterUtils.findIndex(key, parameters);
-  return index > -1 ? parameters[index] : null;
-};
-
-/**
- * a single quoted string starts and ends with a ' (single quote) char
- * for example str = "'arnon'"
- */
-const isSingleQuoted = (s: string): boolean => s.startsWith('\'') && s.endsWith('\'');
-
-const hasLeftParenthesis = (s: string): boolean => s.includes('(');
-
-export const stripToFunctionAndArgs = (s: string): string[] =>
-  s.replace(/\(/, ',').slice(0, -1).split(',');
-
-export const stripParam = (s: string): string => s.replace(/\$|{|}/g, '');
-
-const getTokens = (strippedExpression: string): string[] =>
-  spacesRegExpProvider.use((spacesRegExp) =>
-    strippedExpression.split(spacesRegExp)
-  );
-
-const stripOperators = (tokens: string[]): string[] =>
-  tokens.filter((t) => !operatorsAsStrings.includes(t));
-
-const getSubstringUntilChar = (s: string, c: string) => typeof s === 'string' ? s.split(c)[0] : '';
-
-const isBuiltInFunction = (s: string) => getParameterFunction(getSubstringUntilChar(s, '('));
-
-/* gets a string and returns all occurrences of ${...something/nothing..} */
-export const searchExpressionOccurrences = (s: string): string[] =>
-  s.match(new RegExp(PARAMETER_USAGE_PATTERN, 'g')) || [];
-
-export const getTokensWithoutOperators = (paramOccurrence: string): string[] => {
-  const strippedParam = stripParam(paramOccurrence);
-  const tokens = getTokens(strippedParam);
-  return stripOperators(tokens);
-};
-
-function isParamUsedInConf(paramName: string, conf: TestConfLike, stringifyConf: string): boolean {
-  return !isEmpty(parameterUtils.searchParameterizedExpressionOccurrences(paramName, stringifyConf)) ||
-    isParamNameUsedInConf(paramName, conf);
-}
-
-function isParamNameUsedInField(paramName: string, fieldValue?: string): boolean {
-  return !!fieldValue && fieldValue === paramName;
-}
-
-function isParamNameUsedInAssertions(paramName: string, assertions: Assertions = []): boolean {
-  return assertions.some(assertion => assertion.check === paramName);
-}
-
-function isParamNameUsedInRequest(paramName: string, request: RequestLike): boolean {
-  return isParamNameUsedInAssertions(paramName, request.assert) ||
-  isParamNameUsedInField(paramName, request.loop?.assert?.check) ||
-  isParamNameUsedInField(paramName, request.skipBefore?.condition) ||
-  isParamNameUsedInField(paramName, request.stopBefore);
-}
-
-function isParamNameUsedInConf(paramName: string, conf: TestConfLike): boolean {
-  if (!isEmpty(conf.requests)) {
-    return conf.requests.some(req => isParamNameUsedInRequest(paramName, req));
-  }
-  return false;
-}
-
-export function removeNonStringParameters(conf) {
-  const parameters = conf.parameters as Parameters[];
-  if (parameters) {
-    conf.parameters = parameters.filter(p =>
-      isEmpty(
-        validate.parameter(
-          parameterUtils.getParameterName(p),
-          parameterUtils.getParameterValue(p)
-        )
-      )
-    );
-  }
-}

package/src/parameters/json-path-utils.ts

@@ -1,20 +0,0 @@
-import jsonpath from 'jsonpath';
-
-type jsonPathComponent = {
-  expression: {
-    type: string,
-    value: string
-  };
-  scope: string;
-  operation: string;
-};
-
-export const getLongestJsonPathToken = (jsonPath: string) => {
-  const pathExpressionsValues = (jsonpath.parse(jsonPath) as jsonPathComponent[])
-    .map(p => p.expression.value);
-
-  const longestToken = pathExpressionsValues.reduce(longestStringReducer);
-  return longestToken;
-};
-
-const longestStringReducer = (prev: string, curr: string) => curr.length > prev.length ? curr : prev;

package/src/parameters/operators/binary-operator.ts

@@ -1,23 +0,0 @@
-import { ParameterFunction } from '../parameter-functions/parameter-function';
-
-export class BinaryOperator {
-  readonly regexSymbol;
-
-  /**
-   *
-   * @param {string[]} symbols
-   * @param {ParameterFunction} parameterFunction
-   * @param {string} regexSymbol Must NOT contain any capture groups! I.e. use non-capturing (?:) instead.
-   */
-  constructor(
-    readonly symbols: string[],
-    readonly parameterFunction: ParameterFunction,
-    regexSymbol?: string
-  ) {
-    this.regexSymbol =
-      regexSymbol ||
-      symbols
-        .map((symbol) => (symbol.length > 1 ? `(?:${symbol})` : symbol))
-        .join('|');
-  }
-}

package/src/parameters/operators/index.ts

@@ -1,39 +0,0 @@
-import { BinaryOperator } from './binary-operator';
-import { textualParameterFunctions } from '../parameter-functions/textual-parameter-functions';
-import { booleanParameterFunctions } from '../parameter-functions/boolean-parameter-functions';
-import { numericInputParameterFunctions } from '../parameter-functions/numeric-input-parameter-functions';
-import { numericParameterFunctions } from '../parameter-functions/numeric-parameter-functions';
-
-export const operators = mapOperators(
-  new BinaryOperator(['=', '==', '==='], textualParameterFunctions.__eq),
-  new BinaryOperator(['!=', '!=='], textualParameterFunctions.__neq),
-
-  new BinaryOperator(['&', '&&'], booleanParameterFunctions.__and),
-  new BinaryOperator(
-    ['|', '||'],
-    booleanParameterFunctions.__or,
-    '\\||(?:\\|\\|)'
-  ),
-
-  new BinaryOperator(['<'], numericInputParameterFunctions.__lt),
-
-  new BinaryOperator(['>'], numericInputParameterFunctions.__gt),
-
-  new BinaryOperator(['<='], numericInputParameterFunctions.__lte),
-
-  new BinaryOperator(['>='], numericInputParameterFunctions.__gte),
-
-  new BinaryOperator(['+'], numericParameterFunctions.__add, '\\+'),
-  new BinaryOperator(['-'], numericParameterFunctions.__sub),
-  new BinaryOperator(['*'], numericParameterFunctions.__mult, '\\*'),
-  new BinaryOperator(['/'], numericParameterFunctions.__div)
-);
-
-function mapOperators(...operators: BinaryOperator[]) {
-  return operators.reduce((obj, op) => {
-    op.symbols.forEach((symbol) => (obj[symbol] = op));
-    return obj;
-  }, {} as { [symbol: string]: BinaryOperator });
-}
-
-export const operatorsAsStrings = Object.keys(operators);