testem 3.19.1 → 3.20.0

package/lib/file_watcher_impl.js

@@ -0,0 +1,295 @@
+/**
+ * Internal `FileWatcher` implementation (see {@link module:lib/file_watcher} for the public API).
+ *
+ * **Third-party pieces in use today:** `chokidar` (filesystem watch engine), `glob` (`hasMagic`
+ * for validating concrete `add` paths), and `minimatch` (include-pattern magic checks). Policy
+ * lists and matching live largely in {@link module:lib/utils/file_watch_glob_policy}.
+ *
+ * Nothing here assumes a single vendor forever: the engine is created only through
+ * {@link FileWatcherImpl.createWatcher} (with `chokidar` loaded lazily there), and glob/minimatch
+ * are confined to small helpers—so swapping the watcher, glob detection, or minimatch usage is
+ * meant to be localized work rather than a rewrite.
+ *
+ * @module lib/file_watcher_impl
+ */
+const path = require('path');
+const EventEmitter = require('events').EventEmitter;
+const { hasMagic } = require('glob');
+const { Minimatch } = require('minimatch');
+
+const isEmfileError = require('./utils/is_emfile_error');
+const { convertToPosix } = require('./utils/posix');
+const {
+  buildWatchGlobPolicy,
+  pathMatchesWatchTarget,
+} = require('./utils/file_watch_glob_policy');
+
+/** @private Only {@link FileWatcherImpl.create} may construct instances. */
+const kInternal = Symbol('FileWatcherImpl.internal');
+
+function includePatternHasGlobMagic(pattern) {
+  return new Minimatch(pattern, { dot: true }).hasMagic();
+}
+
+function resolvedPathIsUnderCwd(resolved) {
+  const rel = path.relative(process.cwd(), resolved);
+  return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+/**
+ * Whether the watch engine's `all` event (add/addDir) refers to the same path as `file` /
+ * `absTarget`.
+ */
+function dynamicAddEventMatchesPath(watchedPath, file, absTarget) {
+  const absWatched = path.resolve(watchedPath);
+  const relWatched = convertToPosix(
+    path.relative(process.cwd(), absWatched),
+  );
+  const relTarget = convertToPosix(
+    path.relative(process.cwd(), absTarget),
+  );
+  return (
+    absWatched === absTarget ||
+    relWatched === relTarget ||
+    watchedPath === file
+  );
+}
+
+class FileWatcherImpl extends EventEmitter {
+  /**
+   * @param {{ get: function(string): *, isCwdMode: function(): boolean }} config
+   * @param {symbol} internalToken
+   */
+  constructor(config, internalToken) {
+    super();
+
+    if (internalToken !== kInternal) {
+      throw new TypeError(
+        'FileWatcherImpl is not constructable; use FileWatcherImpl.create(config)',
+      );
+    }
+
+    const policy = buildWatchGlobPolicy(config);
+    this._watchPolicy = policy;
+    this._explicitWatchRelPaths = new Set();
+    const opts = { ignoreInitial: true };
+    if (policy.ignorePatterns.length) {
+      opts.ignored = policy.ignorePatterns;
+    }
+
+    this.fileWatcher = FileWatcherImpl.createWatcher('.', opts);
+
+    let readySettled = false;
+    this._readyPromise = new Promise((resolve, reject) => {
+      this.fileWatcher.once('ready', () => {
+        readySettled = true;
+        resolve();
+      });
+      this.fileWatcher.once('error', (err) => {
+        if (readySettled || isEmfileError(err)) {
+          return;
+        }
+        readySettled = true;
+        reject(err);
+      });
+    });
+
+    for (let i = 0; i < policy.includePatterns.length; i++) {
+      const pattern = policy.includePatterns[i];
+      if (includePatternHasGlobMagic(pattern)) {
+        continue;
+      }
+      const resolved = path.resolve(process.cwd(), pattern);
+      if (!resolvedPathIsUnderCwd(resolved)) {
+        this.fileWatcher.add(path.normalize(pattern));
+      }
+    }
+
+    const onEngineFsEvent = this.onEngineFsEvent.bind(this);
+    this.fileWatcher.on('change', onEngineFsEvent);
+    this.fileWatcher.on('add', onEngineFsEvent);
+    this.fileWatcher.on('unlink', onEngineFsEvent);
+    this.fileWatcher.on('unlinkDir', onEngineFsEvent);
+    this.fileWatcher.on('error', (err) => {
+      if (isEmfileError(err)) {
+        this.onEMFILE();
+      }
+    });
+  }
+
+  /**
+   * @param {{ get: function(string): *, isCwdMode: function(): boolean }} config
+   * @returns {Promise<FileWatcherImpl>}
+   */
+  static async create(config) {
+    const fw = new FileWatcherImpl(config, kInternal);
+    await fw._readyPromise;
+    return fw;
+  }
+
+  onEngineFsEvent(filePath) {
+    const resolved = path.resolve(filePath);
+    const posixRel = convertToPosix(
+      path.relative(process.cwd(), resolved),
+    );
+    if (
+      pathMatchesWatchTarget(posixRel, this._watchPolicy) ||
+      this._explicitWatchRelPaths.has(posixRel)
+    ) {
+      this.onFileChanged(filePath);
+    }
+  }
+
+  onFileChanged(filePath) {
+    this.emit('fileChanged', filePath);
+  }
+
+  onEMFILE() {
+    this.emit('EMFILE');
+  }
+
+  /**
+   * @param {Error} err
+   * @returns {Promise<never>}
+   */
+  async _closeAfterFailedAdd(err) {
+    try {
+      await this.close();
+    } catch {
+      // ignore close errors; primary error is `err`
+    }
+    throw err;
+  }
+
+  /**
+   * @param {string} file
+   * @returns {Promise<void>}
+   */
+  async _validateConcreteAddPath(file) {
+    if (typeof file !== 'string') {
+      await this._closeAfterFailedAdd(
+        new TypeError('FileWatcher.add expects a string path'),
+      );
+    }
+    if (file.length === 0) {
+      await this._closeAfterFailedAdd(
+        new TypeError('FileWatcher.add expects a non-empty path'),
+      );
+    }
+    if (hasMagic(file, { magicalBraces: true })) {
+      await this._closeAfterFailedAdd(
+        new TypeError(
+          'FileWatcher.add does not accept glob patterns; pass a concrete file path: ' +
+            file,
+        ),
+      );
+    }
+  }
+
+  /**
+   * Wait for dynamic `add` on the engine to settle (`all` add/addDir, `error`, or timeout).
+   *
+   * @param {string} file
+   * @returns {Promise<void>}
+   */
+  async _awaitEngineDynamicAdd(file) {
+    const engine = this.fileWatcher;
+    const absTarget = path.resolve(process.cwd(), file);
+    let onError;
+    let onAll;
+    let timeoutId;
+
+    const cleanup = () => {
+      if (onError) {
+        engine.removeListener('error', onError);
+      }
+      if (onAll) {
+        engine.removeListener('all', onAll);
+      }
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+      }
+    };
+
+    await new Promise((resolve, reject) => {
+      let settled = false;
+
+      const finish = (err) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      };
+
+      onError = (err) => {
+        finish(err);
+      };
+      engine.prependOnceListener('error', onError);
+
+      onAll = (event, watchedPath) => {
+        if (event === 'add' || event === 'addDir') {
+          if (dynamicAddEventMatchesPath(watchedPath, file, absTarget)) {
+            finish();
+          }
+        }
+      };
+      engine.on('all', onAll);
+
+      timeoutId = setTimeout(() => finish(), 1000);
+
+      try {
+        engine.add(file);
+      } catch (err) {
+        finish(err);
+      }
+    });
+  }
+
+  /**
+   * @param {string} file
+   * @returns {Promise<void>}
+   */
+  async add(file) {
+    await this._validateConcreteAddPath(file);
+    const rel = convertToPosix(
+      path.relative(
+        process.cwd(),
+        path.resolve(process.cwd(), file),
+      ),
+    );
+    this._explicitWatchRelPaths.add(rel);
+    try {
+      await this._awaitEngineDynamicAdd(file);
+    } catch (err) {
+      await this._closeAfterFailedAdd(err);
+    }
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  close() {
+    if (this.fileWatcher) {
+      const engine = this.fileWatcher;
+      this.fileWatcher = null;
+      return Promise.resolve(engine.close()).then(() => {
+        this.removeAllListeners();
+      });
+    }
+    this.removeAllListeners();
+    return Promise.resolve();
+  }
+}
+
+/** Lazy `require` keeps chokidar off the load path until a real watcher is built (e.g. tests stub this). */
+FileWatcherImpl.createWatcher = function createWatcher(rootPath, opts) {
+  return require('chokidar').watch(rootPath, opts);
+};
+
+module.exports = FileWatcherImpl;

