@loadmill/executer 0.1.52 → 0.1.55

package/src/single-runner.ts

@@ -1,68 +0,0 @@
-import superagent from 'superagent';
-import { sequence } from './sequence';
-import * as envUtils from '@loadmill/universal/dist/env-utils';
-import log from '@loadmill/universal/dist/log';
-import { AuthConf, LoadmillRequest, CachePenetration } from '@loadmill/core/dist/request';
-import { Parameters } from '@loadmill/core/dist/parameters';
-import {
-  ExtendedSequenceResult,
-  extendSequenceResult,
-  RequestSequenceResult
-} from './request-sequence-result';
-
-export async function runSingleIterationAndMergeResolved(
-  conf: ExecutableConf,
-): Promise<ExtendedSequenceResult> {
-  const result = await runSingleIteration(conf);
-  return extendSequenceResult(result, conf.requests);
-}
-
-export async function runSingleIteration(
-  conf: ExecutableConf,
-): Promise<RequestSequenceResult> {
-  let httpAgent;
-  if (conf.useCookies && !envUtils.isBrowser()) {
-    log.debug('Enabling cookies for node client.');
-
-    // todo itay: make leak intentionally possible?
-    // Unlike in the browser, cookies cannot leak from iteration to iteration:
-    httpAgent = superagent.agent();
-  } else {
-    httpAgent = superagent;
-  }
-
-  return sequence.execute(
-    httpAgent,
-    extendRequests(conf),
-    conf.parameters,
-    conf.domainsWhiteList,
-    conf.increaseResSize
-  );
-}
-
-function extendRequests({
-  requests,
-  auth,
-  useCookies,
-  cachePenetration,
-}: ExecutableConf) {
-  return requests.map((req) => ({
-    ...req,
-    auth,
-    useCookies,
-    cachePenetration,
-  }));
-}
-
-export interface ExecutableConf {
-  parameters: Parameters[];
-  domainsWhiteList: string[];
-  requests: LoadmillRequest[];
-  cachePenetration: CachePenetration;
-
-  auth?: AuthConf;
-  useCookies?: boolean;
-  useProxy?: boolean;
-  useStaticIp?: boolean;
-  increaseResSize?: boolean;
-}

package/src/test-run-event-emitter.ts

@@ -1,25 +0,0 @@
-import log from '@loadmill/universal/dist/log';
-import { Socket } from 'socket.io-client';
-
-class TestRunEventsEmitter {
-  postScript: EventsEmitter;
-  constructor() {
-    const warningMsg = ' event emitter callback not assigned';
-    this.postScript = {
-      started: () => log.warn('postScript' + warningMsg),
-      finished: () => log.warn('postScript' + warningMsg),
-    };
-  }
-
-  setPostScriptHandlers = (socket: Socket, token: string) => {
-    this.postScript.started = () => socket.emit(`postscript-started:${token}`);
-    this.postScript.finished = () => socket.emit(`postscript-finished:${token}`);
-  }
-}
-
-const testRunEventsEmitter = new TestRunEventsEmitter();
-export { testRunEventsEmitter };
-
-type EventsEmitter = {
-  [funcName: string]: () => void | Socket;
-}

package/src/utils.ts

@@ -1,8 +0,0 @@
-import {
-  MAX_API_REQUEST_BODY_LENGTH,
-  MAX_LOAD_REQUEST_BODY_LENGTH
-} from '@loadmill/core/dist/conf/extrema';
-import * as envUtils from '@loadmill/universal/dist/env-utils';
-
-export const getMaxRequestBodySize = () =>
-  envUtils.isBrowser() ? MAX_LOAD_REQUEST_BODY_LENGTH : MAX_API_REQUEST_BODY_LENGTH;

package/src/work.ts

@@ -1,17 +0,0 @@
-import { AuthConf, LoadmillRequest, CachePenetration } from '@loadmill/core/dist/request';
-import { TestConfLike } from '@loadmill/core/dist/conf';
-import { Parameters } from '@loadmill/core/dist/parameters';
-
-export interface Work extends TestConfLike {
-  loadId: string;
-  duration: number;
-  iterations: number;
-  iterationDelay: number;
-  parameters: Parameters[];
-  domainsWhiteList: string[];
-  requests: LoadmillRequest[];
-  cachePenetration: CachePenetration;
-
-  auth?: AuthConf;
-  useCookies?: boolean;
-}

