se-runner/lib/slave.js

Selenium Test Runner

'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 _path = require('path');

var _path2 = _interopRequireDefault(_path);

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

var _utils2 = _interopRequireDefault(_utils);

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 Slave = function () {
    function Slave() {
        _classCallCheck(this, Slave);

        var _self = this,
            _args = process.argv.splice(2),
            _resolveRequire = function _resolveRequire(str) {
            var result = str,
                match,
                pattern = /require\(['|"]([^',^"]*)['|"]\)/gi;
            while (match = pattern.exec(str)) {
                if (!_self.config.driverFactory.variables[match[1]]) {
                    _self.config.driverFactory.variables[match[1]] = require(match[1]);

                    var regex = new RegExp('require\\([\'|"]' + match[1] + '[\'|"]\\)', 'i');
                    result = result.replace(regex, 'this.driverFactory.variables[\'' + match[1] + '\']');
                }
            }

            return result;
        },
            _waitForExit = function _waitForExit(counter) {
            if (_self.driver && 10 > counter) {
                setTimeout(function () {
                    _waitForExit(++counter);
                }, 1000);

                return;
            }

            process.kill(process.pid);
        },
            _onExit = function _onExit() {
            if (!_self.driver || !_self.driver.quit) {
                process.kill(process.pid);

                return;
            }

            _self.driver.quit().then(function () {
                _self.driver = null;
                process.kill(process.pid);
            });

            _waitForExit(0);
        };

        _self.pid = process.pid;
        _self.config = JSON.parse(_args[0]);
        _self.capabilities = JSON.parse(_args[1]);
        _self.args = _args.splice(2);

        _self.config.driverFactory.variables = {};
        _self.config.driverFactory.create = new Function('return ' + _resolveRequire(_self.config.driverFactory.create))().bind(_self.config);

        _self.driver = null;

        _self.framework = new (require('se-runner-framework-' + _self.config.framework))().initialize(_utils2.default.extend({
            basePath: _self.config.basePath,
            timeout: _self.config.timeout
        }, _self.config[_self.config.framework], {
            done: function done(report) {
                process.send({
                    type: 'report',
                    report: _self.report = report,
                    pid: _self.pid
                });
            }
        }));

        process.on('message', function (e) {
            switch (e.type) {
                case 'slave':
                    _self.slave();
                    break;
            }
        });

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

        process.send({
            type: 'created',
            pid: _self.pid
        });
    }

    _createClass(Slave, [{
        key: 'createDriver',
        value: function createDriver(capabilities) {
            return this.config.driverFactory.create(capabilities);
        }
    }, {
        key: 'log',
        value: function log(logLevel, message) {
            process.send({
                type: 'log',
                logLevel: logLevel,
                message: message,
                pid: this.pid
            });
        }
    }, {
        key: 'slave',
        value: function slave() {
            var _self = this,
                tests = _self.config.tests,
                runner = _self.framework.createRunner();

            _self.driver = _self.createDriver(_self.capabilities);
            _self.log('debug', 'Slave: ' + _self.pid + ' connecting to Selenium Hub');
            _self.driver.getSession().then(function (session) {
                var testCount = tests.length,
                    _tests = [],
                    _sessionId = session.getId(),
                    callback = function callback() {
                    if (--testCount === 0) {
                        _self.log('debug', 'All test suites done for browser: ' + _self.capabilities.browserName);
                        _self.driver.quit().then(function () {
                            _self.log('debug', 'Slave: ' + _self.pid + ' disconnected from Selenium Hub, sessionId: ' + _sessionId);
                            _self.driver = null;
                            process.kill(_self.pid);
                        });
                    }
                };

                _self.log('debug', 'Slave: ' + _self.pid + ' connected to Selenium Hub, sessionId: ' + _sessionId);

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

                try {
                    for (var _iterator = tests[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                        var testPath = _step.value;

                        var test = require(_path2.default.join(_self.config.basePath, testPath));

                        _tests.push(test(_utils2.default.extend({}, _self.config.context, {
                            requestedCapabilities: _self.capabilities,
                            driver: _self.driver,
                            done: callback,
                            sessionId: _sessionId
                        })));
                    }
                } catch (err) {
                    _didIteratorError = true;
                    _iteratorError = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion && _iterator.return) {
                            _iterator.return();
                        }
                    } finally {
                        if (_didIteratorError) {
                            throw _iteratorError;
                        }
                    }
                }

                try {
                    console.log(_self.config.description + ', sessionId: ' + _sessionId + '\n');
                    runner.run();
                } catch (e) {
                    process.send({
                        type: 'error',
                        message: _self.config.framework.charAt(0).toUpperCase() + _self.config.framework.slice(1) + ' error',
                        error: e,
                        pid: _self.pid,
                        stack: e.stack
                    });

                    _self.driver.quit().then(function () {
                        process.kill(_self.pid);
                    });
                }
            }).catch(function (e) {
                process.send({
                    type: 'error',
                    message: 'WebDriver error',
                    error: e,
                    pid: _self.pid,
                    stack: e.stack
                });

                process.disconnect();
            });
        }
    }]);

    return Slave;
}();

exports.default = new Slave();