package/lib/launcher.js

@@ -1,16 +1,12 @@
-
-
 const log = require('./log');
-const tmp = require('tmp');
+const fs = require('fs');
 const path = require('path');
 const { fromCallback } = require('./utils/promises');
+const { registerCleanup } = require('./utils/tmp-cleanup');
 
 const template = require('./utils/strutils').template;
 const ProcessCtl = require('./process-ctl');
 
-// setup graceful cleanup: removes the created directories when an uncaught exception occurs.
-tmp.setGracefulCleanup();
-
 module.exports = class Launcher {
   constructor(name, settings, config) {
     this.name = name;
@@ -126,12 +122,11 @@ module.exports = class Launcher {
 
   setupBrowserTmpDir() {
     const userDataDir = this.config.getUserDataDir();
-    const tmpPath = path.join(userDataDir, 'testem-' + this.id);
+    const tmpPath = path.join(userDataDir, 'testem-' + this.id + '-');
 
-    this.browserTmpDirectory = tmp.dirSync({
-      template: `${tmpPath}-XXXXXX`,
-      unsafeCleanup: true
-    });
+    const dir = fs.mkdtempSync(tmpPath);
+    registerCleanup(dir);
+    this.browserTmpDirectory = dir;
   }
 
   browserTmpDir() {
@@ -139,6 +134,6 @@ module.exports = class Launcher {
       this.setupBrowserTmpDir();
     }
 
-    return this.browserTmpDirectory.name;
+    return this.browserTmpDirectory;
   }
 };

package/lib/reporters/dev/split_log_panel.js

@@ -205,7 +205,6 @@ module.exports = View.extend({
     var runner = this.get('runner');
     var results = runner.get('results');
     var topLevelError = results ? results.get('topLevelError') : null;
-    var tests = null;
     var out = '';
     var pendingOut = '';
 
@@ -213,6 +212,7 @@ module.exports = View.extend({
       out += 'Top Level:\n' + indent(topLevelError) + '\n\n';
     }
 
+    var tests;
     if (results && (tests = results.get('tests')) && !topLevelError) {
       var total = results.get('total');
       var pending = results.get('pending');

package/lib/runners/browser_test_runner.js

@@ -40,7 +40,9 @@ module.exports = class BrowserTestRunner {
       } else {
         this.launcher.start().then(browserProcess => {
           this.process = browserProcess;
-          this.process.on('processExit', this.onProcessExit.bind(this));
+          if (!this.launcher.settings.ignoreProcessExit) {
+            this.process.on('processExit', this.onProcessExit.bind(this));
+          }
           this.process.on('processError', this.onProcessError.bind(this));
           this.setupStartTimer();
         }).catch(err => {

package/lib/runners/hook_runner.js

@@ -55,7 +55,6 @@ module.exports = class HookRunner {
     } else if (exe) {
       args = this.varsub(args || []);
       hookProcessPromise = this.processCtl.spawn(exe, args, options);
-      command = exe + ' ' + args.join(' ');
     } else {
       return Promise.reject(new Error('No command or exe/args specified for hook ' + hook));
     }

package/lib/server/index.js

@@ -103,8 +103,10 @@ class Server extends EventEmitter {
       })
     );
 
+    // In Express 5 (path-to-regexp v8), wildcard params like /*file are captured
+    // as an array of path segments, so we rejoin them with '/' to reconstruct the path.
     var serveStaticFile = (req, res) => {
-      this.serveStaticFile(req.params[0], req, res);
+      this.serveStaticFile('/' + req.params.file.join('/'), req, res);
     };
 
     if (this.config.get('key') || this.config.get('pfx')) {
@@ -142,16 +144,31 @@ class Server extends EventEmitter {
       res.redirect(`/${String(Math.floor(Math.random() * 10000))}`);
     });
 
-    app.get(/\/(-?[0-9]+)$/, (req, res) => {
-      this.serveHomePage(req, res);
-    });
-
     app.get('/testem.js', (req, res) => {
       this.serveTestemClientJs(req, res);
     });
 
-    app.all(/^\/(?:-?[0-9]+)(\/.+)$/, serveStaticFile);
-    app.all(/^(.+)$/, serveStaticFile);
+    // Express 5 dropped regex-in-param syntax (e.g. /:id(-?\d+)), so we match
+    // any single-segment :id and validate numerically in the handler.
+    app.get('/:id', (req, res, next) => {
+      if (/^-?\d+$/.test(req.params.id)) {
+        this.serveHomePage(req, res);
+      } else {
+        next();
+      }
+    });
+
+    // Serve static files prefixed with a numeric browser id (e.g. /1234/web/test.js).
+    // The numeric guard prevents /:id from greedily swallowing non-numeric paths.
+    app.all('/:id/*file', (req, res, next) => {
+      if (/^-?\d+$/.test(req.params.id)) {
+        serveStaticFile(req, res);
+      } else {
+        next();
+      }
+    });
+    // Catch-all: serve any other path as a static file.
+    app.all('/*file', serveStaticFile);
 
     app.use((err, req, res, next) => {
       if (err) {
@@ -229,7 +246,13 @@ class Server extends EventEmitter {
           });
           return;
         }
-        app.all(`${url}*`, (req, res, next) => {
+        // Express 5 no longer accepts bare wildcard segments (e.g. /api*). We
+        // replace each * in the user-supplied proxy URL with a named param, then
+        // append an optional catch-all for trailing path segments.
+        let wIdx = 0;
+        const proxyPath =
+          url.replace(/\*/g, () => `:_proxyW${wIdx++}`).replace(/\/$/, '') + '{/*_proxyRest}';
+        app.all(proxyPath, (req, res, next) => {
           var opts = proxies[url];
           if (this.shouldProxy(req, opts)) {
             if (opts.host) {

package/lib/tap_consumer.js

@@ -3,40 +3,92 @@
 const yaml = require('js-yaml');
 const extend = Object.assign;
 const EventEmitter = require('events').EventEmitter;
-const TapParser = require('tap-parser');
+const { Parser: TapParser } = require('tap-parser');
 const log = require('./log');
 
 module.exports = class TapConsumer extends EventEmitter {
   constructor() {
     super();
 
+    this.namePrefix = '';
+    this.prefixStack = [];
+    this.childParsers = [];
+
     this.stream = new TapParser();
-    this.stream.on('assert', this.onTapAssert.bind(this));
-    this.stream.on('extra', this.onTapExtra.bind(this));
+    this.attachParser(this.stream, true);
+  }
 
-    this.stream.on('complete', this.onTapEnd.bind(this));
-    this.stream.on('bailout', this.onTapError.bind(this));
+  attachParser(parser, isRoot) {
+    parser.on('assert', this.onTapAssert.bind(this));
+    parser.on('extra', this.onTapExtra.bind(this));
+    parser.on('child', this.onChildParser.bind(this));
+    parser.on('complete', this.onParserComplete.bind(this, parser));
+    if (isRoot) {
+      parser.on('bailout', this.onTapError.bind(this));
+    }
   }
 
-  onTapAssert(data) {
-    log.info(data);
-    if (data.skip) {
+  onChildParser(childParser) {
+    this.prefixStack.push(this.namePrefix);
+    const parentPrefix = this.namePrefix;
+    const segment = (childParser.name && childParser.name.trim()) || '';
+    if (parentPrefix && segment) {
+      this.namePrefix = `${parentPrefix} > ${segment}`;
+    } else if (segment) {
+      this.namePrefix = segment;
+    } else if (parentPrefix) {
+      this.namePrefix = parentPrefix;
+    } else {
+      this.namePrefix = '';
+    }
+
+    this.childParsers.push(childParser);
+    this.attachParser(childParser, false);
+  }
+
+  onParserComplete(parser) {
+    if (parser === this.stream) {
+      this.onTapEnd();
       return;
     }
+    this.namePrefix = this.prefixStack.pop();
+    const idx = this.childParsers.indexOf(parser);
+    if (idx !== -1) {
+      this.childParsers.splice(idx, 1);
+    }
+  }
+
+  onTapAssert(data) {
+    log.verbose(JSON.stringify(data, null, 2));
 
     if (data.id === undefined) {
       return;
     }
 
+    const baseName = data.name ? data.name.trim() : '';
+    const qualifiedName = this.namePrefix
+      ? `${this.namePrefix} > ${baseName}`
+      : baseName;
+
     let test = {
       passed: 0,
       failed: 0,
       total: 1,
       id: data.id,
-      name: data.name ? data.name.trim() : '',
+      name: qualifiedName,
       items: []
     };
 
+    if (data.skip) {
+      test.skipped = true;
+      this.emit('test-result', test);
+      return;
+    }
+
+    if (data.todo) {
+      test.todo = true;
+    }
+
     if (!data.ok) {
       let stack;
       if (data.diag) {
@@ -71,6 +123,16 @@ module.exports = class TapConsumer extends EventEmitter {
     }
   }
 
+  detachAllListeners() {
+    this.stream.removeAllListeners();
+    for (const p of this.childParsers) {
+      p.removeAllListeners();
+    }
+    this.childParsers = [];
+    this.prefixStack = [];
+    this.namePrefix = '';
+  }
+
   onTapError(reason) {
     let test = {
       failed: 1,
@@ -81,13 +143,13 @@ module.exports = class TapConsumer extends EventEmitter {
       }
     };
 
-    this.stream.removeAllListeners();
+    this.detachAllListeners();
     this.emit('test-result', test);
     this.emit('all-test-results');
   }
 
   onTapEnd() {
-    this.stream.removeAllListeners();
+    this.detachAllListeners();
     this.emit('all-test-results');
   }
 };

package/lib/utils/esbuild-browser-polyfills.js

@@ -2,7 +2,7 @@
  * Shared esbuild config for bundling Node.js-dependent test code to run in a
  * browser via testem.
  *
- * esbuild's `@esbuild-plugins/node-modules-polyfill` stores the `process`
+ * `esbuild-plugins-node-modules-polyfill` stores the `process`
  * polyfill as a scoped variable inside the IIFE it emits, but CJS module
  * factories (wrapped in `__commonJS`) reference `process`, `__dirname`, and
  * `setImmediate` as free globals — causing ReferenceErrors at runtime.

package/lib/utils/esbuild-buffer-inject.js

@@ -1,5 +1,5 @@
 // esbuild inject shim: exposes Buffer as a global for browser bundles.
-// The @esbuild-plugins/node-modules-polyfill plugin resolves `require('buffer')`
+// The esbuild-plugins-node-modules-polyfill plugin resolves `require('buffer')`
 // to a browser polyfill, but does not assign it to globalThis automatically.
 import { Buffer } from 'buffer';
 if (typeof globalThis !== 'undefined') { globalThis.Buffer = Buffer; }

package/lib/utils/expand_glob_pattern.js

@@ -0,0 +1,19 @@
+const { glob } = require('glob');
+
+/**
+ * Expand one resolved pattern to matching file paths using the project glob backend.
+ *
+ * Callers pass POSIX-style paths (see `convertToPosix`); this keeps options aligned
+ * with `glob` today and allows swapping the implementation later without touching Config.
+ *
+ * @param {string} resolvedPatternPosix - Single pattern (already resolved to absolute or cwd-relative form, forward slashes).
+ * @param {string[]} [ignorePatternsPosix] - Ignore globs in POSIX form; empty entries are dropped.
+ * @returns {Promise<string[]>} Matching paths, sorted lexicographically (same ordering as before extraction).
+ */
+async function expandGlobPattern(resolvedPatternPosix, ignorePatternsPosix) {
+  const ignore = (ignorePatternsPosix || []).filter(Boolean);
+  const files = await glob(resolvedPatternPosix, { ignore });
+  return files.slice().sort();
+}
+
+module.exports = expandGlobPattern;