npm - mocha - Versions diffs - 9.1.2 - Mend

mocha 9.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (76) hide show

package/CHANGELOG.md +1015 -0
package/LICENSE +22 -0
package/README.md +70 -0
package/assets/growl/error.png +0 -0
package/assets/growl/ok.png +0 -0
package/bin/_mocha +10 -0
package/bin/mocha +142 -0
package/browser-entry.js +216 -0
package/index.js +3 -0
package/lib/browser/growl.js +169 -0
package/lib/browser/highlight-tags.js +39 -0
package/lib/browser/parse-query.js +24 -0
package/lib/browser/progress.js +123 -0
package/lib/browser/template.html +20 -0
package/lib/cli/cli.js +89 -0
package/lib/cli/collect-files.js +92 -0
package/lib/cli/commands.js +13 -0
package/lib/cli/config.js +105 -0
package/lib/cli/index.js +3 -0
package/lib/cli/init.js +36 -0
package/lib/cli/lookup-files.js +145 -0
package/lib/cli/node-flags.js +85 -0
package/lib/cli/one-and-dones.js +69 -0
package/lib/cli/options.js +261 -0
package/lib/cli/run-helpers.js +243 -0
package/lib/cli/run-option-metadata.js +117 -0
package/lib/cli/run.js +379 -0
package/lib/cli/watch-run.js +380 -0
package/lib/context.js +86 -0
package/lib/errors.js +563 -0
package/lib/hook.js +89 -0
package/lib/interfaces/bdd.js +111 -0
package/lib/interfaces/common.js +193 -0
package/lib/interfaces/exports.js +60 -0
package/lib/interfaces/index.js +6 -0
package/lib/interfaces/qunit.js +98 -0
package/lib/interfaces/tdd.js +106 -0
package/lib/mocha.js +1374 -0
package/lib/mocharc.json +10 -0
package/lib/nodejs/buffered-worker-pool.js +172 -0
package/lib/nodejs/esm-utils.js +109 -0
package/lib/nodejs/file-unloader.js +15 -0
package/lib/nodejs/growl.js +137 -0
package/lib/nodejs/parallel-buffered-runner.js +433 -0
package/lib/nodejs/reporters/parallel-buffered.js +165 -0
package/lib/nodejs/serializer.js +412 -0
package/lib/nodejs/worker.js +151 -0
package/lib/pending.js +16 -0
package/lib/plugin-loader.js +286 -0
package/lib/reporters/base.js +537 -0
package/lib/reporters/doc.js +95 -0
package/lib/reporters/dot.js +81 -0
package/lib/reporters/html.js +390 -0
package/lib/reporters/index.js +19 -0
package/lib/reporters/json-stream.js +92 -0
package/lib/reporters/json.js +162 -0
package/lib/reporters/landing.js +116 -0
package/lib/reporters/list.js +78 -0
package/lib/reporters/markdown.js +112 -0
package/lib/reporters/min.js +52 -0
package/lib/reporters/nyan.js +276 -0
package/lib/reporters/progress.js +104 -0
package/lib/reporters/spec.js +99 -0
package/lib/reporters/tap.js +293 -0
package/lib/reporters/xunit.js +217 -0
package/lib/runnable.js +476 -0
package/lib/runner.js +1269 -0
package/lib/stats-collector.js +83 -0
package/lib/suite.js +695 -0
package/lib/test.js +113 -0
package/lib/utils.js +641 -0
package/mocha-es2018.js +19816 -0
package/mocha.css +325 -0
package/mocha.js +30844 -0
package/mocha.js.map +1 -0
package/package.json +200 -0

package/lib/browser/parse-query.js ADDED Viewed

@@ -0,0 +1,24 @@
+'use strict';
+/**
+ * Parse the given `qs`.
+ *
+ * @private
+ * @param {string} qs
+ * @return {Object<string, string>}
+ */
+module.exports = function parseQuery(qs) {
+  return qs
+    .replace('?', '')
+    .split('&')
+    .reduce(function(obj, pair) {
+      var i = pair.indexOf('=');
+      var key = pair.slice(0, i);
+      var val = pair.slice(++i);
+      // Due to how the URLSearchParams API treats spaces
+      obj[key] = decodeURIComponent(val.replace(/\+/g, '%20'));
+      return obj;
+    }, {});
+};

