testem 3.19.0 → 3.20.0

package/lib/runners/browser_test_runner.js

@@ -1,10 +1,9 @@
 
 
-const log = require('npmlog');
+const log = require('../log');
 const BrowserTapConsumer = require('../browser_tap_consumer');
-const Bluebird = require('bluebird');
-
 const LogEntry = require('../utils/log-entry');
+const { asCallback } = require('../utils/promises');
 const toResult = require('./to-result');
 
 module.exports = class BrowserTestRunner {
@@ -33,7 +32,7 @@ module.exports = class BrowserTestRunner {
     this.finished = false;
     this.pending = true;
 
-    return new Bluebird.Promise(resolve => {
+    return new Promise(resolve => {
       this.onFinish = resolve;
 
       if (this.socket) {
@@ -41,26 +40,28 @@ 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 => {
           this.onProcessError(err);
         });
       }
-    }).asCallback(onFinish);
+    }).then(...asCallback(onFinish));
   }
 
   stop(cb) {
     if (this.socket) {
       this.socket.emit('stop-run');
     }
-    return Bluebird.resolve().asCallback(cb);
+    return Promise.resolve().then(...asCallback(cb));
   }
 
   exit() {
     if (!this.process) {
-      return Bluebird.resolve();
+      return Promise.resolve();
     }
 
     // mark that somebody (generally app.js) has requested that the
@@ -119,6 +120,12 @@ module.exports = class BrowserTestRunner {
     socket.on('test-metadata', this.onTestMetadata.bind(this));
     socket.on('top-level-error', this.onGlobalError.bind(this));
 
+    socket.on('tap-debug', function(data) {
+      if (process.env.TESTEM_VERBOSE) {
+        log.verbose('tap-debug', data && data.msg);
+      }
+    });
+
     socket.on('browser-console', function(/* ...args */) {
       let args = Array.prototype.slice.call(arguments);
       let type = args.shift();

package/lib/runners/hook_runner.js

@@ -1,7 +1,7 @@
 
 
-const Bluebird = require('bluebird');
-const log = require('npmlog');
+const { fromCallback, disposer } = require('../utils/promises');
+const log = require('../log');
 
 const template = require('../utils/strutils').template;
 const ProcessCtl = require('../process-ctl');
@@ -11,13 +11,13 @@ module.exports = class HookRunner {
     this.config = config;
   }
 
-  run(hook, data, callback) {
+  run(hook, data) {
     let hookCfg = this.config.get(hook);
     if (!hookCfg) {
-      return Bluebird.resolve();
+      return Promise.resolve();
     }
     if (typeof hookCfg === 'function') {
-      return Bluebird.fromCallback(callback => {
+      return fromCallback(callback => {
         hookCfg(this.config, data, callback);
       });
     }
@@ -55,9 +55,8 @@ module.exports = class HookRunner {
     } else if (exe) {
       args = this.varsub(args || []);
       hookProcessPromise = this.processCtl.spawn(exe, args, options);
-      command = exe + ' ' + args.join(' ');
     } else {
-      return Bluebird.reject(new Error('No command or exe/args specified for hook ' + hook));
+      return Promise.reject(new Error('No command or exe/args specified for hook ' + hook));
     }
 
     waitForTextTimeout = waitForTextTimeout || 10000;
@@ -65,7 +64,7 @@ module.exports = class HookRunner {
 
     let exited = false;
     let finished;
-    let p = new Bluebird.Promise((resolve, reject) => {
+    let p = new Promise((resolve, reject) => {
       finished = (err, stdout, stderr) => {
         if (exited) {
           return;
@@ -109,7 +108,7 @@ module.exports = class HookRunner {
       }
     });
 
-    return p.asCallback(callback);
+    return p;
   }
 
   varsubParams() {
@@ -135,17 +134,19 @@ module.exports = class HookRunner {
       return this.hookProcess.kill();
     }
 
-    return Bluebird.resolve();
+    return Promise.resolve();
   }
 
   static with(config, hook, data) {
     let hookRunner = new HookRunner(config);
 
-    return hookRunner.run(hook, data).catch(err => {
+    let runPromise = hookRunner.run(hook, data).catch(err => {
       log.error(hook + ' error', err);
 
       throw err;
-    }).disposer(() => hookRunner.stop());
+    });
+
+    return disposer(runPromise, () => hookRunner.stop());
   }
 };
 

package/lib/runners/process_test_runner.js

@@ -1,7 +1,6 @@
 
-var Bluebird = require('bluebird');
-
 var toResult = require('./to-result');
+const { asCallback } = require('../utils/promises');
 
 class ProcessTestRunner {
   constructor(launcher, reporter) {
@@ -15,7 +14,7 @@ class ProcessTestRunner {
     this.onStart();
     this.finished = false;
 
-    return new Bluebird.Promise((resolve, reject) => {
+    return new Promise((resolve, reject) => {
       this.onFinish = resolve;
       this.launcher.start().then(testProcess => {
         this.process = testProcess;
@@ -23,12 +22,12 @@ class ProcessTestRunner {
         this.process.once('processError', this.onProcessError.bind(this));
         return Promise.resolve(testProcess);
       }).catch(reject);
-    }).asCallback(onFinish);
+    }).then(...asCallback(onFinish));
   }
 
   exit() {
     if (!this.process) {
-      return Bluebird.resolve();
+      return Promise.resolve();
     }
 
     return this.process.kill();

package/lib/runners/tap_process_test_runner.js

@@ -1,10 +1,9 @@
 
 
 var TapConsumer = require('../tap_consumer');
-var log = require('npmlog');
-var Bluebird = require('bluebird');
-
+var log = require('../log');
 var toResult = require('./to-result');
+const { asCallback } = require('../utils/promises');
 
 class TapProcessTestRunner {
   constructor(launcher, reporter) {
@@ -23,19 +22,19 @@ class TapProcessTestRunner {
     this.tapConsumer.on('test-result', this.onTestResult.bind(this));
     this.tapConsumer.on('all-test-results', this.onAllTestResults.bind(this));
 
-    return new Bluebird.Promise((resolve, reject) => {
+    return new Promise((resolve, reject) => {
       this.onFinish = resolve;
       this.launcher.start().then(tapProcess => {
         this.process = tapProcess;
         this.process.once('processError', this.onProcessError.bind(this));
         this.process.process.stdout.pipe(this.tapConsumer.stream);
       }).catch(reject);
-    }).asCallback(onFinish);
+    }).then(...asCallback(onFinish));
   }
 
   exit() {
     if (!this.process) {
-      return Bluebird.resolve();
+      return Promise.resolve();
     }
 
     return this.process.kill();

package/lib/runners/to-result.js

@@ -1,6 +1,6 @@
 
 
-const log = require('npmlog');
+const log = require('../log');
 
 module.exports = function toResult(launcherId, err, code, runnerProcess, config, testContext) {
   let logs = [];

package/lib/server/index.js

@@ -14,15 +14,13 @@ var socketIO = require('socket.io');
 var compression = require('compression');
 var fs = require('fs');
 var path = require('path');
-var log = require('npmlog');
+var log = require('../log');
 var EventEmitter = require('events').EventEmitter;
 var Mustache = require('consolidate').mustache;
 var http = require('http');
 var https = require('https');
 var httpProxy = require('http-proxy');
-var Bluebird = require('bluebird');
-
-var readFileAsync = Bluebird.promisify(fs.readFile);
+const { fromCallback, each } = require('../utils/promises');
 
 class Server extends EventEmitter {
   constructor(config) {
@@ -37,7 +35,7 @@ class Server extends EventEmitter {
     this.nextSocketId = 0;
   }
 
-  start(callback) {
+  start() {
     this.createExpress();
 
     // Start the server!
@@ -50,7 +48,7 @@ class Server extends EventEmitter {
       });
     });
 
-    return new Bluebird.Promise((resolve, reject) => {
+    return new Promise((resolve, reject) => {
       this.server.on('listening', () => {
         this.config.set('port', this.server.address().port);
         resolve();
@@ -63,23 +61,23 @@ class Server extends EventEmitter {
       });
 
       this.server.listen(this.config.get('port'));
-    }).asCallback(callback);
+    });
   }
 
-  stop(callback) {
+  stop() {
     if (this.server && !this.stopped) {
       this.stopped = true;
 
-      return Bluebird.fromCallback(closeCallback => {
+      return fromCallback(closeCallback => {
         this.server.close(closeCallback);
 
         // Destroy all open sockets
         for (var socketId in this.sockets) {
           this.sockets[socketId].destroy();
         }
-      }).asCallback(callback);
+      });
     } else {
-      return Bluebird.resolve().asCallback(callback);
+      return Promise.resolve();
     }
   }
 
@@ -105,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')) {
@@ -144,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) {
@@ -231,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) {
@@ -281,11 +302,13 @@ class Server extends EventEmitter {
       var url = base + test_page;
       res.redirect(url);
     } else {
-      config.getServeFiles((err, files) => {
-        config.getFooterScripts((err, footerScripts) => {
-          this.renderRunnerPage(err, files, footerScripts, res);
+      Promise.all([config.getServeFiles(), config.getFooterScripts()])
+        .then(([files, footerScripts]) => {
+          this.renderRunnerPage(null, files, footerScripts, res);
+        })
+        .catch(err => {
+          this.renderRunnerPage(err, [], [], res);
         });
-      });
     }
   }
 
@@ -314,11 +337,11 @@ class Server extends EventEmitter {
       'mocha_adapter.js',
       'testem_client.js'
     ];
-    Bluebird.each(files, file => {
+    each(files, file => {
       if (file.indexOf(path.sep) === -1) {
         file = `${__dirname}/../../public/testem/${file}`;
       }
-      return readFileAsync(file).then(data => {
+      return fs.promises.readFile(file).then(data => {
         res.write(`\n//============== ${path.basename(file)} ==================\n\n`);
         res.write(data);
       }).catch(err => {
@@ -376,20 +399,21 @@ class Server extends EventEmitter {
         this.emit('file-requested', filePath);
       });
     } else {
-      fs.stat(filePath, (err, stat) => {
-        this.emit('file-requested', filePath);
-        if (err) {
-          return res.sendFile(filePath);
-        }
-        if (stat.isDirectory()) {
-          fs.readdir(filePath, (err, files) => {
-            var dirListingPage = `${__dirname}/../../views/directorylisting.mustache`;
-            res.render(dirListingPage, { files: files });
-          });
-        } else {
+      fs.promises.stat(filePath)
+        .then(stat => {
+          this.emit('file-requested', filePath);
+          if (stat.isDirectory()) {
+            return fs.promises.readdir(filePath).then(files => {
+              var dirListingPage = `${__dirname}/../../views/directorylisting.mustache`;
+              res.render(dirListingPage, { files: files });
+            });
+          }
           res.sendFile(filePath);
-        }
-      });
+        })
+        .catch(() => {
+          this.emit('file-requested', filePath);
+          res.sendFile(filePath);
+        });
     }
   }
 

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 log = require('npmlog');
+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/browser-args.js

@@ -1,7 +1,7 @@
 
 
 const capitalize = require('./capitalize');
-const log = require('npmlog');
+const log = require('../log');
 const _ = require('lodash');
 
 function Validation() {

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

@@ -0,0 +1,46 @@
+/**
+ * Shared esbuild config for bundling Node.js-dependent test code to run in a
+ * browser via testem.
+ *
+ * `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.
+ *
+ * These two options fix that:
+ *   - `banner.js`: sets `globalThis.process`, `globalThis.setImmediate`, and
+ *     `globalThis.Buffer` before the bundle executes, so CJS factories find
+ *     them as globals.
+ *   - `define`: replaces `__dirname` / `__filename` literals, which esbuild
+ *     does not inject when targeting the browser platform.
+ */
+
+var banner = '(function(){' +
+  'if(typeof process==="undefined"){' +
+    'var p={env:{},browser:true,platform:"browser",' +
+      'nextTick:function(fn){Promise.resolve().then(fn);},' +
+      'on:function(){},once:function(){},off:function(){},' +
+      'emit:function(){},removeListener:function(){},' +
+      'removeAllListeners:function(){},addListener:function(){},' +
+      'binding:function(){throw new Error("process.binding not supported");},' +
+      'cwd:function(){return "/";},' +
+      'exit:function(){}' +
+    '};' +
+    'if(typeof globalThis!=="undefined")globalThis.process=p;' +
+    'else if(typeof window!=="undefined")window.process=p;' +
+  '}' +
+  'if(typeof setImmediate==="undefined"){' +
+    'var si=function(fn){Promise.resolve().then(fn);};' +
+    'if(typeof globalThis!=="undefined")globalThis.setImmediate=si;' +
+    'else if(typeof window!=="undefined")window.setImmediate=si;' +
+  '}' +
+'})();';
+
+module.exports = {
+  banner: { js: banner },
+  bufferInject: require.resolve('./esbuild-buffer-inject.js'),
+  define: {
+    __dirname: '""',
+    __filename: '""'
+  }
+};

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

@@ -0,0 +1,6 @@
+// esbuild inject shim: exposes Buffer as a global for browser bundles.
+// 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; }
+else if (typeof window !== 'undefined') { window.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;