intern/lib/reporters/JUnit.js

(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define(["require", "exports", "tslib", "fs", "path", "../Suite", "./Reporter", "../node/util"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = require("tslib");
    var fs_1 = require("fs");
    var path_1 = require("path");
    var Suite_1 = require("../Suite");
    var Reporter_1 = tslib_1.__importStar(require("./Reporter"));
    var util_1 = require("../node/util");
    var JUnit = (function (_super) {
        tslib_1.__extends(JUnit, _super);
        function JUnit(executor, options) {
            if (options === void 0) { options = {}; }
            var _this = _super.call(this, executor, options) || this;
            if (options.filename) {
                _this.filename = options.filename;
                if (path_1.dirname(_this.filename) !== '.') {
                    util_1.mkdirp(path_1.dirname(_this.filename));
                }
                _this.output = fs_1.createWriteStream(_this.filename);
            }
            return _this;
        }
        JUnit.prototype.runEnd = function () {
            var _this = this;
            var rootNode = new XmlNode('testsuites');
            this.executor.suites.forEach(function (suite) {
                rootNode.childNodes.push(createSuiteNode(suite, _this));
            });
            var report = '<?xml version="1.0" encoding="UTF-8" ?>' + rootNode.toString() + '\n';
            this.output.end(report);
        };
        tslib_1.__decorate([
            Reporter_1.eventHandler()
        ], JUnit.prototype, "runEnd", null);
        return JUnit;
    }(Reporter_1.default));
    exports.default = JUnit;
    var XmlNode = (function () {
        function XmlNode(nodeName, attributes) {
            this.nodeName = '';
            this.childNodes = [];
            this.nodeName = nodeName;
            if (attributes && attributes.childNodes) {
                this.childNodes = attributes.childNodes;
                attributes.childNodes = undefined;
            }
            this.attributes = attributes || {};
        }
        XmlNode.prototype.createNode = function (nodeName, attributes) {
            var node = new XmlNode(nodeName, attributes);
            this.childNodes.push(node);
            return node;
        };
        XmlNode.prototype._escape = function (str) {
            return String(str)
                .replace(/&/g, '&amp;')
                .replace(/</g, '&lt;')
                .replace(/"/g, '&quot;');
        };
        XmlNode.prototype._serializeAttributes = function () {
            var attributes = this.attributes;
            var nodes = [];
            for (var key in attributes) {
                if (attributes[key] != null) {
                    nodes.push(key + '="' + this._escape(attributes[key]) + '"');
                }
            }
            return nodes.length ? ' ' + nodes.join(' ') : '';
        };
        XmlNode.prototype._serializeContent = function () {
            var nodeList = this.childNodes;
            var nodes = [];
            for (var i = 0, j = nodeList.length; i < j; ++i) {
                nodes.push(typeof nodeList[i] === 'string'
                    ? this._escape(nodeList[i])
                    : nodeList[i].toString());
            }
            return nodes.join('');
        };
        XmlNode.prototype.toString = function () {
            var children = this._serializeContent();
            return ('<' +
                this.nodeName +
                this._serializeAttributes() +
                (children.length ? '>' + children + '</' + this.nodeName + '>' : '/>'));
        };
        return XmlNode;
    }());
    function createChildErrorNode(error, reporter) {
        return new XmlNode('error', {
            childNodes: [reporter.formatError(error)],
            message: error.message,
            type: error.name
        });
    }
    function createSuiteNode(suite, reporter) {
        var error = suite.error;
        var childNodes;
        if (error && error.lifecycleMethod === 'before') {
            childNodes = [createChildErrorNode(error, reporter)];
        }
        else {
            childNodes = suite.tests.map(function (test) { return createTestNode(test, reporter); });
        }
        if (error && error.lifecycleMethod === 'after') {
            childNodes.push(createChildErrorNode(error, reporter));
        }
        return new XmlNode('testsuite', {
            name: suite.name || 'Node.js',
            failures: suite.numFailedTests,
            skipped: suite.numSkippedTests,
            tests: suite.numTests,
            time: suite.timeElapsed / 1000,
            childNodes: childNodes
        });
    }
    function createTestNode(test, reporter) {
        if (Suite_1.isSuite(test)) {
            return createSuiteNode(test, reporter);
        }
        var node = new XmlNode('testcase', {
            name: test.name,
            time: test.timeElapsed / 1000,
            status: test.error ? 1 : 0
        });
        if (test.error || test.suiteError) {
            var error = (test.error || test.suiteError);
            node.createNode(error.name === 'AssertionError' ? 'failure' : 'error', {
                childNodes: [reporter.formatError(error)],
                message: error.message,
                type: error.name
            });
        }
        else if (test.skipped != null) {
            node.createNode('skipped', {
                childNodes: [test.skipped]
            });
        }
        return node;
    }
});
//# sourceMappingURL=JUnit.js.map