@loadmill/core 0.3.51 → 0.3.52

package/src/request/index.ts

@@ -1,526 +0,0 @@
-import flatMap = require('lodash/flatMap');
-import * as uriUtils from '@loadmill/universal/dist/uri-utils';
-import { Parameters, parameterUtils } from '../parameters';
-
-export const DEFAULT_REQUEST_TIMEOUT = 25000;
-export const supportedMethods = {
-  GET: 'GET',
-  POST: 'POST',
-  PUT: 'PUT',
-  DELETE: 'DELETE',
-  PATCH: 'PATCH',
-};
-export const ALLOWED_RESPONSE_STATUSES = { SUCCESS: 'SUCCESS', ERROR: 'ERROR', ANY: 'ANY' };
-
-export type HttpMethod = keyof typeof supportedMethods;
-export type HttpResponseStatus = keyof typeof ALLOWED_RESPONSE_STATUSES;
-
-/**
- * This class represents an HTTP request to be performed in the course of a load test.
- *
- * @property url The URL of the request (parameterizable).
- * @property method The HTTP method.
- * @property headers An array of headers to add to the request (values parameterizable).
- * @property postData The content of the request (text parameterizable).
- * @property delay The delay between this request and the previous one in milliseconds. This property is ignored for the first request.
- * @property timeout The time to wait for the request to finish in milliseconds.
- * @property extract A dictionary of parameter extractions.
- * @property assert An array or dictionary of assertions.
- * @property expectedStatus The expected status of the http response SUCCESS for 2XX-3XX, ERROR for 4XX-5XX.
- */
-export class LoadmillRequest implements RequestLike {
-  auth?: AuthConf;
-  stopBefore?: string;
-  skipBefore?: SkipConf;
-  loop?: LoopConf;
-
-  useCookies?: boolean;
-  description?: string;
-  delay?: number | string;
-  postData?: RequestPostData;
-  postFormData?: PostFormData;
-  file?: RequestRawFileData;
-  cachePenetration?: CachePenetration;
-
-  method: HttpMethod = 'GET';
-  headers?: LoadmillHeaders[];
-
-  assert?: Assertions;
-  extract?: Extractions[];
-  postScript?: string;
-  disabled?: boolean;
-  timeout?: number;
-  expectedStatus?: HttpResponseStatus;
-  noRedirects?: boolean;
-
-  constructor(public url: string) { }
-}
-
-export function resolveUrl(
-  url: string,
-  parameters: Parameters | Parameters[],
-  onError?
-) {
-  return uriUtils.withProtocol(
-    parameterUtils.resolveExpression(url, parameters, onError)
-  );
-}
-
-/**
- * This function should be able to take any object/json and either make a VALID LoadmillRequest out of it
- * or fail with a meaningful error message.
- */
-export function createRequest(from: RequestLike): LoadmillRequest {
-  const {
-    url,
-    delay,
-    assert,
-    method,
-    timeout,
-    extract,
-    headers,
-    postData,
-    postFormData,
-    file,
-    stopBefore,
-    skipBefore,
-    loop,
-    description,
-    expectedStatus,
-    postScript,
-    disabled,
-    noRedirects,
-  } = from;
-
-  const request = new LoadmillRequest(url);
-
-  if (method) {
-    request.method = method;
-  }
-
-  if (description) {
-    request.description = description;
-  }
-
-  if (headers) {
-    request.headers = toHeaders(headers);
-  }
-
-  if (postData) {
-    const text = postData.text;
-    const mimeType = postData.mimeType;
-    request.postData = { text, mimeType };
-  }
-
-  if (postFormData) {
-    request.postFormData = postFormData;
-  }
-
-  if (file) {
-    request.file = file;
-  }
-
-  if (delay !== null && delay !== undefined) {
-    request.delay = delay;
-  }
-
-  if (stopBefore !== undefined) {
-    request.stopBefore = stopBefore;
-  }
-
-  if (skipBefore != null) {
-    const { goTo, negate, condition } = skipBefore;
-
-    request.skipBefore = {
-      goTo,
-      condition,
-      negate: !!negate,
-    };
-  }
-
-  if (loop != null) {
-    const { iterations, assert } = loop;
-
-    const [converted] = toAssertions([assert]);
-    request.loop = {
-      assert: converted,
-      iterations
-    };
-  }
-
-  if (timeout != null) {
-    request.timeout = timeout;
-  }
-
-  if (extract) {
-    request.extract = toExtractions(extract);
-  }
-
-  if (assert) {
-    request.assert = toAssertions(assert);
-  }
-
-  if (expectedStatus) {
-    request.expectedStatus = expectedStatus;
-  }
-
-  if (postScript !== undefined) {
-    request.postScript = postScript;
-  }
-
-  if (disabled !== undefined) {
-    request.disabled = disabled;
-  }
-
-  if (noRedirects !== undefined) {
-    request.noRedirects = noRedirects;
-  }
-
-  return request;
-}
-
-export function toHeaders(headers: LoadmillHeaders | LoadmillHeaders[]) {
-  return flatMap<LoadmillHeaders | string, LoadmillHeaders>(
-    headers as any,
-    (value: LoadmillHeaders | any, key: number | string) => {
-      const res = [];
-      if (typeof key === 'string') {
-        pushHeader(value, key, res);
-      } else {
-        Object.keys(value).map((innerKey: string) => {
-          const innerValue = value[innerKey];
-          pushHeader(innerValue, innerKey!, res);
-        });
-      }
-
-      return res;
-    }
-  );
-}
-
-function toExtractions(extractions: Extractions | Extractions[]) {
-  if (!Array.isArray(extractions)) {
-    extractions = [extractions];
-  }
-
-  return extractions.map(toSingleExtractions);
-}
-
-function toSingleExtractions(extractions: Extractions): Extractions {
-  const result = {};
-
-  // Arrgh: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/12449
-  Object.keys(extractions).forEach((name: string) => {
-    const extraction = extractions[name];
-    let newExtraction: Extraction = extractions[name];
-
-    if (typeof extraction !== 'string') {
-      newExtraction = {};
-      const { header, jQuery, jsonPath, edn, regex, ws } = extraction;
-
-      if (header != null) {
-        newExtraction.header = header;
-      }
-
-      if (jQuery != null) {
-        newExtraction.jQuery =
-          typeof jQuery === 'string'
-            ? jQuery
-            : { query: jQuery.query, attr: jQuery.attr };
-      }
-
-      if (jsonPath != null) {
-        newExtraction.jsonPath = jsonPath;
-      }
-
-      if (edn != null) {
-        newExtraction.edn = edn;
-      }
-
-      if (regex != null) {
-        newExtraction.regex = regex;
-      }
-
-      if (ws != null) {
-        newExtraction.ws = ws;
-      }
-    }
-
-    result[name] = newExtraction;
-  });
-
-  return result;
-}
-
-function toAssertions(assertions: Assertions) {
-  const result: Assertions = [];
-
-  assertions.forEach((assertion: Assertion, key: number) => {
-    const {
-      check,
-      equals,
-      notEquals,
-      contains,
-      notContains,
-      matches,
-      falsy,
-      greater,
-      lesser,
-      JSONSchema
-    } = assertion;
-
-    const converted: Assertion = {
-      check,
-    };
-
-    if (equals != null) {
-      converted.equals = equals;
-    }
-
-    if (notEquals != null) {
-      converted.notEquals = notEquals;
-    }
-
-    if (contains != null) {
-      converted.contains = contains;
-    }
-
-    if (notContains != null) {
-      converted.notContains = notContains;
-    }
-
-    if (matches != null) {
-      converted.matches = matches;
-    }
-
-    if (greater != null) {
-      converted.greater = greater;
-    }
-
-    if (lesser != null) {
-      converted.lesser = lesser;
-    }
-
-    if (falsy != null && (falsy === 'true' || falsy === true)) {
-      converted.falsy = true;
-    }
-
-    if (JSONSchema != null) {
-      converted.JSONSchema = JSONSchema;
-    }
-
-    result[key] = converted;
-  });
-
-  return result;
-}
-
-export function findRequestIndex(requests: RequestLike[], desc: string) {
-  return requests.findIndex(({ description }) => description === desc);
-}
-
-export function isReservedHeader(lowerName: string) {
-  return (
-    lowerName.startsWith('proxy-') ||
-    (lowerName.startsWith('sec-') && !lowerName.startsWith('sec-websocket')) ||
-    lowerName === 'accept-charset' ||
-    lowerName === 'accept-encoding' ||
-    lowerName === 'access-control-request-headers' ||
-    lowerName === 'access-control-request-method' ||
-    lowerName === 'connection' ||
-    lowerName === 'content-length' ||
-    lowerName === 'cookie2' ||
-    lowerName === 'date' ||
-    lowerName === 'dnt' ||
-    lowerName === 'expect' ||
-    lowerName === 'keep-alive' ||
-    lowerName === 'te' ||
-    lowerName === 'trailer' ||
-    lowerName === 'transfer-encoding' ||
-    lowerName === 'upgrade'
-  );
-}
-
-function pushHeader(value, name: string, to: object[]) {
-  to.push(singleton(value, name));
-}
-
-function singleton(value: string, name: string) {
-  return { [name]: value };
-}
-
-export interface RequestLike {
-  url: string;
-
-  // currently ignored:
-  auth?: AuthConf;
-
-  stopBefore?: string;
-  skipBefore?: SkipConf;
-  loop?: LoopConf;
-
-  timeout?: number;
-  assert?: Assertions;
-  method?: HttpMethod;
-  description?: string;
-  delay?: number | string;
-  postData?: RequestPostData;
-  postFormData?: PostFormData;
-  file?: RequestRawFileData;
-  extract?: Extractions | Extractions[];
-  headers?: LoadmillHeaders | LoadmillHeaders[];
-  expectedStatus?: HttpResponseStatus;
-  parameters?;
-  postScript?: string;
-  disabled?: boolean;
-  noRedirects?: boolean;
-}
-
-export type SkipConf = {
-  condition: string;
-  negate?: boolean;
-  goTo?: string;
-};
-
-export type LoopConf = {
-  assert: Assertion;
-  iterations: number;
-};
-
-export type RequestPostData = {
-  mimeType?: string;
-  text: string;
-};
-
-export type PostFormData = PostFormDataEntry[];
-
-export type PostFormDataEntry = {
-  name: string;
-  value: string;
-  fileName?: string;
-  contentType?: string;
-};
-
-export type RequestRawFileData = {
-  name: string;
-  key: string;
-  signedUrl?: string; // created by aws
-};
-
-export enum BodyTypes {
-  POST_DATA = 'postData',
-  FORM_DATA = 'postFormData',
-  RAW_FILE = 'rawFile',
-}
-
-export type LoadmillHeaders = { [headerName: string]: string };
-
-export type Extractions = { [parameter: string]: Extraction };
-
-/**
- * This object represents a parameter extraction.
- *
- * The jQuary expression is evaluated against the response body text using Cheerio.
- * The jsonPath expression is evaluated against a superagent-like response object.
- * The edn expression is evaluated against a superagent-like response object converted to JSON and then treated like jsonPath.
- * If a regular expression is specified as well as a header, jQuery or jsonPath then the expression will be matched against the
- * query result, otherwise it is evaluated against the response body text.
- *
- * It is invalid to submit an empty extraction or one with more than one non-regex query. If the extraction yields a
- * `null` result, then the original parameter value will be retained, defaulting to an empty string.
- *
- * @property header A name of a header whose value will be extracted.
- * @property jQuery A jQuery expression to be matched against the response body text.
- * @property jsonPath A jsonPath expression to be matched against the response object.
- * @property edn A jsonPath expression (yes - jsonPath) to be matched against the EDN response object converted to JSON.
- * @property regex A JavaScript regular expression with a capture term, to be matched against the response body text.
- */
-export type Extraction = string | ExtractionObj;
-
-export type ExtractionObj = {
-  regex?: string;
-  header?: string;
-  jsonPath?: string;
-  edn?: string;
-
-  jQuery?:
-  | string
-  | {
-    query: string;
-    attr?: string;
-  };
-  ws?: string;
-};
-
-export type Assertions = Assertion[];
-
-/**
- * This object represents an assertion.
- *
- * Assertions are made once the request has been fulfilled and all parameters have been extracted.
- * All assertions are evaluated, even if some fail.
- * If an assertion contains more then one conditions then the conditions are or-ed.
- *
- * @property check A parameter name to assert the given conditions on.
- * @property equals A parametrized expression that asserts to true if its value is equal to `check`.
- * @property contains A parametrized expression that asserts to true if its value is contained in `check`.
- * @property matches A JavaScript regular expression that asserts to true if `check` matches it.
- * @property falsy if true then A parametrized expression that asserts to true if the value of `check` equales false.
- * @property greater A parametrized expression that asserts to true if its value is less to `check`.
- * @property lesser A parametrized expression that asserts to true if its value is greater to `check`.
- */
-export interface Assertion {
-  check: string;
-  equals?: string;
-  notEquals?: string;
-  contains?: string;
-  notContains?: string;
-  matches?: string;
-  falsy?: string | boolean;
-  greater?: string;
-  lesser?: string;
-  JSONSchema?: string;
-}
-
-export interface AuthConf {
-  user?: string;
-  password?: string;
-}
-
-export interface CachePenetration {
-  cacheControl?: string;
-  mode?: CachePenetrationModes;
-}
-
-export enum CachePenetrationModes {
-  none = 'none',
-  def = 'default',
-  alwaysQuery = 'always-query',
-  alwaysHeader = 'always-header',
-}
-
-// list of fields in our object we must not change
-export const EXCLUDES = [
-  'url',
-  'method',
-  'headers',
-  'timeout',
-  'postData',
-  'text',
-  'mimeType',
-  'extract',
-  'jsonPath',
-  'jQuery',
-  'regex',
-  'header',
-  'assert',
-  'check',
-  'equals',
-  'contains',
-  'matches',
-  'falsy',
-  'greater',
-  'lesser',
-];
-
-export const isWSRequest = (url: string) => url.startsWith('ws://') || url.startsWith('wss://');

