mocha-compat 3.6.4 → 10.8.2

package/lib/reporters/base.js

@@ -1,14 +1,29 @@
 'use strict';
-
+/**
+ * @module Base
+ */
 /**
  * Module dependencies.
  */
 
-var tty = require('tty');
 var diff = require('diff');
-var ms = require('../ms');
+var milliseconds = require('ms');
 var utils = require('../utils');
-var supportsColor = process.browser ? null : require('supports-color');
+var supportsColor = require('supports-color');
+var symbols = require('log-symbols');
+var constants = require('../runner').constants;
+var EVENT_TEST_PASS = constants.EVENT_TEST_PASS;
+var EVENT_TEST_FAIL = constants.EVENT_TEST_FAIL;
+
+const isBrowser = utils.isBrowser();
+
+function getBrowserWindowSize() {
+  if ('innerHeight' in global) {
+    return [global.innerHeight, global.innerWidth];
+  }
+  // In a Web Worker, the DOM Window is not available.
+  return [640, 480];
+}
 
 /**
  * Expose `Base`.
@@ -17,29 +32,23 @@ var supportsColor = process.browser ? null : require('supports-color');
 exports = module.exports = Base;
 
 /**
- * Save timer references to avoid Sinon interfering.
- * See: https://github.com/mochajs/mocha/issues/237
+ * Check if both stdio streams are associated with a tty.
  */
 
-/* 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 */
+var isatty = isBrowser || (process.stdout.isTTY && process.stderr.isTTY);
 
 /**
- * Check if both stdio streams are associated with a tty.
+ * Save log references to avoid tests interfering (see GH-3604).
  */
-
-var isatty = tty.isatty(1) && tty.isatty(2);
+var consoleLog = console.log;
 
 /**
  * Enable coloring by default, except in the browser interface.
  */
 
-exports.useColors = !process.browser && (supportsColor || (process.env.MOCHA_COLORS !== undefined));
+exports.useColors =
+  !isBrowser &&
+  (supportsColor.stdout || process.env.MOCHA_COLORS !== undefined);
 
 /**
  * Inline diffs instead of +/-
@@ -47,6 +56,11 @@ exports.useColors = !process.browser && (supportsColor || (process.env.MOCHA_COL
 
 exports.inlineDiffs = false;
 
+/**
+ * Truncate diffs longer than this value to avoid slow performance
+ */
+exports.maxDiffSize = 8192;
+
 /**
  * Default color map.
  */
@@ -70,7 +84,9 @@ exports.colors = {
   light: 90,
   'diff gutter': 90,
   'diff added': 32,
-  'diff removed': 31
+  'diff removed': 31,
+  'diff added inline': '30;42',
+  'diff removed inline': '30;41'
 };
 
 /**
@@ -78,37 +94,30 @@ exports.colors = {
  */
 
 exports.symbols = {
-  ok: '✓',
-  err: '✖',
-  dot: '․',
+  ok: symbols.success,
+  err: symbols.error,
+  dot: '.',
   comma: ',',
   bang: '!'
 };
 
-// With node.js on Windows: use symbols available in terminal default fonts
-if (process.platform === 'win32') {
-  exports.symbols.ok = '\u221A';
-  exports.symbols.err = '\u00D7';
-  exports.symbols.dot = '.';
-}
-
 /**
  * Color `str` with the given `type`,
  * allowing colors to be disabled,
  * as well as user-defined color
  * schemes.
  *
+ * @private
  * @param {string} type
  * @param {string} str
  * @return {string}
- * @api private
  */
