@loadmill/core 0.3.33 → 0.3.37

package/src/parameters/extractors/ws-extractor.ts

@@ -0,0 +1,89 @@
+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;
+  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);
+    const regexp = new RegExp(resolvedRegex || CAPTURE_ALL_REGEX);
+    const wsMessage = await this.queryMessage(regexp);
+    log.debug('WS message queried and found:', wsMessage);
+
+    return matchRegex(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(
+    regexp: RegExp,
+  ): Promise<string> {
+    const res = await this.getWSMessageOrTimeout(regexp);
+    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(
+    regexp: RegExp,
+  ): Promise<string | undefined> {
+    const startTime = Date.now();
+    let message = '';
+    let elapsedTime = 0;
+
+    while (!message && elapsedTime < this._timeLimit) {
+      message = this.findMessageByRegex(regexp) || '';
+      if (message) {
+        break;
+      }
+
+      await delay(this.GIVE_WS_MSG_TIME_MS);
+      elapsedTime = Date.now() - startTime;
+    }
+    return message;
+  }
+
+  private findMessageByRegex(regexp: RegExp): string | undefined {
+    if (isCaptureAllRegExp(regexp)) {
+      return this.getLastMessage();
+    }
+    return this._messages.find(msg => regexp.test(msg));
+  }
+
+  private getLastMessage(): string {
+    return this._messages[this._messages.length - 1];
+  }
+}
+
+export type WSExtractionData = {
+  messages: string[];
+  timeLimit: number;
+}

package/src/parameters/index.ts

@@ -20,11 +20,14 @@ import {
   usageRegExpProvider,
   PARAMETER_USAGE_PATTERN,
   LEGAL_PARAM_CHARS,
-  CAPTURE_REGEX
+  CAPTURE_REGEX,
+  PARAM_USAGE_REGEXP,
 } 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, RequestLike } from '../request';
+import { TestConfLike } from '../conf';
 
 function isStackEmpty(s) {
   return s.length === 0;
@@ -190,6 +193,7 @@ export const parameterUtils = {
       throw e;
     }
   },
+
   addParamToArray(key, value, arr) {
     arr.push({ [key]: value });
   },
