qape/lib/tester/Runner.js

Monkey testing library

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _Browser = _interopRequireDefault(require("./browser/Browser"));

var _ScenariosHandler = _interopRequireDefault(require("./scenarios/ScenariosHandler"));

var _ActionsHandler = _interopRequireDefault(require("./actions/ActionsHandler"));

var _messanger = require("./messanger");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * QApe runner class which sets up the whole test run.
 */
class Runner {
  /**
   * @param {Object} config
   */
  constructor(config) {
    this._config = config;
    this._scenariosHandler = null;
    this._actionsHandler = null;
    this._isSuccess = true;
  }
  /**
   * Initializes all dependencies and
   * starts all parallel instances.
   * @returns {Promise} Resolves for successful run,
   * rejects for failure
   */


  start() {
    this._init();

    return this._startInstance().then(() => {
      if (this._isSuccess) {
        return Promise.resolve();
      }

      return Promise.reject();
    });
  }
  /**
   * Starts single test instance with all dependencies
   * @returns {Promise}
   */


  async _startInstance() {
    for (;;) {
      let {
        scenario,
        type
      } = await (0, _messanger.requestScenario)();

      if (!scenario && !type) {
        break;
      }

      let instance = await this._getBrowserInstance();
      let results;
      (0, _messanger.report)('runner:start', {
        scenario
      });

      try {
        results = await this._scenariosHandler.runScenario(instance, type, scenario);
      } catch (error) {
        this._isSuccess = false;
        (0, _messanger.report)('runner:error', {
          scenario,
          error: error.stack
        });
      }

      if (results && results.errors && results.errors.length > 0) {
        this._isSuccess = false;
        (0, _messanger.sendFailingScenario)(results);
      }

      if (results && results.executionError && instance.unknownExecutionErrorOccured) {
        this._isSuccess = false;
      }

      await instance.clear();
      (0, _messanger.report)('runner:end');
    }
  }
  /**
   * Initializes browser instance
   * @returns {Browser} instance
   */


  _getBrowserInstance() {
    return new _Browser.default(this._config).initBrowser();
  }
  /**
   * Initializes all runner dependencies
   */


  _init() {
    this._initActionsHandler();

    this._initScenariosHandler();
  }
  /**
   * Initializes ActionsHandler instance
   */


  _initActionsHandler() {
    this._actionsHandler = new _ActionsHandler.default(this._config).init();
  }
  /**
   * Initializes ScenariosHandler instance
   */


  _initScenariosHandler() {
    this._scenariosHandler = new _ScenariosHandler.default(this._config, this._actionsHandler).init();
  }

}

exports.default = Runner;