mocha 5.1.1 → 6.0.0

package/lib/cli/cli.js

@@ -0,0 +1,68 @@
+'use strict';
+
+/**
+ * This is where we finally parse and handle arguments passed to the `mocha` executable.
+ * Option parsing is handled by {@link https://npm.im/yargs yargs}.
+ * If executed via `node`, this module will run {@linkcode module:lib/cli/cli.main main()}.
+ *
+ * @private
+ * @module
+ */
+
+const debug = require('debug')('mocha:cli:cli');
+const symbols = require('log-symbols');
+const yargs = require('yargs');
+const path = require('path');
+const {loadOptions} = require('./options');
+const commands = require('./commands');
+const ansi = require('ansi-colors');
+const {repository, homepage, version, gitter} = require('../../package.json');
+
+/**
+ * - Accepts an `Array` of arguments
+ * - Modifies {@link https://nodejs.org/api/modules.html#modules_module_paths Node.js' search path} for easy loading of consumer modules
+ * - Sets {@linkcode https://nodejs.org/api/errors.html#errors_error_stacktracelimit Error.stackTraceLimit} to `Infinity`
+ * @summary Mocha's main entry point from the command-line.
+ * @param {string[]} argv - Array of arguments to parse, or by default the lovely `process.argv.slice(2)`
+ */
+exports.main = (argv = process.argv.slice(2)) => {
+  debug('entered main with raw args', argv);
+  // ensure we can require() from current working directory
+  module.paths.push(process.cwd(), path.resolve('node_modules'));
+
+  Error.stackTraceLimit = Infinity; // configurable via --stack-trace-limit?
+
+  yargs
+    .scriptName('mocha')
+    .command(commands.run)
+    .command(commands.init)
+    .updateStrings({
+      'Positionals:': 'Positional Arguments',
+      'Options:': 'Other Options',
+      'Commands:': 'Commands'
+    })
+    .fail((msg, err, yargs) => {
+      debug(err);
+      yargs.showHelp();
+      console.error(`\n${symbols.error} ${ansi.red('ERROR:')} ${msg}`);
+      process.exit(1);
+    })
+    .help('help', 'Show usage information & exit')
+    .alias('help', 'h')
+    .version('version', 'Show version number & exit', version)
+    .alias('version', 'V')
+    .wrap(process.stdout.columns ? Math.min(process.stdout.columns, 80) : 80)
+    .epilog(
+      `Mocha Resources
+    Chat: ${ansi.magenta(gitter)}
+  GitHub: ${ansi.blue(repository.url)}
+    Docs: ${ansi.yellow(homepage)}
+      `
+    )
+    .parse(argv, loadOptions(argv));
+};
+
+// allow direct execution
+if (require.main === module) {
+  exports.main();
+}

package/lib/cli/commands.js

@@ -0,0 +1,13 @@
+'use strict';
+
+/**
+ * Exports Yargs commands
+ * @see https://git.io/fpJ0G
+ * @private
+ * @module
+ */
+
+exports.init = require('./init');
+
+// default command
+exports.run = require('./run');

package/lib/cli/config.js

@@ -0,0 +1,79 @@
+'use strict';
+
+/**
+ * Responsible for loading / finding Mocha's "rc" files.
+ * This doesn't have anything to do with `mocha.opts`.
+ *
+ * @private
+ * @module
+ */
+
+const fs = require('fs');
+const findUp = require('findup-sync');
+const path = require('path');
+const debug = require('debug')('mocha:cli:config');
+
+/**
+ * These are the valid config files, in order of precedence;
+ * e.g., if `.mocharc.js` is present, then `.mocharc.yaml` and the rest
+ * will be ignored.
+ * The user should still be able to explicitly specify a file.
+ * @private
+ */
+exports.CONFIG_FILES = [
+  '.mocharc.js',
+  '.mocharc.yaml',
+  '.mocharc.yml',
+  '.mocharc.json'
+];
+
+/**
+ * Parsers for various config filetypes.  Each accepts a filepath and
+ * returns an object (but could throw)
+ */
+const parsers = (exports.parsers = {
+  yaml: filepath =>
+    require('js-yaml').safeLoad(fs.readFileSync(filepath, 'utf8')),
+  js: filepath => require(filepath),
+  json: filepath =>
+    JSON.parse(
+      require('strip-json-comments')(fs.readFileSync(filepath, 'utf8'))
+    )
+});
+
+/**
+ * Loads and parses, based on file extension, a config file.
+ * "JSON" files may have comments.
+ * @param {string} filepath - Config file path to load
+ * @returns {Object} Parsed config object
+ * @private
+ */
+exports.loadConfig = filepath => {
+  let config = {};
+  const ext = path.extname(filepath);
+  try {
+    if (/\.ya?ml/.test(ext)) {
+      config = parsers.yaml(filepath);
+    } else if (ext === '.js') {
+      config = parsers.js(filepath);
+    } else {
+      config = parsers.json(filepath);
+    }
+  } catch (err) {
+    throw new Error(`failed to parse ${filepath}: ${err}`);
+  }
+  return config;
+};
+
+/**
+ * Find ("find up") config file starting at `cwd`
+ * @param {string} [cwd] - Current working directory
+ * @returns {string|null} Filepath to config, if found
+ */
+exports.findConfig = (cwd = process.cwd()) => {
+  const filepath = findUp(exports.CONFIG_FILES, {cwd});
+  if (filepath) {
+    debug(`found config at ${filepath}`);
+  }
+  return filepath;
+};