@@ -236,7 +240,7 @@ export const parameterUtils = {
    *   ${__encode_url(param1)}
    *   ${__if_then_else(param12,'good','bad')}
    */
-  searchParameterOccurrences(
+  searchParameterizedExpressionOccurrences(
     parameterName: string,
     data: string
   ): Array<string> {
@@ -258,13 +262,13 @@ export const parameterUtils = {
     return extractionParamNames;
   },
 
-  getUsedConfParams(conf, parameters: Parameters[]): Parameters[] {
+  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 (!isEmpty(this.searchParameterOccurrences(paramName, stringifyConf))) {
+        if (isParamUsedInConf(paramName, conf, stringifyConf)) {
           const currentUsedParams = this.findUsedParameters(parameters ,p, []);
           usedParameters = usedParameters.concat(currentUsedParams);
         }
@@ -272,6 +276,11 @@ export const parameterUtils = {
     }
     return uniqWith(usedParameters, isEqual);
   },
+
+  getUsedRequestParams(request, parameters: Parameters[]): Parameters[] {
+    return this.getUsedConfParams({ requests: [request] }, parameters);
+  },
+
   getValueByKeyFromArr(key: string, parameters: Parameters[]) {
     let res;
     const param = getParameterByKey(key, parameters);
@@ -283,6 +292,15 @@ export const parameterUtils = {
     }
     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;
@@ -322,7 +340,7 @@ export const parameterUtils = {
               }
             }
           } else {
-            if(!isSingleQuoted(token)) {
+            if (!isSingleQuoted(token)) {
               usedParams.push(token);
             }
           }
@@ -333,7 +351,7 @@ export const parameterUtils = {
   },
   deleteAllSrcElementsFromParamArr(paramArr, src) {
     let isSrcInParamArr = this.isParamKeyInArr(src, paramArr);
-    while(isSrcInParamArr) {
+    while (isSrcInParamArr) {
       this.removeParameterFromArrayByKey(src, paramArr);
       isSrcInParamArr = this.isParamKeyInArr(src, paramArr);
     }
@@ -372,7 +390,10 @@ export const parameterUtils = {
   },
   applyJSONSchema(instance, schema) {
     return applyJSONSchema(instance, schema);
-  }
+  },
+  isUsingParameterizedValue(value: string) {
+    return PARAM_USAGE_REGEXP.test(value);
+  },
 };
 
 function resolvePlainParameter(parameterName: string, parameters) {
@@ -519,7 +540,7 @@ function resolveOperator(opSymbol: string) {
 
 function findUsedParametersRecursively(
   suiteParameters: Parameters[], param: Parameters, usedParameters: Parameters[]
-) : Parameters[]{
+) : Parameters[] {
   const paramValueStringified = JSON.stringify(parameterUtils.getParameterValue(param));
   const currentUsedParameterNames = parameterUtils.getUsedRequestParamNames(paramValueStringified);
 
@@ -592,3 +613,30 @@ export const getTokensWithoutOperators = (paramOccurrence: string): string[] =>
   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;
+}

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

@@ -77,7 +77,7 @@ export const textualParameterFunctions = {
     },
     2
   ),
-  
+
   __array_in_range: new BasicParameterFunction(
     (arrayAsStr, start, end) => {
       const arr: Array<string> = toArray(arrayAsStr);

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

@@ -61,3 +61,11 @@ export const getParameterOperatorsGroupingRegexp = (parameterName) =>
   );
 
 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);
+}

package/src/request/index.ts

@@ -2,7 +2,7 @@ import flatMap = require('lodash/flatMap');
 import * as uriUtils from '@loadmill/universal/dist/uri-utils';
 import { Parameters, parameterUtils } from '../parameters';
 
-export const DEFAULT_REQUEST_TIMEOUT = 60000;
+export const DEFAULT_REQUEST_TIMEOUT = 25000;
 export const supportedMethods = {
   GET: 'GET',
   POST: 'POST',
@@ -45,9 +45,10 @@ export class LoadmillRequest implements RequestLike {
 
   assert?: Assertions;
   extract?: Extractions[];
-  postScript?: string = '';
-  timeout: number = DEFAULT_REQUEST_TIMEOUT;
-  expectedStatus: HttpResponseStatus = 'SUCCESS';
+  postScript?: string;
+  disabled?: boolean;
+  timeout?: number;
+  expectedStatus?: HttpResponseStatus;
 
   constructor(public url: string) { }
 }
@@ -82,6 +83,7 @@ export function createRequest(from: RequestLike): LoadmillRequest {
     description,
     expectedStatus,
     postScript,
+    disabled,
   } = from;
 
   const request = new LoadmillRequest(url);
@@ -104,11 +106,11 @@ export function createRequest(from: RequestLike): LoadmillRequest {
     request.postData = { text, mimeType };
   }
 
-  if (delay != null && delay !== '') {
+  if (delay !== null && delay !== undefined) {
     request.delay = delay;
   }
 
-  if (stopBefore) {
+  if (stopBefore !== undefined) {
     request.stopBefore = stopBefore;
   }
 
@@ -148,9 +150,12 @@ export function createRequest(from: RequestLike): LoadmillRequest {
     request.expectedStatus = expectedStatus;
   }
 
-  if (postScript) {
+  if (postScript !== undefined) {
     request.postScript = postScript;
   }
+  if (disabled !== undefined) {
+    request.disabled = disabled;
+  }
 
   return request;
 }
@@ -192,7 +197,7 @@ function toSingleExtractions(extractions: Extractions): Extractions {
 
     if (typeof extraction !== 'string') {
       newExtraction = {};
-      const { header, jQuery, jsonPath, edn, regex } = extraction;
+      const { header, jQuery, jsonPath, edn, regex, ws } = extraction;
 
       if (header != null) {
         newExtraction.header = header;
@@ -216,6 +221,10 @@ function toSingleExtractions(extractions: Extractions): Extractions {
       if (regex != null) {
         newExtraction.regex = regex;
       }
+
+      if (ws != null) {
+        newExtraction.ws = ws;
+      }
     }
 
     result[name] = newExtraction;
@@ -339,9 +348,10 @@ export interface RequestLike {
   postData?: RequestPostData;
   extract?: Extractions | Extractions[];
   headers?: LoadmillHeaders | LoadmillHeaders[];
-  expectedStatus: HttpResponseStatus;
+  expectedStatus?: HttpResponseStatus;
   parameters?;
   postScript?: string;
+  disabled?: boolean;
 }
 
 export type SkipConf = {
@@ -396,6 +406,7 @@ export type ExtractionObj = {
     query: string;
     attr?: string;
   };
+  ws?: string;
 };
 
 export type Assertions = Assertion[];

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

@@ -1,8 +1,10 @@
+import find = require('lodash/find');
 import log from '@loadmill/universal/dist/log';
+import isEmpty = require('lodash/isEmpty');
 
-export const generateJSONSchema = (jsObj: any, ignoreKeys: string[] = []): PrimitiveSchema | Schema => {
+export const generateJSONSchema = (jsObj: any, ignoreKeys: string[] = [], shouldAddNullable: boolean = false): PrimitiveSchema | Schema => {
   try {
-    const schema = _getSchema(jsObj, ignoreKeys);
+    const schema = _getSchema(jsObj, ignoreKeys, shouldAddNullable);
     return schema;
   } catch (err) {
     _handleError('Error generating JSON Schema', err, jsObj);
@@ -11,27 +13,27 @@ export const generateJSONSchema = (jsObj: any, ignoreKeys: string[] = []): Primi
   return {};
 };
 
-const _getSchema = (obj, ignoreKeys: string[] = []) => {
+const _getSchema = (obj, ignoreKeys: string[] = [], shouldAddNullable: boolean = false) => {
   if (obj == null) {
-    return {};
+    return shouldAddNullable ? { type: 'object', nullable: true } :{};
   }
   else if (_isPrimitive(obj)) {
     return {
-      'type': typeof obj,
-      'const': obj
+      'type': typeof obj
     };
   }
   else if (Array.isArray(obj)) {
     const items: any[] = [];
-    for (const [,value] of Object.entries(obj)) {
-      items.push(_getSchema(value, ignoreKeys));
+    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 { 
+    return {
       'type': 'array',
-      'items': {
-        'anyOf': items
-      }
+      'items': isEmpty(items) ? {} : { 'anyOf': items }
     };
   }
   else {

package/test/parameters/value-utils.spec.js

@@ -36,7 +36,7 @@ suite('test valueUtils module', () => {
         expect(valueUtils.isTruthyParameterValue('undefined')).equals(false);
       });
       it('"NaN" => false', () => {
-        expect(valueUtils.isTruthyParameterValue('NaN')).equals(false); 
+        expect(valueUtils.isTruthyParameterValue('NaN')).equals(false);
       });
       it('"" => false', () => {
         expect(valueUtils.isTruthyParameterValue('')).equals(false);
@@ -66,7 +66,7 @@ suite('test valueUtils module', () => {
         expect(valueUtils.isTruthyParameterValue([])).equals(true);
       });
       it('Infinity => true', () => {
-        expect(valueUtils.isTruthyParameterValue(Infinity)).equals(true); 
+        expect(valueUtils.isTruthyParameterValue(Infinity)).equals(true);
       });
     });
   });

package/test/schema/json-schema-generator.spec.js

@@ -1,4 +1,4 @@
-const { suite } = require('mocha');
+const { suite, describe, it } = require('mocha');
 const { expect } = require('chai');
 const { Validator } = require('jsonschema');
 
@@ -10,7 +10,7 @@ suite('JSON Schema generator', () => {
   describe('Primitive cases', () => {
     it('Just 1 string', () => {
       const string = 'arnon';
-      const expected = { type: 'string', const: 'arnon' };
+      const expected = { type: 'string' };
       const res = generateJSONSchema(string);
       expect(res).eql(expected);
 
@@ -19,7 +19,7 @@ suite('JSON Schema generator', () => {
     });
     it('Just 1 number', () => {
       const number = 123;
-      const expected = { 'type': 'number', 'const': 123 };
+      const expected = { 'type': 'number' };
       const res = generateJSONSchema(number);
       expect(res).eql(expected);
 
@@ -28,7 +28,7 @@ suite('JSON Schema generator', () => {
     });
     it('Just 1 boolean', () => {
       const boolie = false;
-      const expected = { 'type': 'boolean', 'const': false };
+      const expected = { 'type': 'boolean' };
       const res = generateJSONSchema(boolie);
       expect(res).eql(expected);
 
@@ -37,6 +37,18 @@ suite('JSON Schema generator', () => {
     });
   });
   describe('Complex cases', () => {
+    it('Empty Array', () => {
+      const array = [];
+      const expected = {
+        'type': 'array',
+        'items': {}
+      };
+      const res = generateJSONSchema(array);
+      expect(res).eql(expected);
+
+      const schemaRes = v.validate(array, res);
+      expect(schemaRes.errors).eql([]);
+    });
     it('Array of strings', () => {
       const array = ['Arnon','Yochai'];
       const expected = {
@@ -45,12 +57,7 @@ suite('JSON Schema generator', () => {
           'anyOf':
             [
               {
-                'type': 'string',
-                'const': 'Arnon'
-              },
-              {
-                'type': 'string',
-                'const': 'Yochai'
+                'type': 'string'
               }
             ]
         }
@@ -60,6 +67,8 @@ suite('JSON Schema generator', () => {
 
       const schemaRes = v.validate(array, res);
       expect(schemaRes.errors).eql([]);
+      const schemaResRev = v.validate(array.reverse(), res);
+      expect(schemaResRev.errors).eql([]);
     });
     it('Object of primitives', () => {
       const obj = { 'name':'arnon', 'age':48, 'isAntar':true };
@@ -67,16 +76,13 @@ suite('JSON Schema generator', () => {
         'type': 'object',
         'properties': {
           'name': {
-            'type': 'string',
-            'const': 'arnon'
+            'type': 'string'
           },
           'age': {
-            'type': 'number',
-            'const': 48
+            'type': 'number'
           },
           'isAntar': {
-            'type': 'boolean',
-            'const': true
+            'type': 'boolean'
           }
         }
       };
@@ -86,7 +92,7 @@ suite('JSON Schema generator', () => {
       const schemaRes = v.validate(obj, res);
       expect(schemaRes.errors).eql([]);
     });
-    it('Array of objects', () => {
+    it('Array of similar objects', () => {
       const array = [{ 'street': 'Arnon', 'building': 42 }, { 'street': 'Yochai', 'building': 77 }];
       const expected = {
         'type': 'array',
@@ -96,25 +102,52 @@ suite('JSON Schema generator', () => {
               'type': 'object',
               'properties': {
                 'street': {
-                  'type': 'string',
-                  'const': 'Arnon'
+                  'type': 'string'
                 },
                 'building': {
-                  'type': 'number',
-                  'const': 42
+                  'type': 'number'
+                }
+              }
+            }
+          ]
+        }
+      };
+      const res = generateJSONSchema(array);
+      expect(res).eql(expected);
+
+      const schemaRes = v.validate(array, res);
+      expect(schemaRes.errors).eql([]);
+      const schemaResRev = v.validate(array.reverse(), res);
+      expect(schemaResRev.errors).eql([]);
+    });
+    it('Array of different types of objects', () => {
+      const array = [
+        { a: 1 },
+        { a: 2 },
+        { a: 3 },
+        { a: 4 },
+        { b: 5 },
+        { b: 6 },
+        { b: 7 },
+        { b: 8 },
+      ];
+      const expected = {
+        'type': 'array',
+        'items': {
+          'anyOf': [
+            {
+              'type': 'object',
+              'properties': {
+                'a': {
+                  'type': 'number'
                 }
               }
             },
             {
               'type': 'object',
               'properties': {
-                'street': {
-                  'type': 'string',
-                  'const': 'Yochai'
-                },
-                'building': {
-                  'type': 'number',
-                  'const': 77
+                'b': {
+                  'type': 'number'
                 }
               }
             }
@@ -126,6 +159,8 @@ suite('JSON Schema generator', () => {
 
       const schemaRes = v.validate(array, res);
       expect(schemaRes.errors).eql([]);
+      const schemaResRev = v.validate(array.reverse(), res);
+      expect(schemaResRev.errors).eql([]);
     });
     it('Mixed object', () => {
       const obj = {
@@ -142,24 +177,20 @@ suite('JSON Schema generator', () => {
         'type': 'object',
         'properties': {
           'foo': {
-            'type': 'number',
-            'const': 123
+            'type': 'number'
           },
           'bar': {
             'type': 'object',
             'properties': {
               'x': {
-                'type': 'number',
-                'const': 1
+                'type': 'number'
               },
               'y': {
-                'type': 'string',
-                'const': 'one'
+                'type': 'string'
               },
               'null': {},
               'yes': {
-                'type': 'boolean',
-                'const': true
+                'type': 'boolean'
               }
             }
           },
@@ -168,21 +199,15 @@ suite('JSON Schema generator', () => {
             'items': {
               'anyOf': [
                 {
-                  'type': 'number',
-                  'const': 1
-                },
-                {
-                  'type': 'number',
-                  'const': 2
+                  'type': 'number'
                 },
                 {
                   'type': 'array',
                   'items': {
-                    'anyOf': 
+                    'anyOf':
                       [
                         {
-                          'type': 'number',
-                          'const': 3
+                          'type': 'number'
                         }
                       ]
                   }