wdio-cucumber-framework/build/reporter.js

A WebdriverIO plugin. Adapter for Cucumber testing framework.

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.__RewireAPI__ = exports.__ResetDependency__ = exports.__set__ = exports.__Rewire__ = exports.__GetDependency__ = exports.__get__ = undefined;

var _isExtensible = require('babel-runtime/core-js/object/is-extensible');

var _isExtensible2 = _interopRequireDefault(_isExtensible);

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _defineProperty2 = require('babel-runtime/core-js/object/define-property');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

var _create = require('babel-runtime/core-js/object/create');

var _create2 = _interopRequireDefault(_create);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _defineProperty4 = require('babel-runtime/helpers/defineProperty');

var _defineProperty5 = _interopRequireDefault(_defineProperty4);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _cucumber = require('cucumber');

var _cucumberEventListener = require('./cucumberEventListener');

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

var _path = require('path');

var path = _interopRequireWildcard(_path);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

var SETTLE_TIMEOUT = 5000;

var CucumberReporter = function () {
    function CucumberReporter(eventBroadcaster, options, cid, specs) {
        (0, _classCallCheck3.default)(this, CucumberReporter);
        this.gherkinDocEvents = [];

        this.capabilities = options.capabilities;
        this.tagsInTitle = options.tagsInTitle || false;
        this.options = options;
        this.cid = cid;
        this.specs = specs;
        this.failedCount = 0;

        this.sentMessages = 0; // number of messages sent to the parent
        this.receivedMessages = 0; // number of messages received by the parent

        new (_get__('CucumberEventListener'))(eventBroadcaster).on('before-feature', this.handleBeforeFeature.bind(this)).on('before-scenario', this.handleBeforeScenario.bind(this)).on('before-step', this.handleBeforeStep.bind(this)).on('after-step', this.handleAfterStep.bind(this)).on('after-scenario', this.handleAfterScenario.bind(this)).on('after-feature', this.handleAfterFeature.bind(this));
    }

    (0, _createClass3.default)(CucumberReporter, [{
        key: 'handleBeforeFeature',
        value: function handleBeforeFeature(uri, feature) {
            this.featureStart = new Date();

            this.emit('suite:start', {
                uid: this.getUniqueIdentifier(feature),
                title: this.getTitle(feature),
                type: 'suite',
                file: uri,
                tags: feature.tags,
                description: feature.description,
                keyword: feature.keyword
            });
        }
    }, {
        key: 'handleBeforeScenario',
        value: function handleBeforeScenario(uri, feature, scenario) {
            this.scenarioStart = new Date();
            this.testStart = new Date();

            this.emit('suite:start', {
                uid: this.getUniqueIdentifier(scenario),
                title: this.getTitle(scenario),
                parent: this.getUniqueIdentifier(feature),
                type: 'suite',
                file: uri,
                tags: scenario.tags
            });
        }
    }, {
        key: 'handleBeforeStep',
        value: function handleBeforeStep(uri, feature, scenario, step, sourceLocation) {
            this.testStart = new Date();

            this.emit('test:start', {
                uid: this.getUniqueIdentifier(step),
                title: step.text,
                type: 'test',
                file: uri,
                parent: this.getUniqueIdentifier(scenario, sourceLocation),
                duration: new Date() - this.testStart,
                tags: scenario.tags,
                featureName: feature.name,
                scenarioName: scenario.name,
                argument: _get__('createStepArgument')(step)
            });
        }
    }, {
        key: 'handleAfterStep',
        value: function handleAfterStep(uri, feature, scenario, step, result, sourceLocation) {
            var e = 'undefined';
            switch (result.status) {
                case _get__('Status').FAILED:
                case _get__('Status').UNDEFINED:
                    e = 'fail';
                    break;
                case _get__('Status').PASSED:
                    e = 'pass';
                    break;
                case _get__('Status').PENDING:
                case _get__('Status').SKIPPED:
                case _get__('Status').AMBIGUOUS:
                    e = 'pending';
            }
            var error = {};
            var stepTitle = step.text || step.keyword || 'Undefined Step';

            /**
             * if step name is undefined we are dealing with a hook
             * don't report hooks if no error happened
             */
            if (!step.text && result.status !== _get__('Status').FAILED) {
                return;
            }

            if (result.status === _get__('Status').UNDEFINED) {
                if (this.options.ignoreUndefinedDefinitions) {
                    /**
                     * mark test as pending
                     */
                    e = 'pending';
                    stepTitle += ' (undefined step)';
                } else {
                    /**
                     * mark test as failed
                     */
                    this.failedCount++;

                    error = {
                        message: 'Step "' + stepTitle + '" is not defined. You can ignore this error by setting\n                              cucumberOpts.ignoreUndefinedDefinitions as true.',
                        stack: step.uri + ':' + step.line
                    };
                }
            } else if (result.status === _get__('Status').FAILED) {
                /**
                 * cucumber failure exception can't get send to parent process
                 * for some reasons
                 */
                var err = result.exception;
                if (err instanceof Error) {
                    error = {
                        message: err.message,
                        stack: err.stack
                    };
                } else {
                    error = {
                        message: err
                    };
                }
                this.failedCount++;
            } else if (result.status === _get__('Status').AMBIGUOUS && this.options.failAmbiguousDefinitions) {
                e = 'fail';
                this.failedCount++;
                error = {
                    message: result.exception
                };
            }

            this.emit('test:' + e, {
                uid: this.getUniqueIdentifier(step),
                title: stepTitle.trim(),
                type: 'test',
                file: uri,
                parent: this.getUniqueIdentifier(scenario, sourceLocation),
                error: error,
                duration: new Date() - this.testStart,
                tags: scenario.tags,
                keyword: step.keyword,
                argument: _get__('createStepArgument')(step)
            });
        }
    }, {
        key: 'handleAfterScenario',
        value: function handleAfterScenario(uri, feature, scenario, sourceLocation) {
            this.emit('suite:end', {
                uid: this.getUniqueIdentifier(scenario, sourceLocation),
                title: this.getTitle(scenario),
                parent: this.getUniqueIdentifier(feature),
                type: 'suite',
                file: uri,
                duration: new Date() - this.scenarioStart,
                tags: scenario.tags
            });
        }
    }, {
        key: 'handleAfterFeature',
        value: function handleAfterFeature(uri, feature) {
            this.emit('suite:end', {
                uid: this.getUniqueIdentifier(feature),
                title: this.getTitle(feature),
                type: 'suite',
                file: uri,
                duration: new Date() - this.featureStart,
                tags: feature.tags
            });
        }
    }, {
        key: 'emit',
        value: function emit(event, payload) {
            var _this = this;

            var message = {
                event: event,
                cid: this.cid,
                uid: payload.uid,
                title: payload.title,
                pending: payload.pending || false,
                parent: payload.parent || null,
                type: payload.type,
                file: payload.file,
                err: payload.error || {},
                duration: payload.duration,
                runner: (0, _defineProperty5.default)({}, this.cid, this.capabilities),
                specs: this.specs,
                tags: payload.tags || [],
                featureName: payload.featureName,
                scenarioName: payload.scenarioName,
                description: payload.description,
                keyword: payload.keyword || null,
                argument: payload.argument
            };

            this.send(message, null, {}, function () {
                return ++_this.receivedMessages;
            });
            this.sentMessages++;
        }
    }, {
        key: 'send',
        value: function send() {
            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
                args[_key] = arguments[_key];
            }

            return process.send.apply(process, args);
        }

        /**
         * wait until all messages were sent to parent
         */

    }, {
        key: 'waitUntilSettled',
        value: function waitUntilSettled() {
            var _this2 = this;

            return new _promise2.default(function (resolve) {
                var start = new Date().getTime();
                var interval = setInterval(function () {
                    var now = new Date().getTime();

                    if (_this2.sentMessages !== _this2.receivedMessages && now - start < _get__('SETTLE_TIMEOUT')) return;
                    clearInterval(interval);
                    resolve();
                }, 100);
            });
        }
    }, {
        key: 'getTitle',
        value: function getTitle(featureOrScenario) {
            var name = featureOrScenario.name;
            var tags = featureOrScenario.tags;
            if (!this.tagsInTitle || !tags.length) return name;
            return tags.map(function (tag) {
                return tag.name;
            }).join(', ') + ': ' + name;
        }
    }, {
        key: 'getUriOf',
        value: function getUriOf(type) {
            if (!type || !type.uri) {
                return;
            }

            return type.uri.replace(process.cwd(), '');
        }
    }, {
        key: 'getUniqueIdentifier',
        value: function getUniqueIdentifier(target, sourceLocation) {
            var name = void 0;
            var line = void 0;

            if (target.type === 'Hook') {
                name = _get__('path').basename(target.location.uri);
                line = target.location.line;
            } else if (target.type === 'ScenarioOutline') {
                name = target.name || target.text;
                line = sourceLocation.line;

                target.examples[0].tableHeader.cells.forEach(function (header, idx) {
                    if (name.indexOf('<' + header.value + '>') > -1) {
                        target.examples[0].tableBody.forEach(function (tableEntry) {
                            if (tableEntry.location.line === sourceLocation.line) {
                                name = name.replace('<' + header.value + '>', tableEntry.cells[idx].value);
                            }
                        });
                    }
                });
            } else {
                name = target.name || target.text;
                var location = target.location || target.locations[0];
                line = location && location.line || '';
            }

            return name + line;
        }
    }]);
    return CucumberReporter;
}();