package/lib/cli/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+/**
+ * Just exports {@link module:lib/cli/cli} for convenience.
+ * @private
+ * @module lib/cli
+ * @exports module:lib/cli/cli
+ */
+module.exports = require('./cli');

package/lib/cli/init.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * Command module for "init" command
+ *
+ * @private
+ * @module
+ */
+
+const fs = require('fs');
+const path = require('path');
+const mkdirp = require('mkdirp');
+
+exports.command = 'init <path>';
+
+exports.description = 'create a client-side Mocha setup at <path>';
+
+exports.builder = yargs =>
+  yargs.positional('path', {
+    type: 'string',
+    normalize: true
+  });
+
+exports.handler = argv => {
+  const destdir = argv.path;
+  const srcdir = path.join(__dirname, '..', '..');
+  mkdirp.sync(destdir);
+  const css = fs.readFileSync(path.join(srcdir, 'mocha.css'));
+  const js = fs.readFileSync(path.join(srcdir, 'mocha.js'));
+  const tmpl = fs.readFileSync(
+    path.join(srcdir, 'lib', 'browser', 'template.html')
+  );
+  fs.writeFileSync(path.join(destdir, 'mocha.css'), css);
+  fs.writeFileSync(path.join(destdir, 'mocha.js'), js);
+  fs.writeFileSync(path.join(destdir, 'tests.spec.js'), '');
+  fs.writeFileSync(path.join(destdir, 'index.html'), tmpl);
+};

package/lib/cli/node-flags.js

@@ -0,0 +1,69 @@
+'use strict';
+
+/**
+ * Some settings and code related to Mocha's handling of Node.js/V8 flags.
+ * @private
+ * @module
+ */
+
+const nodeFlags = require('node-environment-flags');
+const unparse = require('yargs-unparser');
+
+/**
+ * These flags are considered "debug" flags.
+ * @see {@link impliesNoTimeouts}
+ * @private
+ */
+const debugFlags = new Set(['debug', 'debug-brk', 'inspect', 'inspect-brk']);
+
+/**
+ * Mocha has historical support for various `node` and V8 flags which might not
+ * appear in `process.allowedNodeEnvironmentFlags`.
+ * These include:
+ *   - `--preserve-symlinks`
+ *   - `--harmony-*`
+ *   - `--gc-global`
+ *   - `--trace-*`
+ *   - `--es-staging`
+ *   - `--use-strict`
+ *   - `--v8-*` (but *not* `--v8-options`)
+ * @summary Whether or not to pass a flag along to the `node` executable.
+ * @param {string} flag - Flag to test
+ * @returns {boolean}
+ * @private
+ */
+exports.isNodeFlag = flag =>
+  !/^(?:require|r)$/.test(flag) &&
+  (nodeFlags.has(flag) ||
+    debugFlags.has(flag) ||
+    /(?:preserve-symlinks(?:-main)?|harmony(?:[_-]|$)|(?:trace[_-].+$)|gc(?:[_-]global)?$|es[_-]staging$|use[_-]strict$|v8[_-](?!options).+?$)/.test(
+      flag
+    ));
+
+/**
+ * Returns `true` if the flag is a "debug-like" flag.  These require timeouts
+ * to be suppressed, or pausing the debugger on breakpoints will cause test failures.
+ * @param {string} flag - Flag to test
+ * @returns {boolean}
+ * @private
+ */
+exports.impliesNoTimeouts = flag => debugFlags.has(flag);
+
+/**
+ * All non-strictly-boolean arguments to node--those with values--must specify those values using `=`, e.g., `--inspect=0.0.0.0`.
+ * Unparse these arguments using `yargs-unparser` (which would result in `--inspect 0.0.0.0`), then supply `=` where we have values.
+ * There's probably an easier or more robust way to do this; fixes welcome
+ * @param {Object} opts - Arguments object
+ * @returns {string[]} Unparsed arguments using `=` to specify values
+ * @private
+ */
+exports.unparseNodeFlags = opts => {
+  var args = unparse(opts);
+  return args.length
+    ? args
+        .join(' ')
+        .split(/\b/)
+        .map(arg => (arg === ' ' ? '=' : arg))
+        .join('')
+    : [];
+};

