@loadmill/executer 0.1.52 → 0.1.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadmill/executer",
-  "version": "0.1.52",
+  "version": "0.1.53",
   "description": "Loadmill executer library",
   "scripts": {
     "ts-watch": "rimraf dist && tsc -w -p tsconfig.json",
@@ -14,8 +14,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@loadmill/core": "0.3.51",
-    "@loadmill/universal": "0.3.46",
+    "@loadmill/core": "0.3.52",
+    "@loadmill/universal": "0.3.47",
     "@types/estree": "^0.0.50",
     "acorn": "^8.4.1",
     "agentkeepalive": "^4.1.3",

package/src/asserter.ts

@@ -1,137 +0,0 @@
-import { Parameters } from '@loadmill/core/dist/parameters';
-import { Assertion } from '@loadmill/core/dist/request';
-import { parameterUtils, valueUtils } from '@loadmill/core/dist/parameters';
-import log from '@loadmill/universal/dist/log';
-
-export class Asserter {
-  constructor(private parameters: Parameters) {}
-
-  assert({
-    check,
-    equals,
-    notEquals,
-    contains,
-    notContains,
-    matches,
-    falsy,
-    greater,
-    lesser,
-    JSONSchema
-  }: Assertion): boolean {
-    const actual =
-      parameterUtils.resolveParameter(check, this.parameters) || '';
-
-    if (
-      contains == null &&
-      notContains == null &&
-      equals == null &&
-      notEquals == null &&
-      matches == null &&
-      greater == null &&
-      lesser == null &&
-      JSONSchema == null
-    ) {
-      // only if no other assertions exist, the target expression is to check
-      // for "truthfulness" or "falslyness"(in case falsy flag is on).
-
-      // Note that failed/null extractions evaluate to an empty string while
-      // other nonexistent parameters are left untouched in the resolved expression
-
-      let result;
-      if (falsy) {
-        result = valueUtils.isFalsyParameterValue(actual);
-        log.debug('Assert False:', { actual, result });
-      } else {
-        result = valueUtils.isTruthyParameterValue(actual);
-        log.debug('Assert True:', { actual, result });
-      }
-
-      return result;
-    }
-
-    // short circuiting with approximate increasing complexity:
-    return (
-      this.check(actual, checkContains, contains) ||
-      this.check(actual, checkNotContains, notContains) ||
-      this.check(actual, checkEquals, equals) ||
-      this.check(actual, checkNotEquals, notEquals) ||
-      this.check(actual, checkMatches, matches) ||
-      this.check(actual, checkGreater, greater) ||
-      this.check(actual, checkLesser, lesser) ||
-      this.check(actual, checkJSONSchema, JSONSchema)
-    );
-  }
-
-  private resolve(parametrized: string) {
-    return parameterUtils.resolveExpression(parametrized, this.parameters);
-  }
-
-  private check(actual: string, checker: Checker, expected?: string) {
-    if (expected != null) {
-      const resolved = this.resolve(expected);
-      return checker(actual, resolved);
-    }
-    return false;
-  }
-}
-
-type Checker = (actual: string, expected: string) => boolean;
-
-function checkMatches(actual: string, expected: string) {
-  const regExp = new RegExp(expected);
-  const result = regExp.test(actual);
-  log.debug('Assert regex:', { actual, expected, regExp, result });
-  return result;
-}
-
-function checkEquals(actual: string, expected: string) {
-  let result;
-  if (expected === 'null' && actual === '' ) {
-    result = true;
-  }
-  else {
-    result = actual == expected;
-  }
-  log.debug('Assert equals:', { actual, expected, result });
-  return result;
-}
-
-function checkNotEquals(actual: string, expected: string) {
-  const result = actual !== expected;
-  log.debug('Assert not equal:', { actual, expected, result });
-  return result;
-}
-
-function checkContains(actual: string, expected: string) {
-  const result = actual.includes(expected);
-  log.debug('Assert contains:', { actual, expected, result });
-  return result;
-}
-
-function checkNotContains(actual: string, expected: string) {
-  const result = !actual.includes(expected);
-  log.debug('Assert not contains:', { actual, expected, result });
-  return result;
-}
-
-function checkGreater(actual: string, expected: string) {
-  const numericActual = parseFloat(actual);
-  const numericExpected = parseFloat(expected);
-  const result = numericActual > numericExpected;
-  log.debug('Assert greater:', { actual, expected, result });
-  return result;
-}
-
-function checkLesser(actual: string, expected: string) {
-  const numericActual = parseFloat(actual);
-  const numericExpected = parseFloat(expected);
-  const result = numericActual < numericExpected;
-  log.debug('Assert lesser:', { actual, expected, result });
-  return result;
-}
-
-function checkJSONSchema(actual: string, expected: string) {
-  const result = parameterUtils.applyJSONSchema(actual, expected);
-  log.debug('Assert JSONSchema:', { actual, expected, result });
-  return result;
-}

package/src/errors.ts

@@ -1,10 +0,0 @@
-import { Histogram } from './failures';
-
-export class RequestFailuresError extends Error {
-  constructor(message: string, public histogram: Histogram = { [message]: 1 }) {
-    super(message);
-
-    // 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, RequestFailuresError.prototype);
-  }
-}

package/src/extraction-combiner.ts

@@ -1,110 +0,0 @@
-import {
-  RegexExtractor,
-  Extractor,
-  HeaderExtractor,
-  CheerioExtractor,
-  JsonPathExtractor,
-  ExpressionExtractor,
-  ParametrizedExtractor,
-  WsExtractor,
-} from '@loadmill/core/dist/parameters/extractors';
-import { Parameters } from '@loadmill/core/dist/parameters';
-import { Extraction } from '@loadmill/core/dist/request';
-import log from '@loadmill/universal/dist/log';
-import ednParser from 'jsedn';
-import { WSExtractionData } from '@loadmill/core/dist/parameters/extractors/ws-extractor';
-
-export class ExtractionCombiner {
-  headerExtractor: HeaderExtractor;
-  cheerioExtractor: CheerioExtractor;
-  jsonPathExtractor: JsonPathExtractor;
-  ednPathExtractor: JsonPathExtractor;
-  expressionExtractor: ExpressionExtractor;
-
-  constructor(private contextParameters: Parameters, private res: any, private wsExtractionData: WSExtractionData) {
-    this.headerExtractor = new HeaderExtractor(res, this.contextParameters);
-    this.expressionExtractor = new ExpressionExtractor(this.contextParameters);
-  }
-
-  async combine(extraction: Extraction) {
-    let query: string | string[], extractor!: ParametrizedExtractor;
-
-    if (typeof extraction === 'string') {
-      query = extraction;
-      extractor = this.expressionExtractor;
-    } else {
-      const { header, jQuery, jsonPath, edn, regex, ws } = extraction;
-
-      if (header != null) {
-        query = header;
-        extractor = this.headerExtractor;
-      } else if (jQuery != null) {
-        if (!this.cheerioExtractor) {
-          this.cheerioExtractor = new CheerioExtractor(
-            this.res.text,
-            this.contextParameters
-          );
-        }
-
-        query =
-          typeof jQuery === 'string'
-            ? jQuery
-            : [jQuery.query, '0', jQuery.attr || ''];
-
-        extractor = this.cheerioExtractor;
-      } else if (jsonPath != null) {
-        if (!this.jsonPathExtractor) {
-          this.jsonPathExtractor = new JsonPathExtractor(
-            this.res.text,
-            this.contextParameters
-          );
-        }
-
-        query = jsonPath;
-        extractor = this.jsonPathExtractor;
-      } else if (edn != null) {
-        if (!this.ednPathExtractor) {
-          let converted: string = '';
-          try {
-            converted = JSON.stringify(
-              ednParser.toJS(ednParser.parse(this.res.text))
-            );
-          } catch (e) {
-            log.error(e); // just log. The error will shown later because we send '' to JsonPathExtractor
-          }
-          this.ednPathExtractor = new JsonPathExtractor(
-            converted,
-            this.contextParameters
-          );
-        }
-
-        query = edn;
-        extractor = this.ednPathExtractor;
-      }
-
-      if (regex != null) {
-        extractor = new RegexExtractor(
-          extractor ? wrap(extractor, query!) : () => this.res.text,
-          this.contextParameters
-        );
-
-        query = regex;
-      }
-
-      if (ws != null) {
-        extractor = new WsExtractor(
-          this.wsExtractionData,
-          this.contextParameters
-        );
-
-        query = ws;
-      }
-    }
-
-    return () => extractor.extract(query);
-  }
-}
-
-function wrap(extractor: Extractor, query) {
-  return () => extractor.extract(query);
-}

package/src/failures.ts

@@ -1,79 +0,0 @@
-export function OneFailure(histogram: Histogram): RequestFailures {
-  return {
-    histogram,
-    numFailures: 1,
-  };
-}
-
-export function mergeFailures(to: Failures, from: Failures) {
-  Object.keys(from).forEach(index => {
-    const fromReqFailures = from[index];
-    const toReqFailures = to[index!];
-
-    if (toReqFailures == null) {
-      to[index!] = {
-        numFailures: fromReqFailures.numFailures,
-        histogram: { ...fromReqFailures.histogram },
-      };
-    } else {
-      mergeRequestFailures(toReqFailures, fromReqFailures);
-    }
-  });
-}
-
-export function mergeRequestFailures(
-  to: RequestFailures,
-  from: RequestFailures
-) {
-  to.numFailures += from.numFailures;
-  mergeHistograms(to.histogram, from.histogram);
-}
-
-export function mergeHistograms(to: Histogram, from: Histogram) {
-  Object.keys(from).forEach(reason => {
-    const fromCount = from[reason];
-    const toCount = to[reason];
-
-    if (toCount != null) {
-      to[reason] = toCount + fromCount;
-    } else {
-      to[reason] = fromCount;
-    }
-  });
-}
-
-export function getFailureKeys(failures?: Failures) {
-  const safeFailures = failures || {};
-
-  return Object.keys(safeFailures).map(reqIndex =>
-    Object.keys(safeFailures[reqIndex].histogram).map(reason =>
-      getFailureKey(reqIndex, reason)
-    )
-  ).reduce((a, b) => a.concat(b), []);
-}
-
-export function getFailureKey(reqIndex: string | number, reason: string) {
-  return `${reqIndex},${reason}`;
-}
-
-export interface Failures {
-  [index: number]: RequestFailures;
-}
-
-export interface RequestFailures {
-  /**
-   * Counts the number of times the request has failed.
-   */
-  numFailures: number;
-
-  /**
-   * Maps each failure reason (an error message or assertion name) to the
-   * [positive] number of times the request has failed because of it.
-   *
-   * Note that these may sum up to more than `numFailures`!
-   * This happens when multiple assertions fail for the same request.
-   */
-  histogram: Histogram;
-}
-
-export type Histogram = { [reason: string]: number };

package/src/message-creators.ts

@@ -1,44 +0,0 @@
-import { Work } from './work';
-import { FromMillStatsReport } from './report-types';
-import { RequestSequenceResult } from './request-sequence-result';
-
-export const messageCreators = {
-  work(work) {
-    return JSON.stringify(new WorkLordMessage(work));
-  },
-
-  askRes(failureKeys) {
-    return JSON.stringify(new AskResLordMessage(failureKeys));
-  },
-
-  report(report) {
-    return JSON.stringify(new ReportMillMessage(report));
-  },
-
-  fullRes(results) {
-    return JSON.stringify(new FullResMillMessage(results));
-  },
-};
-
-export class WorkLordMessage {
-  readonly type = 'work';
-  constructor(public work: Work) {}
-}
-
-export class AskResLordMessage {
-  readonly type = 'askRes';
-  constructor(public failureKeys: string[]) {}
-}
-
-export class ReportMillMessage {
-  readonly type = 'report';
-  constructor(public report: FromMillStatsReport) {}
-}
-
-export class FullResMillMessage {
-  readonly type = 'fullRes';
-  constructor(public results: RequestSequenceResult[]) {}
-}
-
-export type LordMessage = WorkLordMessage | AskResLordMessage;
-export type MillMessage = ReportMillMessage | FullResMillMessage;

package/src/mill-info.ts

@@ -1,81 +0,0 @@
-export interface MillInfo {
-  /**
-   * The mill socket IP address (or addresses in case IP is forwarded).
-   */
-  IPs: string[];
-
-  /**
-   * True if and only if this mill is a spy.
-   */
-  spy: boolean;
-
-  /**
-   * True if and only if this mill is a simulator.
-   */
-  sim: boolean;
-
-  /**
-   * True if and only if this mill restricted to using SSL.
-   */
-  onlySsl: boolean;
-
-  /**
-   * True if and only if this mill has cookie support.
-   */
-  cookieAble: boolean;
-
-  /**
-   * True if and only if this mill runs through a proxy.
-   */
-  proxyAble: boolean;
-
-  /**
-   * Number of loads capable of running (Angie)
-   */
-  loadsCapacity: number;
-
-  /**
-   * The location resolved from the first mill IP or an empty string.
-   */
-  location: string;
-
-  /**
-   * The country code provided by Cloudflare or empty string.
-   */
-  countryCode: string;
-
-  /**
-   * The mill user-agent string or an empty string.
-   */
-  userAgent: string;
-
-  /**
-   * The mill browser and version (parsed from user-agent string).
-   */
-  browserVersion: string;
-
-  /**
-   * The full affiliate id.
-   */
-  affiliateId: string;
-
-  /**
-   * The owner of the agent.
-   */
-  userId?: string;
-
-  /**
-   * The agent's owner's team.
-   */
-  teamId?: string;
-
-  /**
-   * Agent pool(if the user supplied)
-   */
-  pool?: string;
-
-  /**
-   * If the agent can't handle API tests
-   */
-  noApi: boolean;
-}

package/src/mill-version.ts

@@ -1,7 +0,0 @@
-export const millVersion = {
-  major: 9,
-  minor: 56,
-  patch: 0,
-};
-
-export const millVersionString = `${millVersion.major}.${millVersion.minor}.${millVersion.patch}`;

package/src/post-script/ast-walker/index.ts

@@ -1,160 +0,0 @@
-import {
-  AssignmentExpression,
-  AssignmentProperty,
-  ExpressionStatement,
-  Identifier,
-  ObjectPattern,
-  Pattern,
-  RestElement,
-  SequenceExpression,
-  VariableDeclaration,
-} from 'estree';
-import { ESTree } from '../parser/js-parser';
-import { AcornJSParser } from '../parser/acorn-js-parser';
-import { ArrayPattern, FunctionDeclaration } from './types';
-import {
-  isArray,
-  isAssignmentExpression,
-  isExpressionStatement,
-  isFunctionDeclaration,
-  isIdentifier,
-  isObject,
-  isRestElement,
-  isSequenceExpression,
-  isVariableDeclaration,
-} from './type-guard';
-
-export class ASTWalker {
-  private ast: ESTree;
-  private untouchables: string[];
-  private detected: Set<string>;
-
-  constructor(script: string) {
-    this.ast = new AcornJSParser().parse(script);
-    this.untouchables = [];
-    this.detected = new Set();
-  }
-
-  public detectDeclarations = (untouchables: string[]): string[] => {
-    this.untouchables = untouchables;
-
-    for (const node of this.ast.body) {
-      if (isFunctionDeclaration(node)) {
-        this.addDeclaredFunction(node as FunctionDeclaration);
-      }
-      else if (isVariableDeclaration(node)) {
-        this.addDeclaredVariables(node as VariableDeclaration);
-      }
-      else if (isExpressionStatement(node)) {
-        this.addImplicitDeclarations(node as ExpressionStatement);
-      }
-    }
-    return Array.from(this.detected);
-  };
-
-  private addDeclaredFunction = (node: FunctionDeclaration) => {
-    this.addIdentifier(node.id);
-  };
-
-  private getIdentifierName = (id: Identifier) => id.name;
-
-  private addNestedDeclaredProps = ({ properties }: ObjectPattern) => {
-    for (const prop of properties) {
-      if (isRestElement(prop)) {
-        this.addRestElement(prop as RestElement);
-      }
-      else {
-        this.addAssignmentProperty(prop as AssignmentProperty);
-      }
-    }
-  };
-
-  private addAssignmentProperty = ({ value }: AssignmentProperty) => {
-    if (isIdentifier(value)) {
-      this.addIdentifier(value as Identifier);
-    }
-    else if (isObject(value)) {
-      this.addNestedDeclaredProps(value as ObjectPattern);
-    }
-    else if (isArray(value)) {
-      this.addDestructuredArrayElements(value as ArrayPattern);
-    }
-  };
-
-  private addRestElement = ({ argument }: RestElement) => {
-    if (isIdentifier(argument)) {
-      this.addIdentifier(argument as Identifier);
-    }
-    else if (isObject(argument)) {
-      this.addNestedDeclaredProps(argument as ObjectPattern);
-    }
-  };
-
-  private addDestructuredArrayElements = ({ elements }: ArrayPattern) => {
-    for (const element of elements) {
-      if (isIdentifier(element)) {
-        this.addIdentifier(element as Identifier);
-      }
-      else if (isRestElement(element)) {
-        this.addRestElement(element as RestElement);
-      }
-      else if (isObject(element)) {
-        this.addNestedDeclaredProps(element as ObjectPattern);
-      }
-      else if (isArray(element)) {
-        this.addDestructuredArrayElements(element as ArrayPattern);
-      }
-    }
-  };
-
-  private addDeclaredVariables = (node: VariableDeclaration) => {
-    for (const declaration of node.declarations) {
-      const pattern: Pattern = declaration.id;
-      if (isIdentifier(pattern)) {
-        this.addIdentifier(pattern as Identifier);
-      }
-      else if (isObject(pattern)) {
-        this.addNestedDeclaredProps(pattern as ObjectPattern);
-      }
-      else if (isArray(pattern)) {
-        this.addDestructuredArrayElements(pattern as ArrayPattern);
-      }
-    }
-  };
-
-  private addImplicitDeclarations = ({ expression }: ExpressionStatement) => {
-    if (isAssignmentExpression(expression)) {
-      this.addSingleImplicitVar(expression as AssignmentExpression);
-    }
-    else if (isSequenceExpression(expression)) {
-      this.addMultipleImplicitVar(expression as SequenceExpression);
-    }
-  };
-
-  private addSingleImplicitVar = (expression: AssignmentExpression) => {
-    if (isIdentifier(expression.left)) {
-      const assignedName = this.getIdentifierName(expression.left as Identifier);
-      if (!this.untouchables.includes(assignedName)) {
-        this.addIdentifier(expression.left as Identifier);
-      }
-    }
-    else if (isObject(expression.left)) {
-      this.addNestedDeclaredProps(expression.left as ObjectPattern);
-    }
-    else if (isArray(expression.left)) {
-      this.addDestructuredArrayElements(expression.left as ArrayPattern);
-    }
-  };
-
-  private addMultipleImplicitVar = ({ expressions }: SequenceExpression) => {
-    for (const expression of expressions) {
-      if (isAssignmentExpression(expression)) {
-        this.addSingleImplicitVar(expression as AssignmentExpression);
-      }
-    }
-  };
-
-  private addIdentifier(id: Identifier) {
-    this.detected.add(this.getIdentifierName(id));
-  }
-}