exports.default = _get__('CucumberReporter');

function _getGlobalObject() {
    try {
        if (!!global) {
            return global;
        }
    } catch (e) {
        try {
            if (!!window) {
                return window;
            }
        } catch (e) {
            return this;
        }
    }
}

;
var _RewireModuleId__ = null;

function _getRewireModuleId__() {
    if (_RewireModuleId__ === null) {
        var globalVariable = _getGlobalObject();

        if (!globalVariable.__$$GLOBAL_REWIRE_NEXT_MODULE_ID__) {
            globalVariable.__$$GLOBAL_REWIRE_NEXT_MODULE_ID__ = 0;
        }

        _RewireModuleId__ = __$$GLOBAL_REWIRE_NEXT_MODULE_ID__++;
    }

    return _RewireModuleId__;
}

function _getRewireRegistry__() {
    var theGlobalVariable = _getGlobalObject();

    if (!theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__) {
        theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__ = (0, _create2.default)(null);
    }

    return __$$GLOBAL_REWIRE_REGISTRY__;
}

function _getRewiredData__() {
    var moduleId = _getRewireModuleId__();

    var registry = _getRewireRegistry__();

    var rewireData = registry[moduleId];

    if (!rewireData) {
        registry[moduleId] = (0, _create2.default)(null);
        rewireData = registry[moduleId];
    }

    return rewireData;
}

