testem 3.19.0 → 3.19.1

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) {
@@ -48,19 +47,19 @@ module.exports = class BrowserTestRunner {
           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 +118,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);
       });
     }
@@ -57,7 +57,7 @@ module.exports = class HookRunner {
       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 +65,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 +109,7 @@ module.exports = class HookRunner {
       }
     });
 
-    return p.asCallback(callback);
+    return p;
   }
 
   varsubParams() {
@@ -135,17 +135,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();
     }
   }
 
@@ -281,11 +279,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 +314,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 +376,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

@@ -4,7 +4,7 @@ const yaml = require('js-yaml');
 const extend = Object.assign;
 const EventEmitter = require('events').EventEmitter;
 const TapParser = require('tap-parser');
-const log = require('npmlog');
+const log = require('./log');
 
 module.exports = class TapConsumer extends EventEmitter {
   constructor() {

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's `@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/fileutils.js

@@ -2,15 +2,15 @@
 
 const fs = require('fs');
 const execa = require('execa').execa;
-const Bluebird = require('bluebird');
-const log = require('npmlog');
+const { promisify } = require('util');
+const log = require('../log');
 
-const fsStatAsync = Bluebird.promisify(fs.stat);
+const fsStatAsync = promisify(fs.stat);
 
 const isWin = require('./is-win')();
 
 exports.fileExists = function fileExists(path) {
-  return fsStatAsync(path).then(stat => stat.isFile()).catchReturn(false);
+  return fsStatAsync(path).then(stat => stat.isFile()).catch(() => false);
 };
 
 exports.executableExists = function executableExists(exe, options) {

package/lib/utils/known-browsers.js

@@ -95,24 +95,25 @@ function firefoxSetup(browserTmpDir, config, done) {
   let perfJS = path.join(browserTmpDir, 'user.js');
 
   if (config.get('firefox_user_js')) {
-    return fs.readFile(config.get('firefox_user_js'), (err, content) => {
-      if (err) {
-        return done(err);
-      }
-
-      fs.writeFile(perfJS, content, done);
-    });
+    return fs.promises.readFile(config.get('firefox_user_js'))
+      .then(content => fs.promises.writeFile(perfJS, content))
+      .then(() => done(null), done);
   }
 
-  // using user.js to suppress the check default browser popup
-  // and the welcome start page
+  // using user.js to suppress the check default browser popup,
+  // the welcome start page, and first-run helper installation prompts
   let prefs = [
     'user_pref("browser.shell.checkDefaultBrowser", false);',
     'user_pref("browser.cache.disk.smart_size.first_run", false);',
     'user_pref("datareporting.policy.dataSubmissionEnabled", false);',
-    'user_pref("datareporting.policy.dataSubmissionPolicyNotifiedTime", "1481830156314");'
+    'user_pref("datareporting.policy.dataSubmissionPolicyNotifiedTime", "1481830156314");',
+    'user_pref("app.update.auto", false);',
+    'user_pref("app.update.enabled", false);',
+    'user_pref("browser.EULA.override", true);',
+    'user_pref("toolkit.telemetry.reportingpolicy.firstRun", false);'
   ];
-  fs.writeFile(perfJS, prefs.join(os.EOL), done);
+  fs.promises.writeFile(perfJS, prefs.join(os.EOL))
+    .then(() => done(null), done);
 }
 
 // Return the catalogue of the browsers that Testem supports for the platform. Each 'browser object'

package/lib/utils/process.js

@@ -1,6 +1,5 @@
 const execa = require('execa').execa;
-const log = require('npmlog');
-const Bluebird = require('bluebird');
+const log = require('../log');
 const EventEmitter = require('events').EventEmitter;
 
 const isWin = require('./is-win')();
@@ -95,14 +94,14 @@ module.exports = class Process extends EventEmitter {
     if (!this.process) {
       log.info('Process ' + this.name + ' already killed.');
 
-      return Bluebird.resolve(this.exitCode);
+      return Promise.resolve(this.exitCode);
     }
 
     sig = sig || 'SIGTERM';
 
     let self = this;
 
-    return new Bluebird.Promise(resolve => {
+    return new Promise(resolve => {
       self.process.once('close', (code, sig) => {
         self.process = null;
         if (self._killTimer) {

package/lib/utils/promises.js

@@ -0,0 +1,130 @@
+function fromCallback(fn) {
+  return new Promise((resolve, reject) => {
+    fn((err, result) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(result);
+      }
+    });
+  });
+}
+
+async function filter(arr, predicate) {
+  const results = await Promise.all(arr.map(item => predicate(item)));
+  return arr.filter((_, i) => results[i]);
+}
+
+function reduce(arr, reducer, initialValue) {
+  return arr.reduce(
+    (acc, item) => acc.then(a => reducer(a, item)),
+    Promise.resolve(initialValue)
+  );
+}
+
+function each(arr, fn) {
+  return arr.reduce(
+    (p, item) => p.then(() => fn(item)),
+    Promise.resolve()
+  ).then(() => arr);
+}
+
+class Disposer {
+  constructor(promise, cleanup) {
+    this.promise = Promise.resolve(promise);
+    this.cleanup = cleanup;
+  }
+}
+
+function disposer(promise, cleanup) {
+  return new Disposer(promise, cleanup);
+}
+
+async function using(resource, fn) {
+  const isDisposer = resource instanceof Disposer;
+  const value = await (isDisposer ? resource.promise : resource);
+
+  let result, rejected = false, error;
+
+  try {
+    result = await fn(value);
+  } catch (err) {
+    rejected = true;
+    error = err;
+  }
+
+  if (isDisposer) {
+    const inspection = {
+      isRejected: () => rejected,
+      reason: () => error,
+    };
+
+    try {
+      await resource.cleanup(value, inspection);
+    } catch (cleanupErr) {
+      if (!rejected) {
+        // Callback succeeded but cleanup failed — surface cleanup error
+        throw cleanupErr;
+      }
+      // Both callback and cleanup failed — suppress cleanup error, re-throw original below
+    }
+  }
+
+  if (rejected) {
+    throw error;
+  }
+  return result;
+}
+
+function mapLimit(arr, concurrency, fn) {
+  if (!isFinite(concurrency) || concurrency >= arr.length) {
+    return Promise.all(arr.map(fn));
+  }
+
+  let index = 0;
+  let results = new Array(arr.length);
+
+  function next() {
+    let i = index++;
+    if (i >= arr.length) {
+      return Promise.resolve();
+    }
+
+    return Promise.resolve(fn(arr[i])).then(result => {
+      results[i] = result;
+      return next();
+    });
+  }
+
+  let workers = [];
+  for (let w = 0; w < Math.min(concurrency, arr.length); w++) {
+    workers.push(next());
+  }
+
+  return Promise.all(workers).then(() => results);
+}
+
+async function retry(fn, { max_tries = 3 } = {}) {
+  let lastErr;
+  for (let i = 0; i < max_tries; i++) {
+    try {
+      return await fn();
+    } catch (e) {
+      lastErr = e;
+    }
+  }
+  throw lastErr;
+}
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function asCallback(cb) {
+  return [
+    result => { if (cb) { cb(null, result); } return result; },
+    err => { if (cb) { cb(err); } throw err; }
+  ];
+}
+
+module.exports = { fromCallback, filter, reduce, each, mapLimit, retry, delay, asCallback, Disposer, disposer, using };

package/lib/utils/report-file.js

@@ -4,8 +4,6 @@ const fs = require('fs');
 const path = require('path');
 const mkdirp = require('mkdirp');
 const PassThrough = require('stream').PassThrough;
-const Bluebird = require('bluebird');
-
 module.exports = class ReportFile {
   constructor(reportFile) {
     this.file = reportFile;
@@ -27,7 +25,7 @@ module.exports = class ReportFile {
     this.outputStream.on('end', finish);
     this.outputStream.on('error', finish);
 
-    this.closePromise = new Bluebird.Promise((resolve, reject) => {
+    this.closePromise = new Promise((resolve, reject) => {
       this.outputStream.on('finish', resolve);
       this.outputStream.on('error', reject);
     });

package/lib/utils/reporter.js

@@ -1,7 +1,7 @@
 
 
-const Bluebird = require('bluebird');
-const log = require('npmlog');
+const { disposer } = require('./promises');
+const log = require('../log');
 
 const reporters = require('../reporters');
 const isa = require('./isa');
@@ -107,7 +107,7 @@ class Reporter {
   }
 }
 
-Reporter.with = (app, stdout, path) => Bluebird.try(() => new Reporter(app, stdout, path)).disposer((reporter, promise) => {
+Reporter.with = (app, stdout, path) => disposer(Promise.resolve(new Reporter(app, stdout, path)), (reporter, promise) => {
   if (promise.isRejected()) {
     let err = promise.reason();