-var color = exports.color = function (type, str) {
+var color = (exports.color = function (type, str) {
   if (!exports.useColors) {
     return String(str);
   }
   return '\u001b[' + exports.colors[type] + 'm' + str + '\u001b[0m';
-};
+});
 
 /**
  * Expose term window size, with some defaults for when stderr is not a tty.
@@ -119,9 +128,11 @@ exports.window = {
 };
 
 if (isatty) {
-  exports.window.width = process.stdout.getWindowSize
-      ? process.stdout.getWindowSize(1)[0]
-      : tty.getWindowSize()[1];
+  if (isBrowser) {
+    exports.window.width = getBrowserWindowSize()[1];
+  } else {
+    exports.window.width = process.stdout.getWindowSize(1)[0];
+  }
 }
 
 /**
@@ -155,117 +166,207 @@ exports.cursor = {
   }
 };
 
+var showDiff = (exports.showDiff = function (err) {
+  return (
+    err &&
+    err.showDiff !== false &&
+    sameType(err.actual, err.expected) &&
+    err.expected !== undefined
+  );
+});
+
+function stringifyDiffObjs(err) {
+  if (!utils.isString(err.actual) || !utils.isString(err.expected)) {
+    err.actual = utils.stringify(err.actual);
+    err.expected = utils.stringify(err.expected);
+  }
+}
+
+/**
+ * Returns a diff between 2 strings with coloured ANSI output.
+ *
+ * @description
+ * The diff will be either inline or unified dependent on the value
+ * of `Base.inlineDiff`.
+ *
+ * @param {string} actual
+ * @param {string} expected
+ * @return {string} Diff
+ */
+
+var generateDiff = (exports.generateDiff = function (actual, expected) {
+  try {
+    var maxLen = exports.maxDiffSize;
+    var skipped = 0;
+    if (maxLen > 0) {
+      skipped = Math.max(actual.length - maxLen, expected.length - maxLen);
+      actual = actual.slice(0, maxLen);
+      expected = expected.slice(0, maxLen);
+    }
+    let result = exports.inlineDiffs
+      ? inlineDiff(actual, expected)
+      : unifiedDiff(actual, expected);
+    if (skipped > 0) {
+      result = `${result}\n      [mocha] output truncated to ${maxLen} characters, see "maxDiffSize" reporter-option\n`;
+    }
+    return result;
+  } catch (err) {
+    var msg =
+      '\n      ' +
+      color('diff added', '+ expected') +
+      ' ' +
+      color('diff removed', '- actual:  failed to generate Mocha diff') +
+      '\n';
+    return msg;
+  }
+});
+
 /**
- * Output the given `failures` as a list.
+ * Traverses err.cause and returns all stack traces
  *
- * @param {Array} failures
- * @api public
+ * @private
+ * @param {Error} err
+ * @param {Set<Error>} [seen]
+ * @return {FullErrorStack}
  */