package/src/ws.ts

@@ -1,286 +0,0 @@
-import WebSocket from 'ws'; // todo should be picked with other option (socketio or non in browser)
-import { delay } from '@loadmill/universal/dist/promise-utils';
-import log from '@loadmill/universal/dist/log';
-import { HttpResponseStatus, LoadmillHeaders } from '@loadmill/core/dist/request';
-import { RequestFailuresError } from './errors';
-import { ClientRequest, IncomingMessage, IncomingHttpHeaders } from 'http';
-import { Socket } from 'net';
-declare class WS extends WebSocket {
-  _req: WSClientRequest | null;
-}
-declare class WSClientRequest extends ClientRequest {
-  socket: Socket & { parser: ParserIncomingMessage };
-}
-declare class ParserIncomingMessage {
-  incoming: IncomingMessage;
-}
-
-
-enum WSState {
-  CONNECTING,
-  OPEN,
-  CLOSING,
-  CLOSED,
-}
-
-const SWITCHING_PROTOCOLS = 'Switching Protocols';
-const WS_CONNECTION_TIMEOUT_MS = 10000;
-
-export class WSRequest {
-  private hasErrorOccured?: boolean; // need this otherwise we have race condition between verifyConnectedAndOpen and onError
-  private ws: WebSocket;
-  public url: string; // need this for isExpectedStatus function
-  public expectedStatus: HttpResponseStatus; // need this for isExpectedStatus function
-
-  constructor(
-    private readonly wsRequestArgs: WSRequestArguments,
-    private readonly wsHandler: WSSequenceHandler,
-    private readonly onError: (e: Error) => void,
-  ) {
-    this.url = wsRequestArgs.url;
-    this.expectedStatus = wsRequestArgs.expectedStatus;
-  }
-
-  /**
-   * This function is executed when we are ready to send the ws request
-   * @param cb This callback is being executed after we successfully connected to ws and sent a ws message if there was any
-   */
-  async ok(cb: (response: WSResponse) => boolean) {
-    const response: WSResponse = {
-      status: undefined,
-      res: {
-        statusMessage: undefined,
-      },
-      header: {},
-      req: {},
-    };
-
-    const existingWS = this.wsHandler.getConnection(this.wsRequestArgs.url);
-
-    existingWS && log.debug(`Existing Connection state ${getConnectionState(existingWS)}`);
-    if (!existingWS || (existingWS && existingWS.readyState !== WSState.OPEN)) {
-      await this.addConnection(response);
-    } else {
-      this.ws = existingWS;
-      log.debug('Reusing existing ws connection', this.ws.url);
-    }
-
-    try {
-      this.sendMessage();
-    } catch (e) {
-      log.error('Failed to send a ws message', e);
-    }
-    cb(response);
-    return { };
-  }
-
-  private async addConnection(response: WSResponse) {
-    this.ws = new WebSocket(this.wsRequestArgs.url, undefined, { headers: this.wsRequestArgs.headers });
-    this.addEventListeners(response);
-    !this.hasErrorOccured && await this.verifyOpen();
-    this.wsHandler.storeConnection(this.wsRequestArgs.url, this.ws);
-    // todo add some debug details for the user to know we created a new connection in this request
-  }
-
-  private async addEventListeners(response: WSResponse) {
-    this.addOnErrorListener(response);
-    this.addOnUpgradeListener(response);
-    this.addOnOpenListener();
-    this.addOnMessageListener();
-  }
-
-  private addOnErrorListener(response: WSResponse) {
-    this.ws.addEventListener('error', event => {
-      log.debug('inside addEventListener error');
-      try {
-        const target = event.target as WS;
-        this.updateResponseOnError(target, response);
-      } catch (e) {
-        log.error('Got an error inside addEventListener error', e);
-      }
-    });
-
-    this.ws.on('error', (e) => {
-      try {
-        log.debug('inside on error', e);
-        this.onError(e);
-        this.hasErrorOccured = true;
-      } catch (e) {
-        log.warn('Failed to handle a ws error', e);
-      }
-      try {
-        log.debug('closing ws');
-        this.ws.close();
-      } catch (e) {
-        log.warn('Failed to close a ws connection', e);
-      }
-    });
-  }
-
-  private updateResponseOnError(ws: WS, response: WSResponse) {
-    if (ws._req) {
-      const { statusCode, statusMessage, headers } = ws._req.socket.parser.incoming;
-      log.debug('Got incoming incoming request', { statusCode, statusMessage, headers });
-      response.status = statusCode;
-      response.res.statusMessage = statusMessage;
-      response.header = headers;
-    }
-  }
-
-  private addOnUpgradeListener(response: WSResponse) {
-    this.ws.on('upgrade', (event) => {
-      try {
-        const { statusCode, statusMessage, headers } = event;
-        log.debug('inside upgrade event', { statusCode, statusMessage, headers });
-        response.status = statusCode || 101;
-        response.res.statusMessage = statusMessage || SWITCHING_PROTOCOLS;
-        response.header = headers as LoadmillHeaders;
-      } catch (e) {
-        log.debug('upgrade event err', e);
-      }
-    });
-  }
-
-  private addOnOpenListener() {
-    this.ws.on('open', () => {
-      log.debug('inside on open, currently doing nothing here.');
-    });
-  }
-
-  private addOnMessageListener() {
-    this.ws.on('message', (message: any) => {
-      try {
-
-        const target = Array.isArray(message) ? decode(message) : message;
-        log.debug('got incoming message', target);
-
-        this.wsHandler.addMessage(target);
-      } catch (e) {
-        log.debug('error getting message', e);
-      }
-    });
-  }
-
-  async verifyOpen() {
-    const readyState = await this.waitForConnectedState(this.wsRequestArgs.timeout);
-    const connectionDebugMsg = `Connection ${WSState[readyState]}`;
-    log.debug(connectionDebugMsg);
-    if (readyState !== WebSocket.OPEN && !this.hasErrorOccured) {
-      let msg = 'Could not connect to WebSocket address: ';
-      log.debug(msg, { connectionState: WSState[readyState], url: this.ws.url });
-      if (readyState === WSState.CONNECTING) {
-        msg += 'request timeout';
-      } else { // CLOSING or CLOSED state
-        msg += connectionDebugMsg;
-      }
-      throw new RequestFailuresError(msg);
-    }
-  }
-
-  /**
-   * Waiting for WS connection to go out of CONNECTING state
-   * @param socket The ws connection object
-   * @param timeout The timeout in milliseconds for the waiting procedure
-   * @returns WSState
-   */
-  waitForConnectedState = async (timeout: number = WS_CONNECTION_TIMEOUT_MS): Promise<WSState> => {
-    const WS_CONNECTION_INTERVAL_MS = 100;
-    if (this.ws.readyState != null && this.ws.readyState !== WebSocket.CONNECTING) {
-      return this.ws.readyState;
-    }
-    else {
-      const maxIterations = timeout / WS_CONNECTION_INTERVAL_MS;
-      let i = 0;
-      while (this.ws.readyState === WebSocket.CONNECTING && i < maxIterations) {
-        await delay(WS_CONNECTION_INTERVAL_MS);
-        i++;
-      }
-      return this.ws.readyState;
-    }
-  };
-
-  private sendMessage() {
-    log.debug('about to send message', { readyState: WSState[this.ws.readyState] } );
-
-    const { message, mimeType } = this.wsRequestArgs;
-
-    if (this.ws.readyState === WSState.OPEN && message) {
-      this.ws.send(message, { binary: mimeType === 'binary' });
-    }
-
-  }
-
-  // need this because the SequenceExecutor expectes a request obj with on func prop
-  on(_eventName: string, _cb: Function) {
-    //do nothing
-  }
-}
-
-export class WSSequenceHandler {
-  private _connections: { [url: string]: WebSocket };
-  messages: string[];
-  constructor() {
-    this._connections = {};
-    this.clearMessages();
-  }
-
-  getConnection(url: string): WebSocket | undefined {
-    return this._connections[url];
-  }
-
-  storeConnection(url: string, wsConnection: WebSocket) {
-    this._connections[url] = wsConnection;
-  }
-
-  async closeAllConnections() {
-    try {
-      log.debug('Closing all ws connections');
-      for (const connection of Object.values(this._connections)) {
-        connection.close();
-      }
-    } catch (e) {
-      log.warn('Failed to close all connections', e, { connections: this._connections });
-    }
-  }
-
-  getMessages() {
-    return this.messages;
-  }
-
-  addMessage(message: string) {
-    this.messages.push(message);
-  }
-
-  clearMessages() {
-    this.messages = [];
-  }
-}
-
-function getConnectionState(existingWS?: WebSocket) {
-  return existingWS ? WSState[existingWS.readyState] : null;
-}
-
-function decode(buffer, encoding = 'utf-8') {
-  const enc = new TextDecoder(encoding);
-  return enc.decode(new Uint8Array(buffer));
-}
-
-export type WSMimeType = 'binary' | 'text';
-
-export type WSRequestArguments = {
-  expectedStatus: HttpResponseStatus;
-  headers: LoadmillHeaders
-  message: string;
-  mimeType: WSMimeType;
-  timeout: number;
-  url: string;
-};
-
-export type WSResponse = {
-  status?: number;
-  res: {
-    statusMessage?: string;
-  };
-  header: LoadmillHeaders | IncomingHttpHeaders;
-  req: {};
-}