(function registerResetAll() {
    var theGlobalVariable = _getGlobalObject();

    if (!theGlobalVariable['__rewire_reset_all__']) {
        theGlobalVariable['__rewire_reset_all__'] = function () {
            theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__ = (0, _create2.default)(null);
        };
    }
})();

var INTENTIONAL_UNDEFINED = '__INTENTIONAL_UNDEFINED__';
var _RewireAPI__ = {};

(function () {
    function addPropertyToAPIObject(name, value) {
        (0, _defineProperty3.default)(_RewireAPI__, name, {
            value: value,
            enumerable: false,
            configurable: true
        });
    }

    addPropertyToAPIObject('__get__', _get__);
    addPropertyToAPIObject('__GetDependency__', _get__);
    addPropertyToAPIObject('__Rewire__', _set__);
    addPropertyToAPIObject('__set__', _set__);
    addPropertyToAPIObject('__reset__', _reset__);
    addPropertyToAPIObject('__ResetDependency__', _reset__);
    addPropertyToAPIObject('__with__', _with__);
})();

function _get__(variableName) {
    var rewireData = _getRewiredData__();

    if (rewireData[variableName] === undefined) {
        return _get_original__(variableName);
    } else {
        var value = rewireData[variableName];

        if (value === INTENTIONAL_UNDEFINED) {
            return undefined;
        } else {
            return value;
        }
    }
}

function _get_original__(variableName) {
    switch (variableName) {
        case 'CucumberEventListener':
            return _cucumberEventListener.CucumberEventListener;

        case 'createStepArgument':
            return _utils.createStepArgument;

        case 'Status':
            return _cucumber.Status;

        case 'SETTLE_TIMEOUT':
            return SETTLE_TIMEOUT;

        case 'path':
            return _filterWildcardImport__(path);

        case 'CucumberReporter':
            return CucumberReporter;
    }

    return undefined;
}

