mocha 6.1.4 → 6.2.0

package/CHANGELOG.md

@@ -1,3 +1,43 @@
+# 6.2.0 / 2019-07-18
+
+## :tada: Enhancements
+
+- [#3827](https://github.com/mochajs/mocha/issues/3827): Do not fork child-process if no Node flags are present ([**@boneskull**](https://github.com/boneskull))
+- [#3725](https://github.com/mochajs/mocha/issues/3725): Base reporter store ref to console.log, see [mocha/wiki](https://github.com/mochajs/mocha/wiki/HOW-TO:-Correctly-stub-stdout) ([**@craigtaub**](https://github.com/craigtaub))
+
+## :bug: Fixes
+
+- [#3942](https://github.com/mochajs/mocha/issues/3942): Fix "No test files found" Error when file is passed via `--file` ([**@gabegorelick**](https://github.com/gabegorelick))
+- [#3914](https://github.com/mochajs/mocha/issues/3914): Modify Mocha constructor to accept options `global` or `globals` ([**@pascalpp**](https://github.com/pascalpp))
+- [#3894](https://github.com/mochajs/mocha/issues/3894): Fix parsing of config files with `_mocha` binary ([**@juergba**](https://github.com/juergba))
+- [#3834](https://github.com/mochajs/mocha/issues/3834): Fix CLI parsing with default values ([**@boneskull**](https://github.com/boneskull), [**@juergba**](https://github.com/juergba))
+- [#3831](https://github.com/mochajs/mocha/issues/3831): Fix `--timeout`/`--slow` string values and duplicate arguments ([**@boneskull**](https://github.com/boneskull), [**@juergba**](https://github.com/juergba))
+
+## :book: Documentation
+
+- [#3906](https://github.com/mochajs/mocha/issues/3906): Document option to define custom report name for XUnit reporter ([**@pkuczynski**](https://github.com/pkuczynski))
+- [#3889](https://github.com/mochajs/mocha/issues/3889): Adds doc links for mocha-examples ([**@craigtaub**](https://github.com/craigtaub))
+- [#3887](https://github.com/mochajs/mocha/issues/3887): Fix broken links ([**@toyjhlee**](https://github.com/toyjhlee))
+- [#3841](https://github.com/mochajs/mocha/issues/3841): Fix anchors to configuration section ([**@trescube**](https://github.com/trescube))
+
+## :mag: Coverage
+
+- [#3915](https://github.com/mochajs/mocha/issues/3915), [#3929](https://github.com/mochajs/mocha/issues/3929): Increase tests coverage for `--watch` options ([**@geigerzaehler**](https://github.com/geigerzaehler))
+
+## :nut_and_bolt: Other
+
+- [#3953](https://github.com/mochajs/mocha/issues/3953): Collect test files later, prepares improvements to the `--watch` mode behavior ([**@geigerzaehler**](https://github.com/geigerzaehler))
+- [#3939](https://github.com/mochajs/mocha/issues/3939): Upgrade for npm audit ([**@boneskull**](https://github.com/boneskull))
+- [#3930](https://github.com/mochajs/mocha/issues/3930): Extract `runWatch` into separate module ([**@geigerzaehler**](https://github.com/geigerzaehler))
+- [#3922](https://github.com/mochajs/mocha/issues/3922): Add `mocha.min.js` file to stacktrace filter ([**@brian-lagerman**](https://github.com/brian-lagerman))
+- [#3919](https://github.com/mochajs/mocha/issues/3919): Update CI config files to use Node-12.x ([**@plroebuck**](https://github.com/plroebuck))
+- [#3892](https://github.com/mochajs/mocha/issues/3892): Rework reporter tests ([**@plroebuck**](https://github.com/plroebuck))
+- [#3872](https://github.com/mochajs/mocha/issues/3872): Rename `--exclude` to `--ignore` and create alias ([**@boneskull**](https://github.com/boneskull))
+- [#3963](https://github.com/mochajs/mocha/issues/3963): Hide stacktrace when cli args are missing ([**@outsideris**](https://github.com/outsideris))
+- [#3956](https://github.com/mochajs/mocha/issues/3956): Do not redeclare variable in docs array example ([**@DanielRuf**](https://github.com/DanielRuf))
+- [#3957](https://github.com/mochajs/mocha/issues/3957): Remove duplicate line-height property in `mocha.css` ([**@DanielRuf**](https://github.com/DanielRuf))
+- [#3960](https://github.com/mochajs/mocha/issues/3960): Don't re-initialize grep option on watch re-run ([**@geigerzaehler**](https://github.com/geigerzaehler))
+
 # 6.1.4 / 2019-04-18
 
 ## :lock: Security Fixes

package/bin/mocha

@@ -3,14 +3,14 @@
 'use strict';
 
 /**
- * This wrapper executable checks for known node flags and appends them when found, before invoking the "real" _mocha(1) executable.
+ * This wrapper executable checks for known node flags and appends them when found,
+ * before invoking the "real" executable (`lib/cli/cli.js`)
  *
  * @module bin/mocha
  * @private
  */
 
 const {deprecate, warn} = require('../lib/utils');
-const {spawn} = require('child_process');
 const {loadOptions} = require('../lib/cli/options');
 const {
   unparseNodeFlags,
@@ -22,7 +22,6 @@ const debug = require('debug')('mocha:cli:mocha');
 const {aliases} = require('../lib/cli/run-option-metadata');
 const nodeEnv = require('node-environment-flags');
 
-const mochaPath = require.resolve('./_mocha');
 const mochaArgs = {};
 const nodeArgs = {};
 
@@ -118,32 +117,39 @@ if (nodeArgs.gc) {
   delete nodeArgs.gc;
 }
 
-debug('final node args', nodeArgs);
+if (Object.keys(nodeArgs).length) {
+  const {spawn} = require('child_process');
+  const mochaPath = require.resolve('../lib/cli/cli.js');
 
-const args = [].concat(
-  unparseNodeFlags(nodeArgs),
-  mochaPath,
-  unparse(mochaArgs, {alias: aliases})
-);
+  debug('final node args', nodeArgs);
 
-debug(`exec ${process.execPath} w/ args:`, args);
+  const args = [].concat(
+    unparseNodeFlags(nodeArgs),
+    mochaPath,
+    unparse(mochaArgs, {alias: aliases})
+  );
 
-const proc = spawn(process.execPath, args, {
-  stdio: 'inherit'
-});
+  debug(`exec ${process.execPath} w/ args:`, args);
 
-proc.on('exit', (code, signal) => {
-  process.on('exit', () => {
-    if (signal) {
-      process.kill(process.pid, signal);
-    } else {
-      process.exit(code);
-    }
+  const proc = spawn(process.execPath, args, {
+    stdio: 'inherit'
   });
-});
 
-// terminate children.
-process.on('SIGINT', () => {
-  proc.kill('SIGINT'); // calls runner.abort()
-  proc.kill('SIGTERM'); // if that didn't work, we're probably in an infinite loop, so make it die.
-});
+  proc.on('exit', (code, signal) => {
+    process.on('exit', () => {
+      if (signal) {
+        process.kill(process.pid, signal);
+      } else {
+        process.exit(code);
+      }
+    });
+  });
+
+  // terminate children.
+  process.on('SIGINT', () => {
+    proc.kill('SIGINT'); // calls runner.abort()
+    proc.kill('SIGTERM'); // if that didn't work, we're probably in an infinite loop, so make it die.
+  });
+} else {
+  require('../lib/cli/cli').main(unparse(mochaArgs, {alias: aliases}));
+}

package/lib/cli/cli.js

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 'use strict';
 
 /**
@@ -32,6 +34,8 @@ exports.main = (argv = process.argv.slice(2)) => {
 
   Error.stackTraceLimit = Infinity; // configurable via --stack-trace-limit?
 
+  var args = loadOptions(argv);
+
   yargs()
     .scriptName('mocha')
     .command(commands.run)
@@ -60,7 +64,8 @@ exports.main = (argv = process.argv.slice(2)) => {
       `
     )
     .parserConfiguration(YARGS_PARSER_CONFIG)
-    .parse(argv, loadOptions(argv));
+    .config(args)
+    .parse(args._);
 };
 
 // allow direct execution

package/lib/cli/collect-files.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const path = require('path');
+const ansi = require('ansi-colors');
+const debug = require('debug')('mocha:cli:run:helpers');
+const minimatch = require('minimatch');
+const utils = require('../utils');
+
+/**
+ * Exports a function that collects test files from CLI parameters.
+ * @see module:lib/cli/run-helpers
+ * @see module:lib/cli/watch-run
+ * @module
+ * @private
+ */
+
+/**
+ * Smash together an array of test files in the correct order
+ * @param {Object} opts - Options
+ * @param {string[]} opts.extension - File extensions to use
+ * @param {string[]} opts.spec - Files, dirs, globs to run
+ * @param {string[]} opts.ignore - Files, dirs, globs to ignore
+ * @param {string[]} opts.file - List of additional files to include
+ * @param {boolean} opts.recursive - Find files recursively
+ * @param {boolean} opts.sort - Sort test files
+ * @returns {string[]} List of files to test
+ * @private
+ */
+module.exports = ({ignore, extension, file, recursive, sort, spec} = {}) => {
+  let files = [];
+  const unmatched = [];
+  spec.forEach(arg => {
+    let newFiles;
+    try {
+      newFiles = utils.lookupFiles(arg, extension, recursive);
+    } catch (err) {
+      if (err.code === 'ERR_MOCHA_NO_FILES_MATCH_PATTERN') {
+        unmatched.push({message: err.message, pattern: err.pattern});
+        return;
+      }
+
+      throw err;
+    }
+
+    if (typeof newFiles !== 'undefined') {
+      if (typeof newFiles === 'string') {
+        newFiles = [newFiles];
+      }
+      newFiles = newFiles.filter(fileName =>
+        ignore.every(pattern => !minimatch(fileName, pattern))
+      );
+    }
+
+    files = files.concat(newFiles);
+  });
+
+  const fileArgs = file.map(filepath => path.resolve(filepath));
+  files = files.map(filepath => path.resolve(filepath));
+
+  // ensure we don't sort the stuff from fileArgs; order is important!
+  if (sort) {
+    files.sort();
+  }
+
+  // add files given through --file to be ran first
+  files = fileArgs.concat(files);
+  debug('files (in order): ', files);
+
+  if (!files.length) {
+    // give full message details when only 1 file is missing
+    const noneFoundMsg =
+      unmatched.length === 1
+        ? `Error: No test files found: ${JSON.stringify(unmatched[0].pattern)}` // stringify to print escaped characters raw
+        : 'Error: No test files found';
+    console.error(ansi.red(noneFoundMsg));
+    process.exit(1);
+  } else {
+    // print messages as an warning
+    unmatched.forEach(warning => {
+      console.warn(ansi.yellow(`Warning: ${warning.message}`));
+    });
+  }
+
+  return files;
+};

package/lib/cli/options.js

@@ -7,6 +7,7 @@
  */
 
 const fs = require('fs');
+const ansi = require('ansi-colors');
 const yargsParser = require('yargs-parser');
 const {types, aliases} = require('./run-option-metadata');
 const {ONE_AND_DONE_ARGS} = require('./one-and-dones');
@@ -16,7 +17,6 @@ const {loadConfig, findConfig} = require('./config');
 const findUp = require('find-up');
 const {deprecate} = require('../utils');
 const debug = require('debug')('mocha:cli:options');
-const {createMissingArgumentError} = require('../errors');
 const {isNodeFlag} = require('./node-flags');
 
 /**
@@ -54,15 +54,26 @@ const configuration = Object.assign({}, YARGS_PARSER_CONFIG, {
 });
 
 /**
- * This is a really fancy way to ensure unique values for `array`-type
- * options.
+ * This is a really fancy way to:
+ * - ensure unique values for `array`-type options
+ * - use its array's last element for `boolean`/`number`/`string`- options given multiple times
  * This is passed as the `coerce` option to `yargs-parser`
  * @private
  * @ignore
  */
-const coerceOpts = types.array.reduce(
-  (acc, arg) => Object.assign(acc, {[arg]: v => Array.from(new Set(list(v)))}),
-  {}
+const coerceOpts = Object.assign(
+  types.array.reduce(
+    (acc, arg) =>
+      Object.assign(acc, {[arg]: v => Array.from(new Set(list(v)))}),
+    {}
+  ),
+  types.boolean
+    .concat(types.string, types.number)
+    .reduce(
+      (acc, arg) =>
+        Object.assign(acc, {[arg]: v => (Array.isArray(v) ? v.pop() : v)}),
+      {}
+    )
 );
 
 /**
@@ -80,11 +91,12 @@ const nargOpts = types.array
 /**
  * Wrapper around `yargs-parser` which applies our settings
  * @param {string|string[]} args - Arguments to parse
+ * @param {Object} defaultValues - Default values of mocharc.json
  * @param  {...Object} configObjects - `configObjects` for yargs-parser
  * @private
  * @ignore
  */
-const parse = (args = [], ...configObjects) => {
+const parse = (args = [], defaultValues = {}, ...configObjects) => {
   // save node-specific args for special handling.
   // 1. when these args have a "=" they should be considered to have values
   // 2. if they don't, they just boolean flags
@@ -109,6 +121,7 @@ const parse = (args = [], ...configObjects) => {
   const result = yargsParser.detailed(args, {
     configuration,
     configObjects,
+    default: defaultValues,
     coerce: coerceOpts,
     narg: nargOpts,
     alias: aliases,
@@ -118,7 +131,8 @@ const parse = (args = [], ...configObjects) => {
     boolean: types.boolean.concat(nodeArgs.map(pair => pair[0]))
   });
   if (result.error) {
-    throw createMissingArgumentError(result.error.message);
+    console.error(ansi.red(`Error: ${result.error.message}`));
+    process.exit(1);
   }
 
   // reapply "=" arg values from above
@@ -324,11 +338,11 @@ const loadOptions = (argv = []) => {
 
   args = parse(
     args._,
+    mocharc,
     args,
     rcConfig || {},
     pkgConfig || {},
-    optsConfig || {},
-    mocharc
+    optsConfig || {}
   );
 
   // recombine positional arguments and "spec"

package/lib/cli/run-helpers.js

@@ -9,15 +9,14 @@
 
 const fs = require('fs');
 const path = require('path');
-const ansi = require('ansi-colors');
 const debug = require('debug')('mocha:cli:run:helpers');
-const minimatch = require('minimatch');
-const Context = require('../context');
-const Mocha = require('../mocha');
-const utils = require('../utils');
+const watchRun = require('./watch-run');
+const collectFiles = require('./collect-files');
 
 const cwd = (exports.cwd = process.cwd());
 
+exports.watchRun = watchRun;
+
 /**
  * Exits Mocha when tests + code under test has finished execution (default)
  * @param {number} code - Exit code; typically # of failures
@@ -65,32 +64,6 @@ const exitMocha = code => {
   done();
 };
 
-/**
- * Hide the cursor.
- * @ignore
- * @private
- */
-const hideCursor = () => {
-  process.stdout.write('\u001b[?25l');
-};
-
-/**
- * Show the cursor.
- * @ignore
- * @private
- */
-const showCursor = () => {
-  process.stdout.write('\u001b[?25h');
-};
-
-/**
- * Stop cursor business
- * @private
- */
-const stop = () => {
-  process.stdout.write('\u001b[2K');
-};
-
 /**
  * Coerce a comma-delimited string (or array thereof) into a flattened array of
  * strings
@@ -119,185 +92,54 @@ exports.handleRequires = (requires = []) => {
 };
 
 /**
- * Smash together an array of test files in the correct order
- * @param {Object} [opts] - Options
- * @param {string[]} [opts.extension] - File extensions to use
- * @param {string[]} [opts.spec] - Files, dirs, globs to run
- * @param {string[]} [opts.exclude] - Files, dirs, globs to exclude
- * @param {boolean} [opts.recursive=false] - Find files recursively
- * @param {boolean} [opts.sort=false] - Sort test files
- * @returns {string[]} List of files to test
- * @private
- */
-exports.handleFiles = ({
-  exclude = [],
-  extension = [],
-  file = [],
-  recursive = false,
-  sort = false,
-  spec = []
-} = {}) => {
-  let files = [];
-  const unmatched = [];
-  spec.forEach(arg => {
-    let newFiles;
-    try {
-      newFiles = utils.lookupFiles(arg, extension, recursive);
-    } catch (err) {
-      if (err.code === 'ERR_MOCHA_NO_FILES_MATCH_PATTERN') {
-        unmatched.push({message: err.message, pattern: err.pattern});
-        return;
-      }
-
-      throw err;
-    }
-
-    if (typeof newFiles !== 'undefined') {
-      if (typeof newFiles === 'string') {
-        newFiles = [newFiles];
-      }
-      newFiles = newFiles.filter(fileName =>
-        exclude.every(pattern => !minimatch(fileName, pattern))
-      );
-    }
-
-    files = files.concat(newFiles);
-  });
-
-  if (!files.length) {
-    // give full message details when only 1 file is missing
-    const noneFoundMsg =
-      unmatched.length === 1
-        ? `Error: No test files found: ${JSON.stringify(unmatched[0].pattern)}` // stringify to print escaped characters raw
-        : 'Error: No test files found';
-    console.error(ansi.red(noneFoundMsg));
-    process.exit(1);
-  } else {
-    // print messages as an warning
-    unmatched.forEach(warning => {
-      console.warn(ansi.yellow(`Warning: ${warning.message}`));
-    });
-  }
-
-  const fileArgs = file.map(filepath => path.resolve(filepath));
-  files = files.map(filepath => path.resolve(filepath));
-
-  // ensure we don't sort the stuff from fileArgs; order is important!
-  if (sort) {
-    files.sort();
-  }
-
-  // add files given through --file to be ran first
-  files = fileArgs.concat(files);
-  debug('files (in order): ', files);
-  return files;
-};
-
-/**
- * Give Mocha files and tell it to run
+ * Collect test files and run mocha instance.
  * @param {Mocha} mocha - Mocha instance
- * @param {Options} [opts] - Options
- * @param {string[]} [opts.files] - List of test files
+ * @param {Options} [opts] - Command line options
  * @param {boolean} [opts.exit] - Whether or not to force-exit after tests are complete
+ * @param {Object} fileCollectParams - Parameters that control test
+ *   file collection. See `lib/cli/collect-files.js`.
  * @returns {Runner}
  * @private
  */
-exports.singleRun = (mocha, {files = [], exit = false} = {}) => {
+exports.singleRun = (mocha, {exit}, fileCollectParams) => {
+  const files = collectFiles(fileCollectParams);
+  debug('running tests with files', files);
   mocha.files = files;
   return mocha.run(exit ? exitMocha : exitMochaLater);
 };
 
 /**
- * Run Mocha in "watch" mode
+ * Actually run tests
  * @param {Mocha} mocha - Mocha instance
- * @param {Object} [opts] - Options
- * @param {string[]} [opts.extension] - List of extensions to watch
- * @param {string|RegExp} [opts.grep] - Grep for test titles
- * @param {string} [opts.ui=bdd] - User interface
- * @param {string[]} [files] - Array of test files
+ * @param {Object} opts - Command line options
  * @private
  */
-exports.watchRun = (
-  mocha,
-  {extension = ['js'], grep = '', ui = 'bdd', files = []} = {}
-) => {
-  let runner;
-
-  console.log();
-  hideCursor();
-  process.on('SIGINT', () => {
-    showCursor();
-    console.log('\n');
-    process.exit(130);
-  });
-
-  const watchFiles = utils.files(cwd, extension);
-  let runAgain = false;
-
-  const loadAndRun = () => {
-    try {
-      mocha.files = files;
-      runAgain = false;
-      runner = mocha.run(() => {
-        runner = null;
-        if (runAgain) {
-          rerun();
-        }
-      });
-    } catch (e) {
-      console.log(e.stack);
-    }
+exports.runMocha = (mocha, options) => {
+  const {
+    watch = false,
+    extension = [],
+    ui = 'bdd',
+    exit = false,
+    ignore = [],
+    file = [],
+    recursive = false,
+    sort = false,
+    spec = []
+  } = options;
+
+  const fileCollectParams = {
+    ignore,
+    extension,
+    file,
+    recursive,
+    sort,
+    spec
   };
 
-  const purge = () => {
-    watchFiles.forEach(Mocha.unloadFile);
-  };
-
-  loadAndRun();
-
-  const rerun = () => {
-    purge();
-    stop();
-    if (!grep) {
-      mocha.grep(null);
-    }
-    mocha.suite = mocha.suite.clone();
-    mocha.suite.ctx = new Context();
-    mocha.ui(ui);
-    loadAndRun();
-  };
-
-  utils.watch(watchFiles, () => {
-    runAgain = true;
-    if (runner) {
-      runner.abort();
-    } else {
-      rerun();
-    }
-  });
-};
-
-/**
- * Actually run tests
- * @param {Mocha} mocha - Mocha instance
- * @param {Object} [opts] - Options
- * @param {boolean} [opts.watch=false] - Enable watch mode
- * @param {string[]} [opts.extension] - List of extensions to watch
- * @param {string|RegExp} [opts.grep] - Grep for test titles
- * @param {string} [opts.ui=bdd] - User interface
- * @param {boolean} [opts.exit=false] - Force-exit Mocha when tests done
- * @param {string[]} [files] - Array of test files
- * @private
- */
-exports.runMocha = (
-  mocha,
-  {watch = false, extension = ['js'], grep = '', ui = 'bdd', exit = false} = {},
-  files = []
-) => {
   if (watch) {
-    exports.watchRun(mocha, {extension, grep, ui, files});
+    watchRun(mocha, {ui}, fileCollectParams);
   } else {
-    exports.singleRun(mocha, {files, exit});
+    exports.singleRun(mocha, {exit}, fileCollectParams);
   }
 };
 

package/lib/cli/run-option-metadata.js

@@ -14,10 +14,10 @@
  */
 exports.types = {
   array: [
-    'exclude',
     'extension',
     'file',
     'global',
+    'ignore',
     'require',
     'reporter-option',
     'spec'
@@ -44,8 +44,18 @@ exports.types = {
     'sort',
     'watch'
   ],
-  number: ['retries', 'slow', 'timeout'],
-  string: ['fgrep', 'grep', 'package', 'reporter', 'ui']
+  number: ['retries'],
+  string: [
+    'config',
+    'fgrep',
+    'grep',
+    'opts',
+    'package',
+    'reporter',
+    'ui',
+    'slow',
+    'timeout'
+  ]
 };
 
 /**
@@ -63,6 +73,7 @@ exports.aliases = {
   global: ['globals'],
   grep: ['g'],
   growl: ['G'],
+  ignore: ['exclude'],
   invert: ['i'],
   'no-colors': ['C'],
   reporter: ['R'],

package/lib/cli/run.js

@@ -16,7 +16,6 @@ const {
 
 const {
   list,
-  handleFiles,
   handleRequires,
   validatePlugin,
   runMocha
@@ -82,12 +81,6 @@ exports.builder = yargs =>
         description: 'Show diff on failure',
         group: GROUPS.OUTPUT
       },
-      exclude: {
-        defaultDescription: '(none)',
-        description: 'Ignore file(s) or glob pattern(s)',
-        group: GROUPS.FILES,
-        requiresArg: true
-      },
       exit: {
         description: 'Force Mocha to quit after tests complete',
         group: GROUPS.RULES
@@ -143,6 +136,12 @@ exports.builder = yargs =>
         description: 'Enable Growl notifications',
         group: GROUPS.OUTPUT
       },
+      ignore: {
+        defaultDescription: '(none)',
+        description: 'Ignore file(s) or glob pattern(s)',
+        group: GROUPS.FILES,
+        requiresArg: true
+      },
       'inline-diffs': {
         description:
           'Display actual/expected differences inline within each string',
@@ -290,8 +289,5 @@ exports.builder = yargs =>
 exports.handler = argv => {
   debug('post-yargs config', argv);
   const mocha = new Mocha(argv);
-  const files = handleFiles(argv);
-
-  debug('running tests with files', files);
-  runMocha(mocha, argv, files);
+  runMocha(mocha, argv);
 };