mocha-compat 3.6.4 → 10.8.2

package/lib/reporters/tap.js

@@ -1,10 +1,22 @@
 'use strict';
-
+/**
+ * @module TAP
+ */
 /**
  * Module dependencies.
  */
 
+var util = require('util');
 var Base = require('./base');
+var constants = require('../runner').constants;
+var EVENT_TEST_PASS = constants.EVENT_TEST_PASS;
+var EVENT_TEST_FAIL = constants.EVENT_TEST_FAIL;
+var EVENT_RUN_BEGIN = constants.EVENT_RUN_BEGIN;
+var EVENT_RUN_END = constants.EVENT_RUN_END;
+var EVENT_TEST_PENDING = constants.EVENT_TEST_PENDING;
+var EVENT_TEST_END = constants.EVENT_TEST_END;
+var inherits = require('../utils').inherits;
+var sprintf = util.format;
 
 /**
  * Expose `TAP`.
@@ -13,58 +25,269 @@ var Base = require('./base');
 exports = module.exports = TAP;
 
 /**
- * Initialize a new `TAP` reporter.
+ * Constructs a new `TAP` reporter instance.
  *
- * @api public
- * @param {Runner} runner
+ * @public
+ * @class
+ * @memberof Mocha.reporters
+ * @extends Mocha.reporters.Base
+ * @param {Runner} runner - Instance triggers reporter actions.
+ * @param {Object} [options] - runner options
  */