+var getFullErrorStack = function (err, seen) {
+  if (seen && seen.has(err)) {
+    return { message: '', msg: '<circular>', stack: '' };
+  }
+
+  var message;
+
+  if (typeof err.inspect === 'function') {
+    message = err.inspect() + '';
+  } else if (err.message && typeof err.message.toString === 'function') {
+    message = err.message + '';
+  } else {
+    message = '';
+  }
 
+  var msg;
+  var stack = err.stack || message;
+  var index = message ? stack.indexOf(message) : -1;
+
+  if (index === -1) {
+    msg = message;
+  } else {
+    index += message.length;
+    msg = stack.slice(0, index);
+    // remove msg from stack
+    stack = stack.slice(index + 1);
+
+    if (err.cause) {
+      seen = seen || new Set();
+      seen.add(err);
+      const causeStack = getFullErrorStack(err.cause, seen)
+      stack += '\n   Caused by: ' + causeStack.msg + (causeStack.stack ? '\n' + causeStack.stack : '');
+    }
+  }
+
+  return {
+    message,
+    msg,
+    stack
+  };
+};
+
+/**
+ * Outputs the given `failures` as a list.
+ *
+ * @public
+ * @memberof Mocha.reporters.Base
+ * @variation 1
+ * @param {Object[]} failures - Each is Test instance with corresponding
+ *     Error property
+ */
 exports.list = function (failures) {
-  console.log();
+  var multipleErr, multipleTest;
+  Base.consoleLog();
   failures.forEach(function (test, i) {
     // format
-    var fmt = color('error title', '  %s) %s:\n') +
+    var fmt =
+      color('error title', '  %s) %s:\n') +
       color('error message', '     %s') +
       color('error stack', '\n%s\n');
 
     // msg
-    var msg;
-    var err = test.err;
-    var message;
-    if (err.message && typeof err.message.toString === 'function') {
-      message = err.message + '';
-    } else if (typeof err.inspect === 'function') {
-      message = err.inspect() + '';
-    } else {
-      message = '';
-    }
-    var stack = err.stack || message;
-    var index = message ? stack.indexOf(message) : -1;
-    var actual = err.actual;
-    var expected = err.expected;
-    var escape = true;
-
-    if (index === -1) {
-      msg = message;
+    var err;
+    if (test.err && test.err.multiple) {
+      if (multipleTest !== test) {
+        multipleTest = test;
+        multipleErr = [test.err].concat(test.err.multiple);
+      }
+      err = multipleErr.shift();
     } else {
-      index += message.length;
-      msg = stack.slice(0, index);
-      // remove msg from stack
-      stack = stack.slice(index + 1);
+      err = test.err;
     }
 
+    var { message, msg, stack } = getFullErrorStack(err);
+
     // uncaught
     if (err.uncaught) {
       msg = 'Uncaught ' + msg;
     }
     // explicitly show diff
-    if (err.showDiff !== false && sameType(actual, expected) && expected !== undefined) {
-      escape = false;
-      if (!(utils.isString(actual) && utils.isString(expected))) {
-        err.actual = actual = utils.stringify(actual);
-        err.expected = expected = utils.stringify(expected);
-      }
-
-      fmt = color('error title', '  %s) %s:\n%s') + color('error stack', '\n%s\n');
+    if (!exports.hideDiff && showDiff(err)) {
+      stringifyDiffObjs(err);
+      fmt =
+        color('error title', '  %s) %s:\n%s') + color('error stack', '\n%s\n');
       var match = message.match(/^([^:]+): expected/);
       msg = '\n      ' + color('error message', match ? match[1] : msg);
 
-      if (exports.inlineDiffs) {
-        msg += inlineDiff(err, escape);
-      } else {
-        msg += unifiedDiff(err, escape);
-      }
+      msg += generateDiff(err.actual, err.expected);
     }
 
     // indent stack trace
     stack = stack.replace(/^/gm, '  ');
 
-    console.log(fmt, (i + 1), test.fullTitle(), msg, stack);
+    // indented test title
+    var testTitle = '';
+    test.titlePath().forEach(function (str, index) {
+      if (index !== 0) {
+        testTitle += '\n     ';
+      }
+      for (var i = 0; i < index; i++) {
+        testTitle += '  ';
+      }
+      testTitle += str;
+    });
+
+    Base.consoleLog(fmt, i + 1, testTitle, msg, stack);
   });
 };
 
 /**
- * Initialize a new `Base` reporter.
+ * Constructs a new `Base` reporter instance.
  *
- * All other reporters generally
- * inherit from this reporter, providing
- * stats such as test duration, number
- * of tests passed / failed etc.
+ * @description
+ * All other reporters generally inherit from this reporter.
  *
- * @param {Runner} runner
- * @api public
+ * @public
+ * @class
+ * @memberof Mocha.reporters
+ * @param {Runner} runner - Instance triggers reporter actions.
+ * @param {Object} [options] - runner options
  */
-
-function Base (runner) {
-  var stats = this.stats = { suites: 0, tests: 0, passes: 0, pending: 0, failures: 0 };
-  var failures = this.failures = [];
+function Base(runner, options) {
+  var failures = (this.failures = []);
 
   if (!runner) {
-    return;
+    throw new TypeError('Missing runner argument');
   }
+  this.options = options || {};
   this.runner = runner;
+  this.stats = runner.stats; // assigned so Reporters keep a closer reference
 
-  runner.stats = stats;
-
-  runner.on('start', function () {
-    stats.start = new Date();
-  });
-
-  runner.on('suite', function (suite) {
-    stats.suites = stats.suites || 0;
-    suite.root || stats.suites++;
-  });
-
-  runner.on('test end', function () {
-    stats.tests = stats.tests || 0;
-    stats.tests++;
-  });
-
-  runner.on('pass', function (test) {
-    stats.passes = stats.passes || 0;
+  var maxDiffSizeOpt =
+    this.options.reporterOption && this.options.reporterOption.maxDiffSize;
+  if (maxDiffSizeOpt !== undefined && !isNaN(Number(maxDiffSizeOpt))) {
+    exports.maxDiffSize = Number(maxDiffSizeOpt);
+  }
 
+  runner.on(EVENT_TEST_PASS, function (test) {
     if (test.duration > test.slow()) {
       test.speed = 'slow';
     } else if (test.duration > test.slow() / 2) {
@@ -273,107 +374,103 @@ function Base (runner) {
     } else {
       test.speed = 'fast';
     }
-
-    stats.passes++;
   });
 
-  runner.on('fail', function (test, err) {
-    stats.failures = stats.failures || 0;
-    stats.failures++;
-    test.err = err;
+  runner.on(EVENT_TEST_FAIL, function (test, err) {
+    if (showDiff(err)) {
+      stringifyDiffObjs(err);
+    }
+    // more than one error per test
+    if (test.err && err instanceof Error) {
+      test.err.multiple = (test.err.multiple || []).concat(err);
+    } else {
+      test.err = err;
+    }
     failures.push(test);
   });
-
-  runner.on('end', function () {
-    stats.end = new Date();
-    stats.duration = new Date() - stats.start;
-  });
-
-  runner.on('pending', function () {
-    stats.pending++;
-  });
 }
 
 /**
- * Output common epilogue used by many of
- * the bundled reporters.
+ * Outputs common epilogue used by many of the bundled reporters.
  *
- * @api public
+ * @public
+ * @memberof Mocha.reporters
  */
 Base.prototype.epilogue = function () {
   var stats = this.stats;
   var fmt;
 
-  console.log();
+  Base.consoleLog();
 
   // passes
-  fmt = color('bright pass', ' ') +
+  fmt =
+    color('bright pass', ' ') +
     color('green', ' %d passing') +
     color('light', ' (%s)');
 
-  console.log(fmt,
-    stats.passes || 0,
-    ms(stats.duration));
+  Base.consoleLog(fmt, stats.passes || 0, milliseconds(stats.duration));
 
   // pending
   if (stats.pending) {
-    fmt = color('pending', ' ') +
-      color('pending', ' %d pending');
+    fmt = color('pending', ' ') + color('pending', ' %d pending');
 
-    console.log(fmt, stats.pending);
+    Base.consoleLog(fmt, stats.pending);
   }
 
   // failures
   if (stats.failures) {
     fmt = color('fail', '  %d failing');
 
-    console.log(fmt, stats.failures);
+    Base.consoleLog(fmt, stats.failures);
 
     Base.list(this.failures);
-    console.log();
+    Base.consoleLog();
   }
 
-  console.log();
+  Base.consoleLog();
 };
 
 /**
- * Pad the given `str` to `len`.
+ * Pads the given `str` to `len`.
  *
- * @api private
+ * @private
  * @param {string} str
  * @param {string} len
  * @return {string}
  */
-function pad (str, len) {
+function pad(str, len) {
   str = String(str);
   return Array(len - str.length + 1).join(' ') + str;
 }
 
 /**
- * Returns an inline diff between 2 strings with coloured ANSI output
+ * Returns inline diff between 2 strings with coloured ANSI output.
  *
- * @api private
- * @param {Error} err with actual/expected
- * @param {boolean} escape
+ * @private
+ * @param {String} actual
+ * @param {String} expected
  * @return {string} Diff
  */
-function inlineDiff (err, escape) {
-  var msg = errorDiff(err, 'WordsWithSpace', escape);
+function inlineDiff(actual, expected) {
+  var msg = errorDiff(actual, expected);
 
   // linenos
   var lines = msg.split('\n');
   if (lines.length > 4) {
     var width = String(lines.length).length;
-    msg = lines.map(function (str, i) {
-      return pad(++i, width) + ' |' + ' ' + str;
-    }).join('\n');
+    msg = lines
+      .map(function (str, i) {
+        return pad(++i, width) + ' |' + ' ' + str;
+      })
+      .join('\n');
   }
 
   // legend
-  msg = '\n' +
-    color('diff removed', 'actual') +
+  msg =
+    '\n' +
+    color('diff removed inline', 'actual') +
     ' ' +
-    color('diff added', 'expected') +
+    color('diff added inline', 'expected') +
     '\n\n' +
     msg +
     '\n';
@@ -384,19 +481,16 @@ function inlineDiff (err, escape) {
 }
 
 /**
- * Returns a unified diff between two strings.
+ * Returns unified diff between two strings with coloured ANSI output.
  *
- * @api private
- * @param {Error} err with actual/expected
- * @param {boolean} escape
+ * @private
+ * @param {String} actual
+ * @param {String} expected
  * @return {string} The diff.
  */
-function unifiedDiff (err, escape) {
+function unifiedDiff(actual, expected) {
   var indent = '      ';
-  function cleanUp (line) {
-    if (escape) {
-      line = escapeInvisibles(line);
-    }
+  function cleanUp(line) {
     if (line[0] === '+') {
       return indent + colorLines('diff added', line);
     }
@@ -404,73 +498,66 @@ function unifiedDiff (err, escape) {
       return indent + colorLines('diff removed', line);
     }
     if (line.match(/@@/)) {
-      return null;
+      return '--';
     }
     if (line.match(/\\ No newline/)) {
       return null;
     }
     return indent + line;
   }
-  function notBlank (line) {
+  function notBlank(line) {
     return typeof line !== 'undefined' && line !== null;
   }
-  var msg = diff.createPatch('string', err.actual, err.expected);
-  var lines = msg.split('\n').splice(4);
-  return '\n      ' +
-    colorLines('diff added', '+ expected') + ' ' +
+  var msg = diff.createPatch('string', actual, expected);
+  var lines = msg.split('\n').splice(5);
+  return (
+    '\n      ' +
+    colorLines('diff added', '+ expected') +
+    ' ' +
     colorLines('diff removed', '- actual') +
     '\n\n' +
-    lines.map(cleanUp).filter(notBlank).join('\n');
-}
-
-/**
- * Return a character diff for `err`.
- *
- * @api private
- * @param {Error} err
- * @param {string} type
- * @param {boolean} escape
- * @return {string}
- */
-function errorDiff (err, type, escape) {
-  var actual = escape ? escapeInvisibles(err.actual) : err.actual;
-  var expected = escape ? escapeInvisibles(err.expected) : err.expected;
-  return diff['diff' + type](actual, expected).map(function (str) {
-    if (str.added) {
-      return colorLines('diff added', str.value);
-    }
-    if (str.removed) {
-      return colorLines('diff removed', str.value);
-    }
-    return str.value;
-  }).join('');
+    lines.map(cleanUp).filter(notBlank).join('\n')
+  );
 }
 
 /**
- * Returns a string with all invisible characters in plain text
+ * Returns character diff for `err`.
  *
- * @api private
- * @param {string} line
- * @return {string}
+ * @private
+ * @param {String} actual
+ * @param {String} expected
+ * @return {string} the diff
  */
-function escapeInvisibles (line) {
-  return line.replace(/\t/g, '<tab>')
-    .replace(/\r/g, '<CR>')
-    .replace(/\n/g, '<LF>\n');
+function errorDiff(actual, expected) {
+  return diff
+    .diffWordsWithSpace(actual, expected)
+    .map(function (str) {
+      if (str.added) {
+        return colorLines('diff added inline', str.value);
+      }
+      if (str.removed) {
+        return colorLines('diff removed inline', str.value);
+      }
+      return str.value;
+    })
+    .join('');
 }
 
 /**
- * Color lines for `str`, using the color `name`.
+ * Colors lines for `str`, using the color `name`.
  *
- * @api private
+ * @private
  * @param {string} name
  * @param {string} str
  * @return {string}
  */
-function colorLines (name, str) {
-  return str.split('\n').map(function (str) {
-    return color(name, str);
-  }).join('\n');
+function colorLines(name, str) {
+  return str
+    .split('\n')
+    .map(function (str) {
+      return color(name, str);
+    })
+    .join('\n');
 }
 
 /**
@@ -479,13 +566,26 @@ function colorLines (name, str) {
 var objToString = Object.prototype.toString;
 
 /**
- * Check that a / b have the same type.
+ * Checks that a / b have the same type.
  *
- * @api private
+ * @private
  * @param {Object} a
  * @param {Object} b
  * @return {boolean}
  */
-function sameType (a, b) {
+function sameType(a, b) {
   return objToString.call(a) === objToString.call(b);
 }
+
+Base.consoleLog = consoleLog;
+
+Base.abstract = true;
+
+/**
+ * An object with all stack traces recursively mounted from each err.cause
+ * @memberof module:lib/reporters/base
+ * @typedef {Object} FullErrorStack
+ * @property {string} message
+ * @property {string} msg
+ * @property {string} stack
+ */