testem 3.19.0 → 3.20.0

package/lib/utils/process.js

@@ -1,9 +1,9 @@
 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')();
+const closeTimeoutAfterExit = 1000;
 
 module.exports = class Process extends EventEmitter {
   constructor(name, options, process) {
@@ -14,6 +14,9 @@ module.exports = class Process extends EventEmitter {
     this.process = process;
     this.stdout = '';
     this.stderr = '';
+    this.exitAt = null;
+    this._killResolve = null;
+    this._closeFallbackTimer = null;
     this.process.stdout.on('data', chunk => {
       this.stdout += chunk;
       this.emit('out');
@@ -26,6 +29,11 @@ module.exports = class Process extends EventEmitter {
     });
 
     this.process.on('close', this.onClose.bind(this));
+    this.process.on('exit', code => {
+      this.exitAt = Date.now();
+      this.exitCode = code;
+      this.scheduleCloseFallback();
+    });
     this.process.on('error', this.onError.bind(this));
 
     this.process.then(result => {
@@ -38,9 +46,35 @@ module.exports = class Process extends EventEmitter {
     });
   }
 
+  scheduleCloseFallback() {
+    if (!this._killResolve || !this.exitAt || this._closeFallbackTimer || !this._killTimer) {
+      return;
+    }
+
+    this._closeFallbackTimer = setTimeout(() => {
+      this._closeFallbackTimer = null;
+
+      if (!this._killResolve || !this.exitAt) {
+        return;
+      }
+
+      if (this._killTimer) {
+        clearTimeout(this._killTimer);
+        this._killTimer = null;
+      }
+
+      this.process = null;
+
+      const resolve = this._killResolve;
+      this._killResolve = null;
+      resolve(this.exitCode);
+    }, closeTimeoutAfterExit);
+  }
+
   onKillTimeout() {
     log.warn('Process ' + this.name + ' not terminated in ' + this.killTimeout + 'ms.');
     kill(this.process, 'SIGKILL');
+    this.scheduleCloseFallback();
   }
 
   onClose(code) {
@@ -95,15 +129,21 @@ 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._killResolve = resolve;
       self.process.once('close', (code, sig) => {
+        if (self._closeFallbackTimer) {
+          clearTimeout(self._closeFallbackTimer);
+          self._closeFallbackTimer = null;
+        }
+        self._killResolve = null;
         self.process = null;
         if (self._killTimer) {
           clearTimeout(self._killTimer);
@@ -123,6 +163,7 @@ module.exports = class Process extends EventEmitter {
       // See https://github.com/testem/testem/pull/1335 for more information.
       if (self.process) {
         kill(self.process, sig);
+        self.scheduleCloseFallback();
       } else {
         log.info('Process ' + this.name + ' already killed.');
       }

package/lib/utils/promises.js

@@ -0,0 +1,149 @@
+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;
+  let value;
+
+  if (isDisposer) {
+    try {
+      value = await resource.promise;
+    } catch (setupErr) {
+      const inspection = {
+        isRejected: () => true,
+        reason: () => setupErr,
+      };
+      try {
+        await resource.cleanup(undefined, inspection);
+      } catch {
+        // Prefer the setup error below
+      }
+      throw setupErr;
+    }
+  } else {
+    value = await 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,11 +107,11 @@ 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();
 
-    if (!err.hideFromReporter) {
+    if (reporter && !err.hideFromReporter) {
       reporter.report(null, {
         passed: false,
         name: err.name || 'unknown error',
@@ -122,7 +122,7 @@ Reporter.with = (app, stdout, path) => Bluebird.try(() => new Reporter(app, stdo
     }
   }
 
-  return reporter.close();
+  return reporter ? reporter.close() : Promise.resolve();
 });
 
 function forwardToReporters(fn) {

package/lib/utils/run-timeout.js

@@ -1,6 +1,6 @@
 
 
-const Bluebird = require('bluebird');
+const { disposer } = require('./promises');
 const EventEmitter = require('events').EventEmitter;
 
 class RunTimeout {
@@ -11,7 +11,7 @@ class RunTimeout {
   static with(timeout) {
     let runTimeout = new RunTimeout(timeout);
 
-    return runTimeout.start().disposer(() => runTimeout.stop());
+    return disposer(runTimeout.start(), () => runTimeout.stop());
   }
 
   start() {
@@ -23,7 +23,7 @@ class RunTimeout {
       }, this.timeout * 1000);
     }
 
-    return Bluebird.resolve(this);
+    return Promise.resolve(this);
   }
 
   setTimedOut() {
@@ -39,7 +39,7 @@ class RunTimeout {
 
   try(fn) {
     if (this.timedOut) {
-      return Bluebird.reject(new Error('Run timed out.'));
+      return Promise.reject(new Error('Run timed out.'));
     }
 
     return fn();

package/lib/utils/signal-listeners.js

@@ -1,17 +1,17 @@
 
 
-const Bluebird = require('bluebird');
+const { disposer } = require('./promises');
 const EventEmitter = require('events').EventEmitter;
 
 class SignalListeners extends EventEmitter {
   static with() {
     let signalListeners = new this();
 
-    return signalListeners.add().disposer(() => signalListeners.remove());
+    return disposer(signalListeners.add(), () => signalListeners.remove());
   }
 }
 
-SignalListeners.prototype.add = Bluebird.method(function() {
+SignalListeners.prototype.add = function() {
   this._boundSigInterrupt = () => {
     this.emit('signal', new Error('Received SIGINT signal'));
   };
@@ -23,16 +23,18 @@ SignalListeners.prototype.add = Bluebird.method(function() {
   };
   process.on('SIGTERM', this._boundSigTerminate);
 
-  return this;
-});
+  return Promise.resolve(this);
+};
 
-SignalListeners.prototype.remove = Bluebird.method(function() {
+SignalListeners.prototype.remove = function() {
   if (this._boundSigInterrupt) {
     process.removeListener('SIGINT', this._boundSigInterrupt);
   }
   if (this._boundSigTerminate) {
     process.removeListener('SIGTERM', this._boundSigTerminate);
   }
-});
+
+  return Promise.resolve();
+};
 
 module.exports = SignalListeners;

package/lib/utils/tmp-cleanup.js

@@ -0,0 +1,26 @@
+
+
+const fs = require('fs');
+
+const dirsToClean = new Set();
+
+process.on('exit', () => {
+  for (const dir of dirsToClean) {
+    try {
+      fs.rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // Best-effort cleanup: ignore errors during process exit
+    }
+  }
+});
+
+// Allow graceful cleanup when the process is terminated by a signal.
+// Calling process.exit() ensures the 'exit' event fires and cleanup runs.
+process.on('SIGTERM', () => process.exit(0));
+process.on('SIGINT',  () => process.exit(130));
+
+function registerCleanup(dir) {
+  dirsToClean.add(dir);
+}
+
+module.exports = { registerCleanup, _registeredDirs: dirsToClean };

package/package.json

@@ -7,7 +7,7 @@
     "unittest",
     "browser"
   ],
-  "version": "3.19.0",
+  "version": "3.20.0",
   "author": "Toby Ho <airportyh@gmail.com>",
   "repository": {
     "type": "git",
@@ -17,35 +17,34 @@
     "url": "http://github.com/testem/testem/issues"
   },
   "engines": {
-    "node": ">= 7.*"
+    "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
   },
   "license": "MIT",
   "dependencies": {
-    "@xmldom/xmldom": "^0.8.0",
-    "backbone": "^1.1.2",
-    "bluebird": "^3.4.6",
-    "charm": "^1.0.0",
-    "commander": "^2.6.0",
-    "compression": "^1.7.4",
-    "consolidate": "^0.16.0",
+    "@xmldom/xmldom": "^0.9.9",
+    "backbone": "^1.6.1",
+    "charm": "^1.0.2",
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.3",
+    "compression": "^1.8.1",
+    "consolidate": "^1.0.4",
     "execa": "^9.6.1",
-    "express": "^4.10.7",
-    "fireworm": "^0.7.2",
+    "express": "^5.2.1",
     "glob": "^13.0.6",
-    "http-proxy": "^1.13.1",
-    "js-yaml": "^3.2.5",
-    "lodash": "^4.17.21",
+    "http-proxy": "^1.18.1",
+    "js-yaml": "^4.1.1",
+    "lodash": "^4.18.1",
+    "minimatch": "^10.2.5",
     "mkdirp": "^3.0.1",
     "mustache": "^4.2.0",
-    "node-notifier": "^10.0.0",
-    "npmlog": "^6.0.0",
+    "node-notifier": "^10.0.1",
     "printf": "^0.6.1",
+    "proc-log": "^6.1.0",
     "rimraf": "^6.1.3",
-    "socket.io": "^4.5.4",
+    "socket.io": "^4.8.3",
     "spawn-args": "^0.2.0",
     "styled_string": "0.0.1",
-    "tap-parser": "^7.0.0",
-    "tmp": "^0.2.5"
+    "tap-parser": "^18.3.0"
   },
   "files": [
     "lib",
@@ -59,30 +58,41 @@
   "scripts": {
     "install:all": "npm install && npm install phantomjs-prebuilt",
     "test": "mocha tests/*_tests.js tests/**/*_tests.js",
+    "test:verbose": "TESTEM_VERBOSE=1 mocha tests/*_tests.js tests/**/*_tests.js",
     "cover": "cover run ./node_modules/.bin/_mocha tests/*_tests.js tests/**/*_tests.js; cover report html; open cover_html/index.html",
     "integration": "node ./bin/run-integration.js",
+    "ci:safari-smoke": "node ./scripts/safari-ci-smoke.js",
     "browser-tests": "cd examples/saucelabs/ && ../../testem.js ci -d",
     "lint": "eslint ."
   },
   "devDependencies": {
-    "bluebird-retry": "^0.11.0",
-    "browserify": "^17.0.0",
+    "@cypress/request": "^3.0.10",
+    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/js": "^10.0.1",
     "chai": "^6.2.2",
-    "chai-files": "^1.2.0",
-    "chai-shallow-deep-equal": "^1.4.4",
-    "cheerio": "1.0.0-rc.12",
+    "chai-files": "^1.4.0",
+    "chai-shallow-deep-equal": "^1.4.6",
+    "cheerio": "^1.2.0",
     "dirty-chai": "^3.0.0",
-    "eslint": "^9.39.4",
-    "eslint-plugin-chai-expect": "^3.1.0",
+    "esbuild": "^0.27.4",
+    "esbuild-plugins-node-modules-polyfill": "^1.8.1",
+    "eslint": "^10.2.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-chai-expect": "^4.0.0",
     "eslint-plugin-mocha": "^11.2.0",
+    "fresh-tape": "^5.9.1",
     "mocha": "^11.7.5",
-    "request": "^2.51.0",
-    "saucie": "^3.3.3",
-    "shelljs": "^0.8.2",
-    "sinon": "10.0.0",
+    "saucie": "^4.0.1",
+    "sinon": "^21.0.3",
     "sinon-chai": "^4.0.1",
-    "socket.io-client": "^4.1.2",
-    "tape": "^5.2.2"
+    "socket.io-client": "^4.8.3"
+  },
+  "overrides": {
+    "mocha": {
+      "diff": "^8.0.3",
+      "minimatch": "^9.0.7",
+      "serialize-javascript": "^7.0.5"
+    }
   },
   "bin": {
     "testem": "./testem.js"