testem 3.18.0 → 3.19.1

package/lib/utils/process.js

@@ -1,8 +1,5 @@
-
-
-const execa = require('execa');
-const log = require('npmlog');
-const Bluebird = require('bluebird');
+const execa = require('execa').execa;
+const log = require('../log');
 const EventEmitter = require('events').EventEmitter;
 
 const isWin = require('./is-win')();
@@ -29,6 +26,15 @@ module.exports = class Process extends EventEmitter {
 
     this.process.on('close', this.onClose.bind(this));
     this.process.on('error', this.onError.bind(this));
+
+    this.process.then(result => {
+      if (result.failed && result.exitCode !== 0 &&
+        result.shortMessage.includes(isWin ? 'is not recognized' : 'ENOENT'))
+      {
+        this.onError(new Error(result.shortMessage), this.stdout, this.stderr);
+      }
+      return Promise.resolve(result);
+    });
   }
 
   onKillTimeout() {
@@ -48,7 +54,7 @@ module.exports = class Process extends EventEmitter {
 
   onError(error) {
     log.warn(this.name + ' errored', error);
-    this.process = null;
+    // this.process = null;
     this.exitCode = 1;
     this.emit('processError', error, this.stdout, this.stderr);
   }
@@ -88,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) {
@@ -132,14 +138,18 @@ function kill(p, sig) {
       args.push('/f');
     }
 
-    execa(command, args).then(result => {
+    const killProcess = execa(command, args, { reject: false });
+
+    killProcess.on('error', err => {
+      log.error(err);
+    });
+
+    killProcess.then(result => {
       // Processes without windows can't be killed without /F, detect and force
       // kill them directly
       if (result.stderr.indexOf('can only be terminated forcefully') !== -1) {
         kill(p, 'SIGKILL');
       }
-    }).catch(err => {
-      log.error(err);
     });
   } else {
     p.kill(sig);

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();
 

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/package.json

@@ -7,7 +7,7 @@
     "unittest",
     "browser"
   ],
-  "version": "3.18.0",
+  "version": "3.19.1",
   "author": "Toby Ho <airportyh@gmail.com>",
   "repository": {
     "type": "git",
@@ -23,24 +23,23 @@
   "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",
-    "execa": "^1.0.0",
+    "consolidate": "^1.0.4",
+    "execa": "^9.6.1",
     "express": "^4.10.7",
     "fireworm": "^0.7.2",
-    "glob": "^7.0.4",
+    "glob": "^13.0.6",
     "http-proxy": "^1.13.1",
     "js-yaml": "^3.2.5",
     "lodash": "^4.17.21",
     "mkdirp": "^3.0.1",
     "mustache": "^4.2.0",
     "node-notifier": "^10.0.0",
-    "npmlog": "^6.0.0",
     "printf": "^0.6.1",
-    "rimraf": "^3.0.2",
+    "proc-log": "^5.0.0",
+    "rimraf": "^6.1.3",
     "socket.io": "^4.5.4",
     "spawn-args": "^0.2.0",
     "styled_string": "0.0.1",
@@ -59,30 +58,30 @@
   "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",
     "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",
+    "@esbuild-plugins/node-modules-polyfill": "^0.2.2",
     "chai": "^6.2.2",
     "chai-files": "^1.2.0",
     "chai-shallow-deep-equal": "^1.4.4",
     "cheerio": "1.0.0-rc.12",
     "dirty-chai": "^3.0.0",
+    "esbuild": "^0.25.1",
     "eslint": "^9.39.4",
     "eslint-plugin-chai-expect": "^3.1.0",
     "eslint-plugin-mocha": "^11.2.0",
+    "fresh-tape": "^5.5.3",
     "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.1.2"
   },
   "bin": {
     "testem": "./testem.js"