qunit-harness/lib/cli/runner.js

A library for running qunit tests on a local machine and in the SauceLabs environment.

'use strict';

var _inherits = require('babel-runtime/helpers/inherits').default;

var _classCallCheck = require('babel-runtime/helpers/class-call-check').default;

var _regeneratorRuntime = require('babel-runtime/regenerator').default;

var _interopRequireDefault = require('babel-runtime/helpers/interop-require-default').default;

exports.__esModule = true;

var _promisifyEvent = require('promisify-event');

var _promisifyEvent2 = _interopRequireDefault(_promisifyEvent);

var _events = require('events');

var _job = require('./job');

var _job2 = _interopRequireDefault(_job);

var REPORTING_TIMEOUT = 1000 * 30;

var CLIRunner = (function (_EventEmitter) {
    _inherits(CLIRunner, _EventEmitter);

    function CLIRunner(options, testServer) {
        _classCallCheck(this, CLIRunner);

        _EventEmitter.call(this);

        this.options = options;
        this.testServer = testServer;
        this.jobs = [];
        this.jobResults = [];
        this.reportingInterval = null;
        this.freeMachineCheckInterval = null;
    }

    CLIRunner.prototype._getQueuedJobs = function _getQueuedJobs() {
        return this.jobs.filter(function (job) {
            return job.getStatus() === _job2.default.STATUSES.INITIALIZED;
        });
    };

    CLIRunner.prototype._getInProgressJobsCount = function _getInProgressJobsCount() {
        return this.jobs.filter(function (job) {
            return job.getStatus() === _job2.default.STATUSES.IN_PROGRESS;
        }).length;
    };

    CLIRunner.prototype._getCompletedJobsCount = function _getCompletedJobsCount() {
        return this.jobs.filter(function (job) {
            return job.getStatus() === _job2.default.STATUSES.COMPLETED;
        }).length;
    };

    CLIRunner.prototype._getFailedJobsCount = function _getFailedJobsCount() {
        return this.jobs.filter(function (job) {
            return job.getStatus() === _job2.default.STATUSES.FAILED;
        }).length;
    };

    CLIRunner.prototype._outputCurrentTaskStatus = function _outputCurrentTaskStatus() {
        var total = this.jobs.length;
        var inProgress = this._getInProgressJobsCount();
        var completed = this._getCompletedJobsCount();
        var failed = this._getFailedJobsCount();
        var queued = total - inProgress - completed - failed;

        var message = 'Tasks total: ' + total + ', queued: ' + queued + ', in progress: ' + inProgress + ', completed: ' + completed;

        if (failed) message += ', failed: ' + failed;

        console.log(message);
    };

    CLIRunner.prototype._runCurrentTaskStatusReporting = function _runCurrentTaskStatusReporting() {
        var _this = this;

        this.reportingInterval = setInterval(function () {
            return _this._outputCurrentTaskStatus();
        }, REPORTING_TIMEOUT);
    };

    CLIRunner.prototype._startJobs = function _startJobs() {
        var jobs;
        return _regeneratorRuntime.async(function _startJobs$(context$2$0) {
            var _this2 = this;

            while (1) switch (context$2$0.prev = context$2$0.next) {
                case 0:
                    jobs = this._getQueuedJobs();

                    jobs.forEach(function (job) {
                        job.run().then(function (result) {
                            _this2.jobResults = _this2.jobResults.concat(result);

                            _this2.emit('job-done');
                        }).catch(console.log);
                    });

                case 2:
                case 'end':
                    return context$2$0.stop();
            }
        }, null, this);
    };

    CLIRunner.prototype.runTests = function runTests() {
        var completedJobs, jobsDonePromise;
        return _regeneratorRuntime.async(function runTests$(context$2$0) {
            var _this3 = this;

            while (1) switch (context$2$0.prev = context$2$0.next) {
                case 0:
                    this.jobs = this.options.browsers.map(function (browser) {
                        return new _job2.default(_this3.options, browser, _this3.testServer);
                    });

                    completedJobs = 0;

                    this._runCurrentTaskStatusReporting();

                    context$2$0.prev = 3;
                    jobsDonePromise = _promisifyEvent2.default(this, 'done');

                    this._startJobs();

                    this.on('job-done', function () {
                        if (++completedJobs === _this3.jobs.length) _this3.emit('done');
                    });

                    context$2$0.next = 9;
                    return _regeneratorRuntime.awrap(jobsDonePromise);

                case 9:

                    clearInterval(this.reportingInterval);
                    context$2$0.next = 16;
                    break;

                case 12:
                    context$2$0.prev = 12;
                    context$2$0.t0 = context$2$0['catch'](3);

                    clearInterval(this.reportingInterval);

                    throw 'RUN TESTS ERROR: ' + context$2$0.t0;

                case 16:
                    return context$2$0.abrupt('return', this.jobResults);

                case 17:
                case 'end':
                    return context$2$0.stop();
            }
        }, null, this, [[3, 12]]);
    };

    return CLIRunner;
})(_events.EventEmitter);

exports.default = CLIRunner;
module.exports = exports.default;