green-light/lib/index.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _mockedApi = require('mocked-api');

var _mockedApi2 = _interopRequireDefault(_mockedApi);

var _terminate = require('terminate');

var _terminate2 = _interopRequireDefault(_terminate);

var _chai = require('chai');

var _chai2 = _interopRequireDefault(_chai);

var _configHelper = require('./utils/config-helper');

var _target = require('./target');

var _target2 = _interopRequireDefault(_target);

var _browser = require('./browser');

var _browser2 = _interopRequireDefault(_browser);

var _tests = require('./tests');

var _tests2 = _interopRequireDefault(_tests);

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var readLine = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

var GreenLight = function () {
  function GreenLight() {
    var _this = this;

    _classCallCheck(this, GreenLight);

    this.api = null;
    this.API = _mockedApi2.default;

    this.target = null;
    this.Target = _target2.default;

    this.browser = null;
    this.Browser = _browser2.default;

    this.tests = null;
    this.Tests = _tests2.default;

    this.expect = _chai2.default.expect;

    this.pause = function (test) {
      console.log('Paused at: ' + _this.browser.url);
      var originalTimeout = test.timeout;
      test.timeout(null);
      return new Promise(function (resolve, reject) {
        readLine.question('Press enter to continue.', function () {
          test.timeout(originalTimeout);
          readLine.close();
          reject(new Error('Test is considered invalid because it was paused.'));
        });
      });
    };
  }

  _createClass(GreenLight, [{
    key: 'init',
    value: function init() {
      return Promise.resolve();
    }
  }, {
    key: 'done',
    value: function done(exitCode) {
      return this.clean().then(function () {
        process.exit(exitCode);
      });
    }
  }, {
    key: 'fail',
    value: function fail(err) {
      return this.clean().then(function () {
        console.error(err.stack || err);
        process.exit(1);
      });
    }
  }, {
    key: 'clean',
    value: function clean() {
      return new Promise(function (resolve, reject) {
        (0, _terminate2.default)(process.pid, function (err) {
          if (err) {
            throw err;
          }
          resolve();
        });
      });
    }

    /*
     * API
     */

  }, {
    key: 'runAPI',
    value: function runAPI(config) {
      config = (0, _configHelper.parseConfigFor)('api', config);

      if (config.verbose) {
        console.log('Initializing API...');
      }

      var api = this.API.setup(config);

      if (!config.name) {
        // handy shortcut:
        this.api = api;
      } else {
        // should be referenced with GreenLight.API.getByName()
      }

      return api.start().then(function () {
        if (config.verbose) {
          console.log('API ready');
        }
      });
    }

    /*
     * Target
     */

  }, {
    key: 'runTarget',
    value: function runTarget(config) {
      config = (0, _configHelper.parseConfigFor)('target', config);

      if (config.verbose) {
        console.log('Initializing target...');
      }

      this.target = new _target2.default(config);
      return this.target.start().then(function () {
        if (config.verbose) {
          console.log('Target ready');
        }
      });
    }

    /*
     * Browser
     */

  }, {
    key: 'runBrowser',
    value: function runBrowser(config) {
      config = (0, _configHelper.parseConfigFor)('browser', config);

      if (config.verbose) {
        console.log('Initializing browser...');
      }

      this.browser = new _browser2.default(config);
      return this.browser.start().then(function () {
        if (config.verbose) {
          console.log('Browser ready');
        }
      });
    }

    /*
     * Mocha
     */

  }, {
    key: 'runTests',
    value: function runTests(config) {
      config = (0, _configHelper.parseConfigFor)('tests', config);

      if (config.verbose) {
        console.log('Initializing tests...');
      }

      this.tests = new _tests2.default(config);
      return this.tests.start().then(function (failures) {
        if (config.verbose) {
          console.log('Tests ready');
        }
        return failures;
      });
    }
  }]);

  return GreenLight;
}();

exports.default = GreenLight;


module.exports = new GreenLight();