package/src/schema/json-schema-generator.ts

@@ -1,76 +0,0 @@
-import find = require('lodash/find');
-import log from '@loadmill/universal/dist/log';
-import isEmpty = require('lodash/isEmpty');
-
-export const generateJSONSchema = (jsObj: any, ignoreKeys: string[] = [], shouldAddNullable: boolean = false): PrimitiveSchema | Schema => {
-  try {
-    const schema = _getSchema(jsObj, ignoreKeys, shouldAddNullable);
-    return schema;
-  } catch (err) {
-    _handleError('Error generating JSON Schema', err, jsObj);
-  }
-
-  return {};
-};
-
-const _getSchema = (obj, ignoreKeys: string[] = [], shouldAddNullable: boolean = false) => {
-  if (obj == null) {
-    return shouldAddNullable ? { type: 'object', nullable: true } :{};
-  }
-  else if (_isPrimitive(obj)) {
-    return {
-      'type': typeof obj
-    };
-  }
-  else if (Array.isArray(obj)) {
-    const items: any[] = [];
-    for (const [, value] of Object.entries(obj)) {
-      const elementSchema = _getSchema(value, ignoreKeys);
-      if (!find(items, elementSchema)) {
-        items.push(elementSchema);
-      }
-    }
-    // The use of 'oneOf' creates a schema that validates the existence of the items but not their order in the array
-    return {
-      'type': 'array',
-      'items': isEmpty(items) ? {} : { 'anyOf': items }
-    };
-  }
-  else {
-    const properties = {};
-    for (const [key, value] of Object.entries(obj)) {
-      if (!ignoreKeys.includes(key)) {
-        properties[key] = _getSchema(value, ignoreKeys);
-      }
-    }
-    return {
-      'type': 'object',
-      properties
-    };
-  }
-};
-
-const _isPrimitive = (obj) => Object(obj) !== obj;
-
-const _handleError = (err, msg, json) => {
-  log.error(msg, err, json);
-  throw new Error(msg);
-};
-
-export type Schema = BaseSchema & {
-  properties?: {
-      [name: string]: Schema | PrimitiveSchema
-  }
-  items?: Schema[] | PrimitiveSchema[]
-}
-
-export type PrimitiveSchema = BaseSchema & {
-  const?: Primitive
-}
-
-type BaseSchema = {
-  type?: string
-}
-
-type Primitive = string | number | boolean;
-