se-runner/lib/se-runner.js

Selenium Test Runner

'use strict';

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

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 _globAll = require('glob-all');

var _globAll2 = _interopRequireDefault(_globAll);

var _logger = require('./logger');

var _logger2 = _interopRequireDefault(_logger);

var _utils = require('./utils');

var _utils2 = _interopRequireDefault(_utils);

var _worker = require('./worker');

var _worker2 = _interopRequireDefault(_worker);

var _workerState = require('./worker-state');

var _workerState2 = _interopRequireDefault(_workerState);

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 SeRunner = exports.SeRunner = function () {
    function SeRunner(config) {
        _classCallCheck(this, SeRunner);

        this.config = _utils2.default.extend({}, this.defaultConfig, config);
        this.config = _utils2.default.extend(this.config, {
            basePath: process.cwd(),
            concurrency: Math.min(this.config.capabilities.length, this.config.concurrency),
            driverFactory: {
                create: this.config.driverFactory.create.toString()
            },
            tests: this.config.tests ? _globAll2.default.sync(this.config.tests) : []
        });

        var _iteratorNormalCompletion = true;
        var _didIteratorError = false;
        var _iteratorError = undefined;

        try {
            for (var _iterator = this.config.dependencies[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                var d = _step.value;

                require(d);
            }
        } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
        } finally {
            try {
                if (!_iteratorNormalCompletion && _iterator.return) {
                    _iterator.return();
                }
            } finally {
                if (_didIteratorError) {
                    throw _iteratorError;
                }
            }
        }

        this.logger = new _logger2.default(this.config.logLevel);
        this.reports = [];
        this.workers = {};
    }

    _createClass(SeRunner, [{
        key: 'run',
        value: function run(done) {
            var _self = this,
                _doneCalled = false,
                _start = new Date().getTime(),
                _done = function _done(error) {
                !_doneCalled && (_doneCalled = true) && done && done({
                    duration: (new Date().getTime() - _start) / 1000,
                    error: error || null,
                    reports: _self.reports,
                    success: error ? false : !_self.reports.some(function (r) {
                        return !r.report.success;
                    })
                });
            },
                _workers = function _workers() {
                var state = arguments.length <= 0 || arguments[0] === undefined ? _workerState2.default.Working : arguments[0];

                var _workers = [];
                for (var worker in _self.workers) {
                    if (!_self.workers.hasOwnProperty(worker)) continue;

                    if (state === _self.workers[worker].state) {
                        _workers.push(_self.workers[worker]);
                    }
                }

                return _workers;
            },
                _onExit = function _onExit() {
                var _workers = _utils2.default.extend({}, _self.workers);
                for (var worker in _workers) {
                    if (!_workers.hasOwnProperty(worker)) continue;

                    if (_workerState2.default.Done !== _workers[worker].state) {
                        _workers[worker].done(true);
                    }
                }

                _done();
            },
                _onWorkerStopped = function _onWorkerStopped() {
                if (_workerState2.default.Done !== this.state) {
                    this.done();
                }

                _self.logger.log('Worker: ' + this.id + ' stopped');

                if (_workers(_workerState2.default.Done).length !== Object.keys(_self.workers).length) {
                    var _pendingWorkers = _workers(_workerState2.default.Pending);
                    for (var worker in _pendingWorkers) {
                        if (!_pendingWorkers.hasOwnProperty(worker)) continue;

                        if (_self.config.concurrency > _workers(_workerState2.default.Working).length) {
                            _pendingWorkers[worker].work();
                        }
                    }

                    return;
                }

                _self.logger.log('SeRunner::run(): Done...');
                _done();
            };

            process.on('SIGINT', _onExit);
            process.on('exit', _onExit);

            _self.logger.log('SeRunner::run(): Starting ' + _self.config.capabilities.length + ' workers, maximum ' + _self.config.concurrency + ' at the time...');
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
                for (var _iterator2 = _self.config.capabilities[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                    var capabilities = _step2.value;

                    var worker = new _worker2.default(_utils2.default.guid(), _utils2.default.extend({}, _self.config), _utils2.default.extend({}, capabilities));

                    worker.on('message', function (e) {
                        switch (e.type) {
                            case 'created':
                                _self.logger.log('Worker: ' + this.id + ' started, slave process id: ' + this.slave.pid);
                                break;
                            case 'data':
                                break;
                            case 'error':
                                _done(e);
                                break;
                            case 'exit':
                                _onWorkerStopped.call(this);
                                break;
                            case 'log':
                                _self.logger[e.logLevel](e.message);
                                break;
                            case 'report':
                                var _config = _utils2.default.extend({}, this.config, {
                                    workerId: this.id
                                });
                                delete _config.capabilities;

                                _self.reports.push({
                                    config: _config,
                                    description: this.description,
                                    report: e.report
                                });
                                break;
                        }
                    });

                    worker.on('error', _onWorkerStopped.bind(worker));
                    worker.on('exit', _onWorkerStopped.bind(worker));

                    this.workers[worker.id] = worker;

                    if (_self.config.concurrency > _workers(_workerState2.default.Working).length) {
                        worker.work();
                    }
                }
            } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                        _iterator2.return();
                    }
                } finally {
                    if (_didIteratorError2) {
                        throw _iteratorError2;
                    }
                }
            }
        }
    }, {
        key: 'defaultConfig',
        get: function get() {
            return {
                basePath: process.cwd(),
                capabilities: [],
                concurrency: 1,
                context: {},
                dependencies: [],
                driverFactory: {
                    create: function create(capabilities) {
                        return new (require('selenium-webdriver').Builder)().usingServer(this.selenium.hub).withCapabilities(capabilities).build();
                    }
                },
                framework: 'jasmine',
                logLevel: 'INFO',
                selenium: {
                    hub: 'http://hub.browserstack.com/wd/hub'
                },
                tests: [],
                timeout: 60000,
                jasmine: {
                    consoleReporter: true,
                    dependencies: [],
                    timeout: 60000
                }
            };
        }
    }]);

    return SeRunner;
}();