package/lib/cli/one-and-dones.js

@@ -0,0 +1,70 @@
+'use strict';
+
+/**
+ * Contains "command" code for "one-and-dones"--options passed
+ * to Mocha which cause it to just dump some info and exit.
+ * See {@link module:lib/cli/one-and-dones.ONE_AND_DONE_ARGS ONE_AND_DONE_ARGS} for more info.
+ * @module
+ * @private
+ */
+
+const align = require('wide-align');
+const Mocha = require('../mocha');
+
+/**
+ * Dumps a sorted list of the enumerable, lower-case keys of some object
+ * to `STDOUT`.
+ * @param {Object} obj - Object, ostensibly having some enumerable keys
+ * @ignore
+ * @private
+ */
+const showKeys = obj => {
+  console.log();
+  const keys = Object.keys(obj);
+  const maxKeyLength = keys.reduce((max, key) => Math.max(max, key.length), 0);
+  keys
+    .filter(
+      key => /^[a-z]/.test(key) && !obj[key].browserOnly && !obj[key].abstract
+    )
+    .sort()
+    .forEach(key => {
+      const description = obj[key].description;
+      console.log(
+        `    ${align.left(key, maxKeyLength + 1)}${
+          description ? `- ${description}` : ''
+        }`
+      );
+    });
+  console.log();
+};
+
+/**
+ * Handlers for one-and-done options
+ * @namespace
+ * @private
+ */
+exports.ONE_AND_DONES = {
+  /**
+   * Dump list of built-in interfaces
+   * @private
+   */
+  interfaces: () => {
+    showKeys(Mocha.interfaces);
+  },
+  /**
+   * Dump list of built-in reporters
+   * @private
+   */
+  reporters: () => {
+    showKeys(Mocha.reporters);
+  }
+};
+
+/**
+ * A Set of all one-and-done options
+ * @type Set<string>
+ * @private
+ */
+exports.ONE_AND_DONE_ARGS = new Set(
+  ['help', 'h', 'version', 'V'].concat(Object.keys(exports.ONE_AND_DONES))
+);

package/lib/cli/options.js