function _assign__(variableName, value) {
    var rewireData = _getRewiredData__();

    if (rewireData[variableName] === undefined) {
        return _set_original__(variableName, value);
    } else {
        return rewireData[variableName] = value;
    }
}

function _set_original__(variableName, _value) {
    switch (variableName) {}

    return undefined;
}

function _update_operation__(operation, variableName, prefix) {
    var oldValue = _get__(variableName);

    var newValue = operation === '++' ? oldValue + 1 : oldValue - 1;

    _assign__(variableName, newValue);

    return prefix ? newValue : oldValue;
}

function _set__(variableName, value) {
    var rewireData = _getRewiredData__();

    if ((typeof variableName === 'undefined' ? 'undefined' : (0, _typeof3.default)(variableName)) === 'object') {
        (0, _keys2.default)(variableName).forEach(function (name) {
            rewireData[name] = variableName[name];
        });
    } else {
        if (value === undefined) {
            rewireData[variableName] = INTENTIONAL_UNDEFINED;
        } else {
            rewireData[variableName] = value;
        }

        return function () {
            _reset__(variableName);
        };
    }
}

function _reset__(variableName) {
    var rewireData = _getRewiredData__();

    delete rewireData[variableName];

    if ((0, _keys2.default)(rewireData).length == 0) {
        delete _getRewireRegistry__()[_getRewireModuleId__];
    }

    ;
}

function _with__(object) {
    var rewireData = _getRewiredData__();

    var rewiredVariableNames = (0, _keys2.default)(object);
    var previousValues = {};

    function reset() {
        rewiredVariableNames.forEach(function (variableName) {
            rewireData[variableName] = previousValues[variableName];
        });
    }

    return function (callback) {
        rewiredVariableNames.forEach(function (variableName) {
            previousValues[variableName] = rewireData[variableName];
            rewireData[variableName] = object[variableName];
        });
        var result = callback();

        if (!!result && typeof result.then == 'function') {
            result.then(reset).catch(reset);
        } else {
            reset();
        }

        return result;
    };
}

var _typeOfOriginalExport = typeof CucumberReporter === 'undefined' ? 'undefined' : (0, _typeof3.default)(CucumberReporter);

function addNonEnumerableProperty(name, value) {
    (0, _defineProperty3.default)(CucumberReporter, name, {
        value: value,
        enumerable: false,
        configurable: true
    });
}

if ((_typeOfOriginalExport === 'object' || _typeOfOriginalExport === 'function') && (0, _isExtensible2.default)(CucumberReporter)) {
    addNonEnumerableProperty('__get__', _get__);
    addNonEnumerableProperty('__GetDependency__', _get__);
    addNonEnumerableProperty('__Rewire__', _set__);
    addNonEnumerableProperty('__set__', _set__);
    addNonEnumerableProperty('__reset__', _reset__);
    addNonEnumerableProperty('__ResetDependency__', _reset__);
    addNonEnumerableProperty('__with__', _with__);
    addNonEnumerableProperty('__RewireAPI__', _RewireAPI__);
}

function _filterWildcardImport__() {
    var wildcardImport = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var validPropertyNames = (0, _keys2.default)(wildcardImport).filter(function (propertyName) {
        return propertyName !== '__get__' && propertyName !== '__set__' && propertyName !== '__reset__' && propertyName !== '__with__' && propertyName !== '__GetDependency__' && propertyName !== '__Rewire__' && propertyName !== '__ResetDependency__' && propertyName !== '__RewireAPI__';
    });
    return validPropertyNames.reduce(function (filteredWildcardImport, propertyName) {
        filteredWildcardImport[propertyName] = wildcardImport[propertyName];
        return filteredWildcardImport;
    }, {});
}

exports.__get__ = _get__;
exports.__GetDependency__ = _get__;
exports.__Rewire__ = _set__;
exports.__set__ = _set__;
exports.__ResetDependency__ = _reset__;
exports.__RewireAPI__ = _RewireAPI__;