package/test/post-script-console-log.spec.ts

@@ -1,73 +0,0 @@
-import { strict as assert } from 'assert';
-import { describe, it } from 'mocha';
-
-import { myConsole, LINE_LIMIT, CONSOLE_LOG_LIMIT } from '../src/post-script/console-log';
-
-describe('override console.log', () => {
-
-  it('Simple console.log', () => {
-    myConsole.setStdout([]);
-    myConsole.log(1);
-    assert.deepEqual(myConsole.stdout, ['1 ']);
-    myConsole.setStdout([]);
-    myConsole.log('a');
-    assert.deepEqual(myConsole.stdout, ['a ']);
-  });
-  it('Empty console.log', () => {
-    myConsole.setStdout([]);
-    myConsole.log();
-    assert.deepEqual(myConsole.stdout, []);
-  });
-  it('console.log with empty string', () => {
-    myConsole.setStdout([]);
-    myConsole.log('');
-    assert.deepEqual(myConsole.stdout, [' ']);
-  });
-  it('console.log of more than one element in one line', () => {
-    myConsole.setStdout([]);
-    myConsole.log(1,2,3,'a','b','c');
-    assert.deepEqual(myConsole.stdout, ['1 2 3 a b c ']);
-  });
-  it('console.log of an object', () => {
-    myConsole.setStdout([]);
-    const a = { 'A':1,'B':2 };
-    myConsole.log(a);
-    assert.deepEqual(myConsole.stdout, ['{\n  "A": 1,\n  "B": 2\n} ']);
-  });
-  it('console.log of a function', () => {
-    myConsole.setStdout([]);
-    const func = () => { };
-    myConsole.log(func);
-    assert.deepEqual(myConsole.stdout, ['function () { } ']);
-  });
-  it('console.log of an array', () => {
-    myConsole.setStdout([]);
-    const a = [1,2,3];
-    myConsole.log(a);
-    assert.deepEqual(myConsole.stdout, ['[\n  1,\n  2,\n  3\n] ']);
-  });
-  it('console.log of an array that contains objects', () => {
-    myConsole.setStdout([]);
-    const a = [1,2,3,{ 'A':1,'B':2 },{ 'C':3,'D':4 }];
-    myConsole.log(a);
-    assert.deepEqual(myConsole.stdout, ['[\n  1,\n  2,\n  3,\n  {\n    "A": 1,\n    "B": 2\n  },\n  {\n    "C": 3,\n    "D": 4\n  }\n] ']);
-  });
-  it('check the line limit', () => {
-    myConsole.setStdout([]);
-    const a = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
-    let b = '';
-    for (let i = 0; i<11; i++) {
-      b += a;
-    }
-    myConsole.log(b);
-    assert.deepEqual(myConsole.stdout, [b.substring(0, LINE_LIMIT) + '\n...']);
-  });
-  it('check the console.log limit', () => {
-    myConsole.setStdout([]);
-    const a = 123;
-    for (let i = 0; i<110; i++) {
-      myConsole.log(a);
-    }
-    assert.equal(myConsole.stdout.length, CONSOLE_LOG_LIMIT);
-  });
-});