package/lib/browser/progress.js ADDED Viewed

@@ -0,0 +1,123 @@
+'use strict';
+/**
+ @module browser/Progress
+*/
+/**
+ * Expose `Progress`.
+ */
+module.exports = Progress;
+/**
+ * Initialize a new `Progress` indicator.
+ */
+function Progress() {
+  this.percent = 0;
+  this.size(0);
+  this.fontSize(11);
+  this.font('helvetica, arial, sans-serif');
+}
+/**
+ * Set progress size to `size`.
+ *
+ * @public
+ * @param {number} size
+ * @return {Progress} Progress instance.
+ */
+Progress.prototype.size = function(size) {
+  this._size = size;
+  return this;
+};
+/**
+ * Set text to `text`.
+ *
+ * @public
+ * @param {string} text
+ * @return {Progress} Progress instance.
+ */
+Progress.prototype.text = function(text) {
+  this._text = text;
+  return this;
+};
+/**
+ * Set font size to `size`.
+ *
+ * @public
+ * @param {number} size
+ * @return {Progress} Progress instance.
+ */
+Progress.prototype.fontSize = function(size) {
+  this._fontSize = size;
+  return this;
+};
+/**
+ * Set font to `family`.
+ *
+ * @param {string} family
+ * @return {Progress} Progress instance.
+ */
+Progress.prototype.font = function(family) {
+  this._font = family;
+  return this;
+};
+/**
+ * Update percentage to `n`.
+ *
+ * @param {number} n
+ * @return {Progress} Progress instance.
+ */
+Progress.prototype.update = function(n) {
+  this.percent = n;
+  return this;
+};
+/**
+ * Draw on `ctx`.
+ *
+ * @param {CanvasRenderingContext2d} ctx
+ * @return {Progress} Progress instance.
+ */
+Progress.prototype.draw = function(ctx) {
+  try {
+    var percent = Math.min(this.percent, 100);
+    var size = this._size;
+    var half = size / 2;
+    var x = half;
+    var y = half;
+    var rad = half - 1;
+    var fontSize = this._fontSize;
+    ctx.font = fontSize + 'px ' + this._font;
+    var angle = Math.PI * 2 * (percent / 100);
+    ctx.clearRect(0, 0, size, size);
+    // outer circle
+    ctx.strokeStyle = '#9f9f9f';
+    ctx.beginPath();
+    ctx.arc(x, y, rad, 0, angle, false);
+    ctx.stroke();
+    // inner circle
+    ctx.strokeStyle = '#eee';
+    ctx.beginPath();
+    ctx.arc(x, y, rad - 1, 0, angle, true);
+    ctx.stroke();
+    // text
+    var text = this._text || (percent | 0) + '%';
+    var w = ctx.measureText(text).width;
+    ctx.fillText(text, x - w / 2 + 1, y + fontSize / 2 - 1);
+  } catch (ignore) {
+    // don't fail if we can't render progress
+  }
+  return this;
+};

package/lib/browser/template.html ADDED Viewed

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Mocha</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="stylesheet" href="mocha.css" />
+  </head>
+  <body>
+    <div id="mocha"></div>
+    <script src="mocha.js"></script>
+    <script>
+      mocha.setup('bdd');
+    </script>
+    <script src="tests.spec.js"></script>
+    <script>
+      mocha.run();
+    </script>
+  </body>
+</html>