-function TAP (runner) {
-  Base.call(this, runner);
+function TAP(runner, options) {
+  Base.call(this, runner, options);
 
+  var self = this;
   var n = 1;
-  var passes = 0;
-  var failures = 0;
 
-  runner.on('start', function () {
-    var total = runner.grepTotal(runner.suite);
-    console.log('%d..%d', 1, total);
+  var tapVersion = '12';
+  if (options && options.reporterOptions) {
+    if (options.reporterOptions.tapVersion) {
+      tapVersion = options.reporterOptions.tapVersion.toString();
+    }
+  }
+
+  this._producer = createProducer(tapVersion);
+
+  runner.once(EVENT_RUN_BEGIN, function () {
+    self._producer.writeVersion();
   });
 
-  runner.on('test end', function () {
+  runner.on(EVENT_TEST_END, function () {
     ++n;
   });
 
-  runner.on('pending', function (test) {
-    console.log('ok %d %s # SKIP -', n, title(test));
+  runner.on(EVENT_TEST_PENDING, function (test) {
+    self._producer.writePending(n, test);
   });
 
-  runner.on('pass', function (test) {
-    passes++;
-    console.log('ok %d %s', n, title(test));
+  runner.on(EVENT_TEST_PASS, function (test) {
+    self._producer.writePass(n, test);
   });
 
-  runner.on('fail', function (test, err) {
-    failures++;
-    console.log('not ok %d %s', n, title(test));
-    if (err.stack) {
-      console.log(err.stack.replace(/^/gm, '  '));
-    }
+  runner.on(EVENT_TEST_FAIL, function (test, err) {
+    self._producer.writeFail(n, test, err);
   });
 
-  runner.on('end', function () {
-    console.log('# tests ' + (passes + failures));
-    console.log('# pass ' + passes);
-    console.log('# fail ' + failures);
+  runner.once(EVENT_RUN_END, function () {
+    self._producer.writeEpilogue(runner.stats);
   });
 }
 
 /**
- * Return a TAP-safe title of `test`
+ * Inherit from `Base.prototype`.
+ */
+inherits(TAP, Base);
+
+/**
+ * Returns a TAP-safe title of `test`.
  *
- * @api private
- * @param {Object} test
- * @return {String}
+ * @private
+ * @param {Test} test - Test instance.
+ * @return {String} title with any hash character removed
  */
-function title (test) {
+function title(test) {
   return test.fullTitle().replace(/#/g, '');
 }
+
+/**
+ * Writes newline-terminated formatted string to reporter output stream.
+ *
+ * @private
+ * @param {string} format - `printf`-like format string
+ * @param {...*} [varArgs] - Format string arguments
+ */
+function println(format, varArgs) {
+  var vargs = Array.from(arguments);
+  vargs[0] += '\n';
+  process.stdout.write(sprintf.apply(null, vargs));
+}
+
+/**
+ * Returns a `tapVersion`-appropriate TAP producer instance, if possible.
+ *
+ * @private
+ * @param {string} tapVersion - Version of TAP specification to produce.
+ * @returns {TAPProducer} specification-appropriate instance
+ * @throws {Error} if specification version has no associated producer.
+ */
+function createProducer(tapVersion) {
+  var producers = {
+    12: new TAP12Producer(),
+    13: new TAP13Producer()
+  };
+  var producer = producers[tapVersion];
+
+  if (!producer) {
+    throw new Error(
+      'invalid or unsupported TAP version: ' + JSON.stringify(tapVersion)
+    );
+  }
+
+  return producer;
+}
+
+/**
+ * @summary
+ * Constructs a new TAPProducer.
+ *
+ * @description
+ * <em>Only</em> to be used as an abstract base class.
+ *
+ * @private
+ * @constructor
+ */
+function TAPProducer() {}
+
+/**
+ * Writes the TAP version to reporter output stream.
+ *
+ * @abstract
+ */
+TAPProducer.prototype.writeVersion = function () {};
+
+/**
+ * Writes the plan to reporter output stream.
+ *
+ * @abstract
+ * @param {number} ntests - Number of tests that are planned to run.
+ */
+TAPProducer.prototype.writePlan = function (ntests) {
+  println('%d..%d', 1, ntests);
+};
+
+/**
+ * Writes that test passed to reporter output stream.
+ *
+ * @abstract
+ * @param {number} n - Index of test that passed.
+ * @param {Test} test - Instance containing test information.
+ */
+TAPProducer.prototype.writePass = function (n, test) {
+  println('ok %d %s', n, title(test));
+};
+
+/**
+ * Writes that test was skipped to reporter output stream.
+ *
+ * @abstract
+ * @param {number} n - Index of test that was skipped.
+ * @param {Test} test - Instance containing test information.
+ */
+TAPProducer.prototype.writePending = function (n, test) {
+  println('ok %d %s # SKIP -', n, title(test));
+};
+
+/**
+ * Writes that test failed to reporter output stream.
+ *
+ * @abstract
+ * @param {number} n - Index of test that failed.
+ * @param {Test} test - Instance containing test information.
+ * @param {Error} err - Reason the test failed.
+ */
+TAPProducer.prototype.writeFail = function (n, test, err) {
+  println('not ok %d %s', n, title(test));
+};
+
+/**
+ * Writes the summary epilogue to reporter output stream.
+ *
+ * @abstract
+ * @param {Object} stats - Object containing run statistics.
+ */
+TAPProducer.prototype.writeEpilogue = function (stats) {
+  // :TBD: Why is this not counting pending tests?
+  println('# tests ' + (stats.passes + stats.failures));
+  println('# pass ' + stats.passes);
+  // :TBD: Why are we not showing pending results?
+  println('# fail ' + stats.failures);
+  this.writePlan(stats.passes + stats.failures + stats.pending);
+};
+
+/**
+ * @summary
+ * Constructs a new TAP12Producer.
+ *
+ * @description
+ * Produces output conforming to the TAP12 specification.
+ *
+ * @private
+ * @constructor
+ * @extends TAPProducer
+ * @see {@link https://testanything.org/tap-specification.html|Specification}
+ */
+function TAP12Producer() {
+  /**
+   * Writes that test failed to reporter output stream, with error formatting.
+   * @override
+   */
+  this.writeFail = function (n, test, err) {
+    TAPProducer.prototype.writeFail.call(this, n, test, err);
+    if (err.message) {
+      println(err.message.replace(/^/gm, '  '));
+    }
+    if (err.stack) {
+      println(err.stack.replace(/^/gm, '  '));
+    }
+  };
+}
+
+/**
+ * Inherit from `TAPProducer.prototype`.
+ */
+inherits(TAP12Producer, TAPProducer);
+
+/**
+ * @summary
+ * Constructs a new TAP13Producer.
+ *
+ * @description
+ * Produces output conforming to the TAP13 specification.
+ *
+ * @private
+ * @constructor
+ * @extends TAPProducer
+ * @see {@link https://testanything.org/tap-version-13-specification.html|Specification}
+ */
+function TAP13Producer() {
+  /**
+   * Writes the TAP version to reporter output stream.
+   * @override
+   */
+  this.writeVersion = function () {
+    println('TAP version 13');
+  };
+
+  /**
+   * Writes that test failed to reporter output stream, with error formatting.
+   * @override
+   */
+  this.writeFail = function (n, test, err) {
+    TAPProducer.prototype.writeFail.call(this, n, test, err);
+    var emitYamlBlock = err.message != null || err.stack != null;
+    if (emitYamlBlock) {
+      println(indent(1) + '---');
+      if (err.message) {
+        println(indent(2) + 'message: |-');
+        println(err.message.replace(/^/gm, indent(3)));
+      }
+      if (err.stack) {
+        println(indent(2) + 'stack: |-');
+        println(err.stack.replace(/^/gm, indent(3)));
+      }
+      println(indent(1) + '...');
+    }
+  };
+
+  function indent(level) {
+    return Array(level + 1).join('  ');
+  }
+}
+
+/**
+ * Inherit from `TAPProducer.prototype`.
+ */
+inherits(TAP13Producer, TAPProducer);
+
+TAP.description = 'TAP-compatible output';

package/lib/reporters/xunit.js

@@ -1,28 +1,30 @@
 'use strict';
-
+/**
+ * @module XUnit
+ */
 /**
  * Module dependencies.
  */
 
 var Base = require('./base');
 var utils = require('../utils');
-var inherits = utils.inherits;
 var fs = require('fs');
-var escape = utils.escape;
-var mkdirp = require('mkdirp');
 var path = require('path');
+var errors = require('../errors');
+var createUnsupportedError = errors.createUnsupportedError;
+var constants = require('../runner').constants;
+var EVENT_TEST_PASS = constants.EVENT_TEST_PASS;
+var EVENT_TEST_FAIL = constants.EVENT_TEST_FAIL;
+var EVENT_RUN_END = constants.EVENT_RUN_END;
+var EVENT_TEST_PENDING = constants.EVENT_TEST_PENDING;
+var STATE_FAILED = require('../runnable').constants.STATE_FAILED;
+var inherits = utils.inherits;
+var escape = utils.escape;
 
 /**
  * Save timer references to avoid Sinon interfering (see GH-237).
  */
-
-/* eslint-disable no-unused-vars, no-native-reassign */
 var Date = global.Date;
-var setTimeout = global.setTimeout;
-var setInterval = global.setInterval;
-var clearTimeout = global.clearTimeout;
-var clearInterval = global.clearInterval;
-/* eslint-enable no-unused-vars, no-native-reassign */
 
 /**
  * Expose `XUnit`.
@@ -31,48 +33,75 @@ var clearInterval = global.clearInterval;
 exports = module.exports = XUnit;
 
 /**
- * Initialize a new `XUnit` reporter.
+ * Constructs a new `XUnit` reporter instance.
  *
- * @api public
- * @param {Runner} runner
+ * @public
+ * @class
+ * @memberof Mocha.reporters
+ * @extends Mocha.reporters.Base
+ * @param {Runner} runner - Instance triggers reporter actions.
+ * @param {Object} [options] - runner options
  */
-function XUnit (runner, options) {
-  Base.call(this, runner);
+function XUnit(runner, options) {
+  Base.call(this, runner, options);
 
   var stats = this.stats;
   var tests = [];
   var self = this;
 
-  if (options && options.reporterOptions && options.reporterOptions.output) {
-    if (!fs.createWriteStream) {
-      throw new Error('file output not supported in browser');
+  // the name of the test suite, as it will appear in the resulting XML file
+  var suiteName;
+
+  // the default name of the test suite if none is provided
+  var DEFAULT_SUITE_NAME = 'Mocha Tests';
+
+  if (options && options.reporterOptions) {
+    if (options.reporterOptions.output) {
+      if (!fs.createWriteStream) {
+        throw createUnsupportedError('file output not supported in browser');
+      }
+
+      fs.mkdirSync(path.dirname(options.reporterOptions.output), {
+        recursive: true
+      });
+      self.fileStream = fs.createWriteStream(options.reporterOptions.output);
     }
-    mkdirp.sync(path.dirname(options.reporterOptions.output));
-    self.fileStream = fs.createWriteStream(options.reporterOptions.output);
+
+    // get the suite name from the reporter options (if provided)
+    suiteName = options.reporterOptions.suiteName;
   }
 
-  runner.on('pending', function (test) {
+  // fall back to the default suite name
+  suiteName = suiteName || DEFAULT_SUITE_NAME;
+
+  runner.on(EVENT_TEST_PENDING, function (test) {
     tests.push(test);
   });
 
-  runner.on('pass', function (test) {
+  runner.on(EVENT_TEST_PASS, function (test) {
     tests.push(test);
   });
 
-  runner.on('fail', function (test) {
+  runner.on(EVENT_TEST_FAIL, function (test) {
     tests.push(test);
   });
 
-  runner.on('end', function () {
-    self.write(tag('testsuite', {
-      name: 'Mocha Tests',
-      tests: stats.tests,
-      failures: stats.failures,
-      errors: stats.failures,
-      skipped: stats.tests - stats.failures - stats.passes,
-      timestamp: (new Date()).toUTCString(),
-      time: (stats.duration / 1000) || 0
-    }, false));
+  runner.once(EVENT_RUN_END, function () {
+    self.write(
+      tag(
+        'testsuite',
+        {
+          name: suiteName,
+          tests: stats.tests,
+          failures: 0,
+          errors: stats.failures,
+          skipped: stats.tests - stats.failures - stats.passes,
+          timestamp: new Date().toUTCString(),
+          time: stats.duration / 1000 || 0
+        },
+        false
+      )
+    );
 
     tests.forEach(function (t) {
       self.test(t);
@@ -114,7 +143,7 @@ XUnit.prototype.write = function (line) {
   } else if (typeof process === 'object' && process.stdout) {
     process.stdout.write(line + '\n');
   } else {
-    console.log(line);
+    Base.consoleLog(line);
   }
 };
 
@@ -124,15 +153,34 @@ XUnit.prototype.write = function (line) {
  * @param {Test} test
  */
 XUnit.prototype.test = function (test) {
+  Base.useColors = false;
+
   var attrs = {
     classname: test.parent.fullTitle(),
     name: test.title,
-    time: (test.duration / 1000) || 0
+    file: test.file,
+    time: test.duration / 1000 || 0
   };
 
-  if (test.state === 'failed') {
+  if (test.state === STATE_FAILED) {
     var err = test.err;
-    this.write(tag('testcase', attrs, false, tag('failure', {}, false, escape(err.message) + '\n' + escape(err.stack))));
+    var diff =
+      !Base.hideDiff && Base.showDiff(err)
+        ? '\n' + Base.generateDiff(err.actual, err.expected)
+        : '';
+    this.write(
+      tag(
+        'testcase',
+        attrs,
+        false,
+        tag(
+          'failure',
+          {},
+          false,
+          escape(err.message) + escape(diff) + '\n' + escape(err.stack)
+        )
+      )
+    );
   } else if (test.isPending()) {
     this.write(tag('testcase', attrs, false, tag('skipped', {}, true)));
   } else {
@@ -149,7 +197,7 @@ XUnit.prototype.test = function (test) {
  * @param content
  * @return {string}
  */
-function tag (name, attrs, close, content) {
+function tag(name, attrs, close, content) {
   var end = close ? '/>' : '>';
   var pairs = [];
   var tag;
@@ -166,3 +214,5 @@ function tag (name, attrs, close, content) {
   }
   return tag;
 }
+
+XUnit.description = 'XUnit-compatible XML output';