mocha 11.7.4 → 11.7.6

package/lib/cli/watch-run.js

@@ -1,14 +1,14 @@
-'use strict';
-
-const logSymbols = require('log-symbols');
-const debug = require('debug')('mocha:cli:watch');
-const path = require('node:path');
-const chokidar = require('chokidar');
-const glob = require('glob');
-const isPathInside = require('is-path-inside');
-const {minimatch} = require('minimatch');
-const Context = require('../context');
-const collectFiles = require('./collect-files');
+"use strict";
+
+const logSymbols = require("log-symbols");
+const debug = require("debug")("mocha:cli:watch");
+const path = require("node:path");
+const chokidar = require("chokidar");
+const glob = require("glob");
+const isPathInside = require("is-path-inside");
+const { minimatch } = require("minimatch");
+const Context = require("../context");
+const collectFiles = require("./collect-files");
 
 /**
  * @typedef {import('chokidar').FSWatcher} FSWatcher
@@ -46,15 +46,15 @@ const collectFiles = require('./collect-files');
  */
 exports.watchParallelRun = (
   mocha,
-  {watchFiles, watchIgnore},
-  fileCollectParams
+  { watchFiles, watchIgnore },
+  fileCollectParams,
 ) => {
-  debug('creating parallel watcher');
+  debug("creating parallel watcher");
 
   return createWatcher(mocha, {
     watchFiles,
     watchIgnore,
-    beforeRun({mocha}) {
+    beforeRun({ mocha }) {
       // I don't know why we're cloning the root suite.
       const rootSuite = mocha.suite.clone();
 
@@ -64,7 +64,7 @@ exports.watchParallelRun = (
       // this `require` is needed because the require cache has been cleared.  the dynamic
       // exports set via the below call to `mocha.ui()` won't work properly if a
       // test depends on this module.
-      const Mocha = require('../mocha');
+      const Mocha = require("../mocha");
 
       // ... and now that we've gotten a new module, we need to use it again due
       // to `mocha.ui()` call
@@ -90,7 +90,7 @@ exports.watchParallelRun = (
       newMocha.lazyLoadFiles(true);
       return newMocha;
     },
-    fileCollectParams
+    fileCollectParams,
   });
 };
 
@@ -108,13 +108,13 @@ exports.watchParallelRun = (
  *   file collection. See `lib/cli/collect-files.js`.
  * @private
  */
-exports.watchRun = (mocha, {watchFiles, watchIgnore}, fileCollectParams) => {
-  debug('creating serial watcher');
+exports.watchRun = (mocha, { watchFiles, watchIgnore }, fileCollectParams) => {
+  debug("creating serial watcher");
 
   return createWatcher(mocha, {
     watchFiles,
     watchIgnore,
-    beforeRun({mocha}) {
+    beforeRun({ mocha }) {
       mocha.unloadFiles();
 
       // I don't know why we're cloning the root suite.
@@ -126,7 +126,7 @@ exports.watchRun = (mocha, {watchFiles, watchIgnore}, fileCollectParams) => {
       // this `require` is needed because the require cache has been cleared.  the dynamic
       // exports set via the below call to `mocha.ui()` won't work properly if a
       // test depends on this module.
-      const Mocha = require('../mocha');
+      const Mocha = require("../mocha");
 
       // ... and now that we've gotten a new module, we need to use it again due
       // to `mocha.ui()` call
@@ -149,7 +149,7 @@ exports.watchRun = (mocha, {watchFiles, watchIgnore}, fileCollectParams) => {
 
       return newMocha;
     },
-    fileCollectParams
+    fileCollectParams,
   });
 };
 
@@ -163,35 +163,35 @@ exports.watchRun = (mocha, {watchFiles, watchIgnore}, fileCollectParams) => {
  * @private
  */
 function createPathFilter(globPaths, basePath) {
-  debug('creating path filter from glob paths: %s', globPaths);
+  debug("creating path filter from glob paths: %s", globPaths);
 
   /**
    * The resulting object to filter paths.
    * @type {PathFilter}
    */
   const res = {
-    dir: {paths: new Set(), globs: new Set()},
-    match: {paths: new Set(), globs: new Set()}
+    dir: { paths: new Set(), globs: new Set() },
+    match: { paths: new Set(), globs: new Set() },
   };
 
   // for checking if a path ends with `/**/*`
-  const globEnd = path.join(path.sep, '**', '*');
+  const globEnd = path.join(path.sep, "**", "*");
 
   /**
    * The current glob pattern to check.
    * @type {Pattern[]}
    */
-  const patterns = globPaths.flatMap(globPath => {
+  const patterns = globPaths.flatMap((globPath) => {
     return new glob.Glob(globPath, {
       dot: true,
       magicalBraces: true,
-      windowsPathsNoEscape: true
+      windowsPathsNoEscape: true,
     }).patterns;
   }, []);
 
   // each pattern will have its own path because of the `magicalBraces` option
   for (const pattern of patterns) {
-    debug('processing glob pattern: %s', pattern.globString());
+    debug("processing glob pattern: %s", pattern.globString());
 
     /**
      * Path segments before the glob pattern.
@@ -209,11 +209,11 @@ function createPathFilter(globPaths, basePath) {
     do {
       // save string patterns until a non-string (glob or regexp) is matched
       const entry = currentPattern.pattern();
-      const isString = typeof entry === 'string';
+      const isString = typeof entry === "string";
       debug(
-        'found %s pattern: %s',
-        isString ? 'string' : 'glob or regexp',
-        entry
+        "found %s pattern: %s",
+        isString ? "string" : "glob or regexp",
+        entry,
       );
       if (!isString) {
         // if the entry is a glob
@@ -226,28 +226,28 @@ function createPathFilter(globPaths, basePath) {
       // go to next pattern
     } while ((currentPattern = currentPattern.rest()));
     if (!isGlob) {
-      debug('all subpatterns of %j processed', pattern.globString());
+      debug("all subpatterns of %j processed", pattern.globString());
     }
 
     // match `cleanPath` (path without the glob part) and its subdirectories
     const cleanPath = path.resolve(basePath, ...segments);
-    debug('clean path: %s', cleanPath);
+    debug("clean path: %s", cleanPath);
     res.dir.paths.add(cleanPath);
-    res.dir.globs.add(path.resolve(cleanPath, '**', '*'));
+    res.dir.globs.add(path.resolve(cleanPath, "**", "*"));
 
     // match `absPath` and all of its contents
     const absPath = path.resolve(basePath, pattern.globString());
-    debug('absolute path: %s', absPath);
+    debug("absolute path: %s", absPath);
     (isGlob ? res.match.globs : res.match.paths).add(absPath);
 
     // always include `/**/*` to the full pattern for matching
     // since it's possible for the last path segment to be a directory
     if (!absPath.endsWith(globEnd)) {
-      res.match.globs.add(path.resolve(absPath, '**', '*'));
+      res.match.globs.add(path.resolve(absPath, "**", "*"));
     }
   }
 
-  debug('returning path filter: %o', res);
+  debug("returning path filter: %o", res);
   return res;
 }
 
@@ -276,7 +276,7 @@ function matchPattern(filePath, pattern, matchParent) {
   // loop through the set of glob paths instead of converting it into an array
   for (const globPath of pattern.globs) {
     if (
-      minimatch(filePath, globPath, {dot: true, windowsPathsNoEscape: true})
+      minimatch(filePath, globPath, { dot: true, windowsPathsNoEscape: true })
     ) {
       return true;
     }
@@ -296,9 +296,9 @@ function matchPattern(filePath, pattern, matchParent) {
  */
 function createPathMatcher(allowed, ignored, basePath) {
   debug(
-    'creating path matcher from allowed: %o, ignored: %o',
+    "creating path matcher from allowed: %o, ignored: %o",
     allowed,
-    ignored
+    ignored,
   );
 
   /**
@@ -379,7 +379,7 @@ function createPathMatcher(allowed, ignored, basePath) {
 
       cache(ignoreCache, filePath, ignore);
       return ignore;
-    }
+    },
   };
 
   return matcher;
@@ -404,14 +404,14 @@ function createPathMatcher(allowed, ignored, basePath) {
  */
 const createWatcher = (
   mocha,
-  {watchFiles, watchIgnore, beforeRun, fileCollectParams}
+  { watchFiles, watchIgnore, beforeRun, fileCollectParams },
 ) => {
   if (!watchFiles) {
-    watchFiles = fileCollectParams.extension.map(ext => `**/*.${ext}`);
+    watchFiles = fileCollectParams.extension.map((ext) => `**/*.${ext}`);
   }
 
-  debug('watching files: %s', watchFiles);
-  debug('ignoring files matching: %s', watchIgnore);
+  debug("watching files: %s", watchFiles);
+  debug("ignoring files matching: %s", watchIgnore);
   let globalFixtureContext;
 
   // we handle global fixtures manually
@@ -431,23 +431,23 @@ const createWatcher = (
   // Chokidar has to watch the directory paths in case new files are created
   const watcher = chokidar.watch(Array.from(allowed.dir.paths), {
     ignoreInitial: true,
-    ignored: matcher.ignore
+    ignored: matcher.ignore,
   });
 
   const rerunner = createRerunner(mocha, watcher, {
-    beforeRun
+    beforeRun,
   });
 
-  watcher.on('ready', async () => {
-    debug('watcher ready');
+  watcher.on("ready", async () => {
+    debug("watcher ready");
     if (!globalFixtureContext) {
-      debug('triggering global setup');
+      debug("triggering global setup");
       globalFixtureContext = await mocha.runGlobalSetup();
     }
     rerunner.run();
   });
 
-  watcher.on('all', (_event, filePath) => {
+  watcher.on("all", (_event, filePath) => {
     // only allow file paths that match the allowed patterns
     if (matcher.allow(filePath)) {
       rerunner.scheduleRun();
@@ -455,7 +455,7 @@ const createWatcher = (
   });
 
   hideCursor();
-  process.on('exit', () => {
+  process.on("exit", () => {
     showCursor();
   });
 
@@ -468,21 +468,21 @@ const createWatcher = (
   // there may be another way to solve this, but it too will be a hack.
   // for our watch tests on win32 we must _fork_ mocha with an IPC channel
   if (process.connected) {
-    process.on('message', msg => {
-      if (msg === 'SIGINT') {
-        process.emit('SIGINT');
+    process.on("message", (msg) => {
+      if (msg === "SIGINT") {
+        process.emit("SIGINT");
       }
     });
   }
 
   let exiting = false;
-  process.on('SIGINT', async () => {
+  process.on("SIGINT", async () => {
     showCursor();
     console.error(`${logSymbols.warning} [mocha] cleaning up, please wait...`);
     if (!exiting) {
       exiting = true;
       if (mocha.hasGlobalTeardownFixtures()) {
-        debug('running global teardown');
+        debug("running global teardown");
         try {
           await mocha.runGlobalTeardown(globalFixtureContext);
         } catch (err) {
@@ -495,10 +495,10 @@ const createWatcher = (
 
   // Keyboard shortcut for restarting when "rs\n" is typed (ala Nodemon)
   process.stdin.resume();
-  process.stdin.setEncoding('utf8');
-  process.stdin.on('data', data => {
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (data) => {
     const str = data.toString().trim().toLowerCase();
-    if (str === 'rs') rerunner.scheduleRun();
+    if (str === "rs") rerunner.scheduleRun();
   });
 
   return watcher;
@@ -515,7 +515,7 @@ const createWatcher = (
  * @ignore
  * @private
  */
-const createRerunner = (mocha, watcher, {beforeRun} = {}) => {
+const createRerunner = (mocha, watcher, { beforeRun } = {}) => {
   // Set to a `Runner` when mocha is running. Set to `null` when mocha is not
   // running.
   let runner = null;
@@ -525,9 +525,9 @@ const createRerunner = (mocha, watcher, {beforeRun} = {}) => {
 
   const run = () => {
     try {
-      mocha = beforeRun ? beforeRun({mocha, watcher}) || mocha : mocha;
+      mocha = beforeRun ? beforeRun({ mocha, watcher }) || mocha : mocha;
       runner = mocha.run(() => {
-        debug('finished watch run');
+        debug("finished watch run");
         runner = null;
         blastCache(watcher);
         if (rerunScheduled) {
@@ -562,7 +562,7 @@ const createRerunner = (mocha, watcher, {beforeRun} = {}) => {
 
   return {
     scheduleRun,
-    run
+    run,
   };
 };
 
@@ -574,14 +574,14 @@ const createRerunner = (mocha, watcher, {beforeRun} = {}) => {
  * @ignore
  * @private
  */
-const getWatchedFiles = watcher => {
+const getWatchedFiles = (watcher) => {
   const watchedDirs = watcher.getWatched();
   return Object.keys(watchedDirs).reduce(
     (acc, dir) => [
       ...acc,
-      ...watchedDirs[dir].map(file => path.join(dir, file))
+      ...watchedDirs[dir].map((file) => path.join(dir, file)),
     ],
-    []
+    [],
   );
 };
 
@@ -591,7 +591,7 @@ const getWatchedFiles = watcher => {
  * @private
  */
 const hideCursor = () => {
-  process.stdout.write('\u001b[?25l');
+  process.stdout.write("\u001b[?25l");
 };
 
 /**
@@ -600,7 +600,7 @@ const hideCursor = () => {
  * @private
  */
 const showCursor = () => {
-  process.stdout.write('\u001b[?25h');
+  process.stdout.write("\u001b[?25h");
 };
 
 /**
@@ -608,7 +608,7 @@ const showCursor = () => {
  * @private
  */
 const eraseLine = () => {
-  process.stdout.write('\u001b[2K');
+  process.stdout.write("\u001b[2K");
 };
 
 /**
@@ -617,10 +617,10 @@ const eraseLine = () => {
  * @ignore
  * @private
  */
-const blastCache = watcher => {
+const blastCache = (watcher) => {
   const files = getWatchedFiles(watcher);
-  files.forEach(file => {
+  files.forEach((file) => {
     delete require.cache[file];
   });
-  debug('deleted %d file(s) from the require cache', files.length);
+  debug("deleted %d file(s) from the require cache", files.length);
 };

package/lib/context.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 /**
  * @typedef {import('./runnable.js')} Runnable

package/lib/error-constants.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 /**
  * When Mocha throws exceptions (or rejects `Promise`s), it attempts to assign a `code` property to the `Error` object, for easier handling. These are the potential values of `code`.
@@ -12,112 +12,112 @@ var constants = {
    * @constant
    * @default
    */
-  FATAL: 'ERR_MOCHA_FATAL',
+  FATAL: "ERR_MOCHA_FATAL",
 
   /**
    * The type of an argument to a function call is invalid
    * @constant
    * @default
    */
-  INVALID_ARG_TYPE: 'ERR_MOCHA_INVALID_ARG_TYPE',
+  INVALID_ARG_TYPE: "ERR_MOCHA_INVALID_ARG_TYPE",
 
   /**
    * The value of an argument to a function call is invalid
    * @constant
    * @default
    */
-  INVALID_ARG_VALUE: 'ERR_MOCHA_INVALID_ARG_VALUE',
+  INVALID_ARG_VALUE: "ERR_MOCHA_INVALID_ARG_VALUE",
 
   /**
    * Something was thrown, but it wasn't an `Error`
    * @constant
    * @default
    */
-  INVALID_EXCEPTION: 'ERR_MOCHA_INVALID_EXCEPTION',
+  INVALID_EXCEPTION: "ERR_MOCHA_INVALID_EXCEPTION",
 
   /**
    * An interface (e.g., `Mocha.interfaces`) is unknown or invalid
    * @constant
    * @default
    */
-  INVALID_INTERFACE: 'ERR_MOCHA_INVALID_INTERFACE',
+  INVALID_INTERFACE: "ERR_MOCHA_INVALID_INTERFACE",
 
   /**
    * A reporter (.e.g, `Mocha.reporters`) is unknown or invalid
    * @constant
    * @default
    */
-  INVALID_REPORTER: 'ERR_MOCHA_INVALID_REPORTER',
+  INVALID_REPORTER: "ERR_MOCHA_INVALID_REPORTER",
 
   /**
    * `done()` was called twice in a `Test` or `Hook` callback
    * @constant
    * @default
    */
-  MULTIPLE_DONE: 'ERR_MOCHA_MULTIPLE_DONE',
+  MULTIPLE_DONE: "ERR_MOCHA_MULTIPLE_DONE",
 
   /**
    * No files matched the pattern provided by the user
    * @constant
    * @default
    */
-  NO_FILES_MATCH_PATTERN: 'ERR_MOCHA_NO_FILES_MATCH_PATTERN',
+  NO_FILES_MATCH_PATTERN: "ERR_MOCHA_NO_FILES_MATCH_PATTERN",
 
   /**
    * Known, but unsupported behavior of some kind
    * @constant
    * @default
    */
-  UNSUPPORTED: 'ERR_MOCHA_UNSUPPORTED',
+  UNSUPPORTED: "ERR_MOCHA_UNSUPPORTED",
 
   /**
    * Invalid state transition occurring in `Mocha` instance
    * @constant
    * @default
    */
-  INSTANCE_ALREADY_RUNNING: 'ERR_MOCHA_INSTANCE_ALREADY_RUNNING',
+  INSTANCE_ALREADY_RUNNING: "ERR_MOCHA_INSTANCE_ALREADY_RUNNING",
 
   /**
    * Invalid state transition occurring in `Mocha` instance
    * @constant
    * @default
    */
-  INSTANCE_ALREADY_DISPOSED: 'ERR_MOCHA_INSTANCE_ALREADY_DISPOSED',
+  INSTANCE_ALREADY_DISPOSED: "ERR_MOCHA_INSTANCE_ALREADY_DISPOSED",
 
   /**
    * Use of `only()` w/ `--forbid-only` results in this error.
    * @constant
    * @default
    */
-  FORBIDDEN_EXCLUSIVITY: 'ERR_MOCHA_FORBIDDEN_EXCLUSIVITY',
+  FORBIDDEN_EXCLUSIVITY: "ERR_MOCHA_FORBIDDEN_EXCLUSIVITY",
 
   /**
    * To be thrown when a user-defined plugin implementation (e.g., `mochaHooks`) is invalid
    * @constant
    * @default
    */
-  INVALID_PLUGIN_IMPLEMENTATION: 'ERR_MOCHA_INVALID_PLUGIN_IMPLEMENTATION',
+  INVALID_PLUGIN_IMPLEMENTATION: "ERR_MOCHA_INVALID_PLUGIN_IMPLEMENTATION",
 
   /**
    * To be thrown when a builtin or third-party plugin definition (the _definition_ of `mochaHooks`) is invalid
    * @constant
    * @default
    */
-  INVALID_PLUGIN_DEFINITION: 'ERR_MOCHA_INVALID_PLUGIN_DEFINITION',
+  INVALID_PLUGIN_DEFINITION: "ERR_MOCHA_INVALID_PLUGIN_DEFINITION",
 
   /**
    * When a runnable exceeds its allowed run time.
    * @constant
    * @default
    */
-  TIMEOUT: 'ERR_MOCHA_TIMEOUT',
+  TIMEOUT: "ERR_MOCHA_TIMEOUT",
 
   /**
    * Input file is not able to be parsed
    * @constant
    * @default
    */
-  UNPARSABLE_FILE: 'ERR_MOCHA_UNPARSABLE_FILE'
+  UNPARSABLE_FILE: "ERR_MOCHA_UNPARSABLE_FILE",
 };
 
 module.exports = { constants };