package/lib/cli/cli.js ADDED Viewed

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * Contains CLI entry point and public API for programmatic usage in Node.js.
+ * - Option parsing is handled by {@link https://npm.im/yargs yargs}.
+ * - If executed via `node`, this module will run {@linkcode module:lib/cli.main main()}.
+ * @public
+ * @module lib/cli
+ */
+const debug = require('debug')('mocha:cli:cli');
+const symbols = require('log-symbols');
+const yargs = require('yargs/yargs');
+const path = require('path');
+const {
+  loadRc,
+  loadPkgRc,
+  loadOptions,
+  YARGS_PARSER_CONFIG
+} = require('./options');
+const lookupFiles = require('./lookup-files');
+const commands = require('./commands');
+const ansi = require('ansi-colors');
+const {repository, homepage, version, gitter} = require('../../package.json');
+const {cwd} = require('../utils');
+/**
+ * - 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`
+ * @public
+ * @summary Mocha's main command-line entry-point.
+ * @param {string[]} argv - Array of arguments to parse, or by default the lovely `process.argv.slice(2)`
+ * @param {object} [mochaArgs] - Object of already parsed Mocha arguments (by bin/mocha)
+ */
+exports.main = (argv = process.argv.slice(2), mochaArgs) => {
+  debug('entered main with raw args', argv);
+  // ensure we can require() from current working directory
+  if (typeof module.paths !== 'undefined') {
+    module.paths.push(cwd(), path.resolve('node_modules'));
+  }
+  Error.stackTraceLimit = Infinity; // configurable via --stack-trace-limit?
+  var args = mochaArgs || loadOptions(argv);
+  yargs()
+    .scriptName('mocha')
+    .command(commands.run)
+    .command(commands.init)
+    .updateStrings({
+      'Positionals:': 'Positional Arguments',
+      'Options:': 'Other Options',
+      'Commands:': 'Commands'
+    })
+    .fail((msg, err, yargs) => {
+      debug('caught error sometime before command handler: %O', err);
+      yargs.showHelp();
+      console.error(`\n${symbols.error} ${ansi.red('ERROR:')} ${msg}`);
+      process.exitCode = 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)}
+      `
+    )
+    .parserConfiguration(YARGS_PARSER_CONFIG)
+    .config(args)
+    .parse(args._);
+};
+exports.lookupFiles = lookupFiles;
+exports.loadOptions = loadOptions;
+exports.loadPkgRc = loadPkgRc;
+exports.loadRc = loadRc;
+// allow direct execution
+if (require.main === module) {
+  exports.main();
+}

package/lib/cli/collect-files.js ADDED Viewed

@@ -0,0 +1,92 @@
+'use strict';
+const path = require('path');
+const ansi = require('ansi-colors');
+const debug = require('debug')('mocha:cli:run:helpers');
+const minimatch = require('minimatch');
+const {NO_FILES_MATCH_PATTERN} = require('../errors').constants;
+const lookupFiles = require('./lookup-files');
+const {castArray} = 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 {FileCollectionOptions} [opts] - Options
+ * @returns {string[]} List of files to test
+ * @private
+ */
+module.exports = ({
+  ignore,
+  extension,
+  file: fileArgs,
+  recursive,
+  sort,
+  spec
+} = {}) => {
+  const unmatched = [];
+  const specFiles = spec.reduce((specFiles, arg) => {
+    try {
+      const moreSpecFiles = castArray(lookupFiles(arg, extension, recursive))
+        .filter(filename =>
+          ignore.every(pattern => !minimatch(filename, pattern))
+        )
+        .map(filename => path.resolve(filename));
+      return [...specFiles, ...moreSpecFiles];
+    } catch (err) {
+      if (err.code === NO_FILES_MATCH_PATTERN) {
+        unmatched.push({message: err.message, pattern: err.pattern});
+        return specFiles;
+      }
+      throw err;
+    }
+  }, []);
+  // ensure we don't sort the stuff from fileArgs; order is important!
+  if (sort) {
+    specFiles.sort();
+  }
+  // add files given through --file to be ran first
+  const files = [
+    ...fileArgs.map(filepath => path.resolve(filepath)),
+    ...specFiles
+  ];
+  debug('test 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 a warning
+    unmatched.forEach(warning => {
+      console.warn(ansi.yellow(`Warning: ${warning.message}`));
+    });
+  }
+  return files;
+};
+/**
+ * An object to configure how Mocha gathers test files
+ * @private
+ * @typedef {Object} FileCollectionOptions
+ * @property {string[]} extension - File extensions to use
+ * @property {string[]} spec - Files, dirs, globs to run
+ * @property {string[]} ignore - Files, dirs, globs to ignore
+ * @property {string[]} file - List of additional files to include
+ * @property {boolean} recursive - Find files recursively
+ * @property {boolean} sort - Sort test files
+ */

package/lib/cli/commands.js ADDED Viewed

@@ -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 ADDED Viewed

@@ -0,0 +1,105 @@
+'use strict';
+/**
+ * Responsible for loading / finding Mocha's "rc" files.
+ *
+ * @private
+ * @module
+ */
+const fs = require('fs');
+const path = require('path');
+const debug = require('debug')('mocha:cli:config');
+const findUp = require('find-up');
+const {createUnparsableFileError} = require('../errors');
+const utils = require('../utils');
+/**
+ * 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.cjs',
+  '.mocharc.js',
+  '.mocharc.yaml',
+  '.mocharc.yml',
+  '.mocharc.jsonc',
+  '.mocharc.json'
+];
+const isModuleNotFoundError = err =>
+  err.code === 'MODULE_NOT_FOUND' ||
+  err.message.indexOf('Cannot find module') !== -1;
+/**
+ * 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').load(fs.readFileSync(filepath, 'utf8')),
+  js: filepath => {
+    const cwdFilepath = path.resolve(filepath);
+    try {
+      debug('parsers: load using cwd-relative path: "%s"', cwdFilepath);
+      return require(cwdFilepath);
+    } catch (err) {
+      if (isModuleNotFoundError(err)) {
+        debug('parsers: retry load as module-relative path: "%s"', filepath);
+        return require(filepath);
+      } else {
+        throw err; // rethrow
+      }
+    }
+  },
+  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.
+ *
+ * @private
+ * @param {string} filepath - Config file path to load
+ * @returns {Object} Parsed config object
+ */
+exports.loadConfig = filepath => {
+  let config = {};
+  debug('loadConfig: trying to parse config at %s', filepath);
+  const ext = path.extname(filepath);
+  try {
+    if (ext === '.yml' || ext === '.yaml') {
+      config = parsers.yaml(filepath);
+    } else if (ext === '.js' || ext === '.cjs') {
+      config = parsers.js(filepath);
+    } else {
+      config = parsers.json(filepath);
+    }
+  } catch (err) {
+    throw createUnparsableFileError(
+      `Unable to read/parse ${filepath}: ${err}`,
+      filepath
+    );
+  }
+  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 = utils.cwd()) => {
+  const filepath = findUp.sync(exports.CONFIG_FILES, {cwd});
+  if (filepath) {
+    debug('findConfig: found config file %s', filepath);
+  }
+  return filepath;
+};

package/lib/cli/index.js ADDED Viewed

@@ -0,0 +1,3 @@
+'use strict';
+module.exports = require('./cli');

package/lib/cli/init.js ADDED Viewed

@@ -0,0 +1,36 @@
+'use strict';
+/**
+ * Command module for "init" command
+ *
+ * @private
+ * @module
+ */
+const fs = require('fs');
+const path = require('path');
+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, '..', '..');
+  fs.mkdirSync(destdir, {recursive: true});
+  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/lookup-files.js ADDED Viewed

@@ -0,0 +1,145 @@
+'use strict';
+/**
+ * Contains `lookupFiles`, which takes some globs/dirs/options and returns a list of files.
+ * @module
+ * @private
+ */
+var fs = require('fs');
+var path = require('path');
+var glob = require('glob');
+var errors = require('../errors');
+var createNoFilesMatchPatternError = errors.createNoFilesMatchPatternError;
+var createMissingArgumentError = errors.createMissingArgumentError;
+const debug = require('debug')('mocha:cli:lookup-files');
+/**
+ * Determines if pathname would be a "hidden" file (or directory) on UN*X.
+ *
+ * @description
+ * On UN*X, pathnames beginning with a full stop (aka dot) are hidden during
+ * typical usage. Dotfiles, plain-text configuration files, are prime examples.
+ *
+ * @see {@link http://xahlee.info/UnixResource_dir/writ/unix_origin_of_dot_filename.html|Origin of Dot File Names}
+ *
+ * @private
+ * @param {string} pathname - Pathname to check for match.
+ * @return {boolean} whether pathname would be considered a hidden file.
+ * @example
+ * isHiddenOnUnix('.profile'); // => true
+ */
+const isHiddenOnUnix = pathname => path.basename(pathname).startsWith('.');
+/**
+ * Determines if pathname has a matching file extension.
+ *
+ * Supports multi-part extensions.
+ *
+ * @private
+ * @param {string} pathname - Pathname to check for match.
+ * @param {string[]} exts - List of file extensions, w/-or-w/o leading period
+ * @return {boolean} `true` if file extension matches.
+ * @example
+ * hasMatchingExtname('foo.html', ['js', 'css']); // false
+ * hasMatchingExtname('foo.js', ['.js']); // true
+ * hasMatchingExtname('foo.js', ['js']); // ture
+ */
+const hasMatchingExtname = (pathname, exts = []) =>
+  exts
+    .map(ext => (ext.startsWith('.') ? ext : `.${ext}`))
+    .some(ext => pathname.endsWith(ext));
+/**
+ * Lookup file names at the given `path`.
+ *
+ * @description
+ * Filenames are returned in _traversal_ order by the OS/filesystem.
+ * **Make no assumption that the names will be sorted in any fashion.**
+ *
+ * @public
+ * @alias module:lib/cli.lookupFiles
+ * @param {string} filepath - Base path to start searching from.
+ * @param {string[]} [extensions=[]] - File extensions to look for.
+ * @param {boolean} [recursive=false] - Whether to recurse into subdirectories.
+ * @return {string[]} An array of paths.
+ * @throws {Error} if no files match pattern.
+ * @throws {TypeError} if `filepath` is directory and `extensions` not provided.
+ */
+module.exports = function lookupFiles(
+  filepath,
+  extensions = [],
+  recursive = false
+) {
+  const files = [];
+  let stat;
+  if (!fs.existsSync(filepath)) {
+    let pattern;
+    if (glob.hasMagic(filepath)) {
+      // Handle glob as is without extensions
+      pattern = filepath;
+    } else {
+      // glob pattern e.g. 'filepath+(.js|.ts)'
+      const strExtensions = extensions
+        .map(ext => (ext.startsWith('.') ? ext : `.${ext}`))
+        .join('|');
+      pattern = `${filepath}+(${strExtensions})`;
+      debug('looking for files using glob pattern: %s', pattern);
+    }
+    files.push(...glob.sync(pattern, {nodir: true}));
+    if (!files.length) {
+      throw createNoFilesMatchPatternError(
+        `Cannot find any files matching pattern "${filepath}"`,
+        filepath
+      );
+    }
+    return files;
+  }
+  // Handle file
+  try {
+    stat = fs.statSync(filepath);
+    if (stat.isFile()) {
+      return filepath;
+    }
+  } catch (err) {
+    // ignore error
+    return;
+  }
+  // Handle directory
+  fs.readdirSync(filepath).forEach(dirent => {
+    const pathname = path.join(filepath, dirent);
+    let stat;
+    try {
+      stat = fs.statSync(pathname);
+      if (stat.isDirectory()) {
+        if (recursive) {
+          files.push(...lookupFiles(pathname, extensions, recursive));
+        }
+        return;
+      }
+    } catch (ignored) {
+      return;
+    }
+    if (!extensions.length) {
+      throw createMissingArgumentError(
+        `Argument '${extensions}' required when argument '${filepath}' is a directory`,
+        'extensions',
+        'array'
+      );
+    }
+    if (
+      !stat.isFile() ||
+      !hasMatchingExtname(pathname, extensions) ||
+      isHiddenOnUnix(pathname)
+    ) {
+      return;
+    }
+    files.push(pathname);
+  });
+  return files;
+};