@@ -0,0 +1,330 @@
+'use strict';
+
+/**
+ * Main entry point for handling filesystem-based configuration,
+ * whether that's `mocha.opts` or a config file or `package.json` or whatever.
+ * @module
+ */
+
+const fs = require('fs');
+const yargsParser = require('yargs-parser');
+const {types, aliases} = require('./run-option-metadata');
+const {ONE_AND_DONE_ARGS} = require('./one-and-dones');
+const mocharc = require('../mocharc.json');
+const yargsParserConfig = require('../../package.json').yargs;
+const {list} = require('./run-helpers');
+const {loadConfig, findConfig} = require('./config');
+const findup = require('findup-sync');
+const {deprecate} = require('../utils');
+const debug = require('debug')('mocha:cli:options');
+const {createMissingArgumentError} = require('../errors');
+const {isNodeFlag} = require('./node-flags');
+
+/**
+ * The `yargs-parser` namespace
+ * @external yargsParser
+ * @see {@link https://npm.im/yargs-parser}
+ */
+
+/**
+ * An object returned by a configured `yargs-parser` representing arguments
+ * @memberof external:yargsParser
+ * @interface Arguments
+ */
+
+/**
+ * This is the config pulled from the `yargs` property of Mocha's
+ * `package.json`, but it also disables camel case expansion as to
+ * avoid outputting non-canonical keynames, as we need to do some
+ * lookups.
+ * @private
+ * @ignore
+ */
+const configuration = Object.assign({}, yargsParserConfig, {
+  'camel-case-expansion': false
+});
+
+/**
+ * This is a really fancy way to ensure unique values for `array`-type
+ * options.
+ * 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)))}),
+  {}
+);
+
+/**
+ * We do not have a case when multiple arguments are ever allowed after a flag
+ * (e.g., `--foo bar baz quux`), so we fix the number of arguments to 1 across
+ * the board of non-boolean options.
+ * This is passed as the `narg` option to `yargs-parser`
+ * @private
+ * @ignore
+ */
+const nargOpts = types.array
+  .concat(types.string, types.number)
+  .reduce((acc, arg) => Object.assign(acc, {[arg]: 1}), {});
+
+/**
+ * Wrapper around `yargs-parser` which applies our settings
+ * @param {string|string[]} args - Arguments to parse
+ * @param  {...Object} configObjects - `configObjects` for yargs-parser
+ * @private
+ * @ignore
+ */
+const parse = (args = [], ...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
+  // 3. to avoid explicitly defining the set of them, we tell yargs-parser they
+  //    are ALL boolean flags.
+  // 4. we can then reapply the values after yargs-parser is done.
+  const nodeArgs = (Array.isArray(args) ? args : args.split(' ')).reduce(
+    (acc, arg) => {
+      const pair = arg.split('=');
+      const flag = pair[0].replace(/^--?/, '');
+      if (isNodeFlag(flag)) {
+        return arg.includes('=')
+          ? acc.concat([[flag, pair[1]]])
+          : acc.concat([[flag, true]]);
+      }
+      return acc;
+    },
+    []
+  );
+
+  const result = yargsParser.detailed(args, {
+    configuration,
+    configObjects,
+    coerce: coerceOpts,
+    narg: nargOpts,
+    alias: aliases,
+    string: types.string,
+    array: types.array,
+    number: types.number,
+    boolean: types.boolean.concat(nodeArgs.map(pair => pair[0]))
+  });
+  if (result.error) {
+    throw createMissingArgumentError(result.error.message);
+  }
+
+  // reapply "=" arg values from above
+  nodeArgs.forEach(([key, value]) => {
+    result.argv[key] = value;
+  });
+
+  return result.argv;
+};
+
+/**
+ * - Replaces comments with empty strings
+ * - Replaces escaped spaces (e.g., 'xxx\ yyy') with HTML space
+ * - Splits on whitespace, creating array of substrings
+ * - Filters empty string elements from array
+ * - Replaces any HTML space with space
+ * @summary Parses options read from run-control file.
+ * @private
+ * @param {string} content - Content read from run-control file.
+ * @returns {string[]} cmdline options (and associated arguments)
+ * @ignore
+ */
+const parseMochaOpts = content =>
+  content
+    .replace(/^#.*$/gm, '')
+    .replace(/\\\s/g, '%20')
+    .split(/\s/)
+    .filter(Boolean)
+    .map(value => value.replace(/%20/g, ' '));
+
+/**
+ * Prepends options from run-control file to the command line arguments.
+ *
+ * @deprecated Deprecated in v6.0.0; This function is no longer used internally and will be removed in a future version.
+ * @public
+ * @alias module:lib/cli/options
+ * @see {@link https://mochajs.org/#mochaopts|mocha.opts}
+ */
+module.exports = function getOptions() {
+  deprecate(
+    'getOptions() is DEPRECATED and will be removed from a future version of Mocha.  Use loadOptions() instead'
+  );
+  if (process.argv.length === 3 && ONE_AND_DONE_ARGS.has(process.argv[2])) {
+    return;
+  }
+
+  const optsPath =
+    process.argv.indexOf('--opts') === -1
+      ? mocharc.opts
+      : process.argv[process.argv.indexOf('--opts') + 1];
+
+  try {
+    const options = parseMochaOpts(fs.readFileSync(optsPath, 'utf8'));
+
+    process.argv = process.argv
+      .slice(0, 2)
+      .concat(options.concat(process.argv.slice(2)));
+  } catch (ignore) {
+    // NOTE: should console.error() and throw the error
+  }
+
+  process.env.LOADED_MOCHA_OPTS = true;
+};
+
+/**
+ * Given filepath in `args.opts`, attempt to load and parse a `mocha.opts` file.
+ * @param {Object} [args] - Arguments object
+ * @param {string|boolean} [args.opts] - Filepath to mocha.opts; defaults to whatever's in `mocharc.opts`, or `false` to skip
+ * @returns {external:yargsParser.Arguments|void} If read, object containing parsed arguments
+ * @memberof module:lib/cli/options
+ * @public
+ */
+const loadMochaOpts = (args = {}) => {
+  let result;
+  let filepath = args.opts;
+  // /dev/null is backwards compat
+  if (filepath === false || filepath === '/dev/null') {
+    return result;
+  }
+  filepath = filepath || mocharc.opts;
+  result = {};
+  let mochaOpts;
+  try {
+    mochaOpts = fs.readFileSync(filepath, 'utf8');
+    debug(`read ${filepath}`);
+  } catch (err) {
+    if (args.opts) {
+      throw new Error(`Unable to read ${filepath}: ${err}`);
+    }
+    // ignore otherwise.  we tried
+    debug(`No mocha.opts found at ${filepath}`);
+  }
+
+  // real args should override `mocha.opts` which should override defaults.
+  // if there's an exception to catch here, I'm not sure what it is.
+  // by attaching the `no-opts` arg, we avoid re-parsing of `mocha.opts`.
+  if (mochaOpts) {
+    result = parse(parseMochaOpts(mochaOpts));
+    debug(`${filepath} parsed succesfully`);
+  }
+  return result;
+};
+
+module.exports.loadMochaOpts = loadMochaOpts;
+
+/**
+ * Given path to config file in `args.config`, attempt to load & parse config file.
+ * @param {Object} [args] - Arguments object
+ * @param {string|boolean} [args.config] - Path to config file or `false` to skip
+ * @public
+ * @memberof module:lib/cli/options
+ * @returns {external:yargsParser.Arguments|void} Parsed config, or nothing if `args.config` is `false`
+ */
+const loadRc = (args = {}) => {
+  if (args.config !== false) {
+    const config = args.config || findConfig();
+    return config ? loadConfig(config) : {};
+  }
+};
+
+module.exports.loadRc = loadRc;
+
+/**
+ * Given path to `package.json` in `args.package`, attempt to load config from `mocha` prop.
+ * @param {Object} [args] - Arguments object
+ * @param {string|boolean} [args.config] - Path to `package.json` or `false` to skip
+ * @public
+ * @memberof module:lib/cli/options
+ * @returns {external:yargsParser.Arguments|void} Parsed config, or nothing if `args.package` is `false`
+ */
+const loadPkgRc = (args = {}) => {
+  let result;
+  if (args.package === false) {
+    return result;
+  }
+  result = {};
+  const filepath = args.package || findup(mocharc.package);
+  if (filepath) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(filepath, 'utf8'));
+      if (pkg.mocha) {
+        debug(`'mocha' prop of package.json parsed:`, pkg.mocha);
+        result = pkg.mocha;
+      } else {
+        debug(`no config found in ${filepath}`);
+      }
+    } catch (err) {
+      if (args.package) {
+        throw new Error(`Unable to read/parse ${filepath}: ${err}`);
+      }
+      debug(`failed to read default package.json at ${filepath}; ignoring`);
+    }
+  }
+  return result;
+};
+
+module.exports.loadPkgRc = loadPkgRc;
+
+/**
+ * Priority list:
+ *
+ * 1. Command-line args
+ * 2. RC file (`.mocharc.js`, `.mocharc.ya?ml`, `mocharc.json`)
+ * 3. `mocha` prop of `package.json`
+ * 4. `mocha.opts`
+ * 5. default configuration (`lib/mocharc.json`)
+ *
+ * If a {@link module:lib/cli/one-and-dones.ONE_AND_DONE_ARGS "one-and-done" option} is present in the `argv` array, no external config files will be read.
+ * @summary Parses options read from `mocha.opts`, `.mocharc.*` and `package.json`.
+ * @param {string|string[]} [argv] - Arguments to parse
+ * @public
+ * @memberof module:lib/cli/options
+ * @returns {external:yargsParser.Arguments} Parsed args from everything
+ */
+const loadOptions = (argv = []) => {
+  let args = parse(argv);
+  // short-circuit: look for a flag that would abort loading of mocha.opts
+  if (
+    Array.from(ONE_AND_DONE_ARGS).reduce(
+      (acc, arg) => acc || arg in args,
+      false
+    )
+  ) {
+    return args;
+  }
+
+  const rcConfig = loadRc(args);
+  const pkgConfig = loadPkgRc(args);
+  const optsConfig = loadMochaOpts(args);
+
+  if (rcConfig) {
+    args.config = false;
+  }
+  if (pkgConfig) {
+    args.package = false;
+  }
+  if (optsConfig) {
+    args.opts = false;
+  }
+
+  args = parse(
+    args._,
+    args,
+    rcConfig || {},
+    pkgConfig || {},
+    optsConfig || {},
+    mocharc
+  );
+
+  // recombine positional arguments and "spec"
+  if (args.spec) {
+    args._ = args._.concat(args.spec);
+    delete args.spec;
+  }
+
+  return args;
+};
+
+module.exports.loadOptions = loadOptions;