testem 3.18.0 → 3.19.1

package/lib/api.js

@@ -1,6 +1,6 @@
 
 
-const log = require('npmlog');
+const log = require('./log');
 const Config = require('./config');
 const EventEmitter = require('events').EventEmitter;
 const fs = require('fs');

package/lib/app.js

@@ -1,9 +1,9 @@
 
 
 const EventEmitter = require('events').EventEmitter;
-const Bluebird = require('bluebird');
+const { fromCallback, using, disposer, mapLimit } = require('./utils/promises');
 const Path = require('path');
-const log = require('npmlog');
+const log = require('./log');
 const StyledString = require('styled_string');
 const _ = require('lodash');
 
@@ -64,16 +64,16 @@ module.exports = class App extends EventEmitter {
   start(cb) {
     log.info('Starting ' + this.config.appMode);
 
-    return Bluebird.using(SignalListeners.with(), signalListeners => {
+    return using(SignalListeners.with(), signalListeners => {
       signalListeners.on('signal', err => this.exit(err));
 
-      return Bluebird.using(Reporter.with(this, this.stdoutStream, this.reportFileName), reporter => {
+      return using(Reporter.with(this, this.stdoutStream, this.reportFileName), reporter => {
         this.reporter = reporter;
 
-        return Bluebird.using(this.fileWatch(), () => {
-          return Bluebird.using(this.getServer(), () => {
-            return Bluebird.using(this.getRunners(), () => {
-              return Bluebird.using(this.runHook('on_start'), () => {
+        return using(this.fileWatch(), () => {
+          return using(this.getServer(), () => {
+            return using(this.getRunners(), () => {
+              return using(this.runHook('on_start'), () => {
                 let w = this.waitForTests();
 
                 if (cb) {
@@ -86,15 +86,15 @@ module.exports = class App extends EventEmitter {
 
                 this.emit('tests-finish');
 
-                return Bluebird.using(this.runHook('on_exit'), () => {});
+                return using(this.runHook('on_exit'), () => {});
               }).catch(error => {
                 log.error(error);
                 log.info('Stopping ' + this.config.appMode);
 
                 this.emit('tests-error');
 
-                return new Bluebird((resolve, reject) => {
-                  Bluebird.using(this.runHook('on_exit'), () => {}).then(() => {
+                return new Promise((resolve, reject) => {
+                  using(this.runHook('on_exit'), () => {}).then(() => {
                     reject(error);
                   });
                 });
@@ -103,14 +103,14 @@ module.exports = class App extends EventEmitter {
           });
         });
       });
-    }).asCallback(this.cleanExit);
+    }).then(() => this.cleanExit(), err => this.cleanExit(err));
   }
 
   waitForTests() {
     log.info('Waiting for tests.');
 
     if (this.exited) {
-      return Bluebird.reject(this.exitErr || new Error('Testem exited before running any tests.'));
+      return Promise.reject(this.exitErr || new Error('Testem exited before running any tests.'));
     }
 
     let run = this.triggerRun('Start');
@@ -119,7 +119,7 @@ module.exports = class App extends EventEmitter {
       run.then(() => this.exit());
     }
 
-    return new Bluebird.Promise((resolve, reject) => {
+    return new Promise((resolve, reject) => {
       this.on('testFinish', resolve);
       this.on('testError', reject);
     });
@@ -142,23 +142,23 @@ module.exports = class App extends EventEmitter {
 
   stopCurrentRun() {
     if (!this.currentRun) {
-      return Bluebird.resolve();
+      return Promise.resolve();
     }
 
-    return Bluebird.all([ this.stopRunners(), this.currentRun ]);
+    return Promise.all([ this.stopRunners(), this.currentRun ]);
   }
 
   runTests() {
     if (this.paused) {
-      return Bluebird.resolve();
+      return Promise.resolve();
     }
 
     log.info('Running tests...');
 
     this.reporter.onStart('testem', { launcherId: 0 });
 
-    return Bluebird.using(this.runHook('before_tests'), () => {
-      return Bluebird.using(RunTimeout.with(this.config.get('timeout')), timeout => {
+    return using(this.runHook('before_tests'), () => {
+      return using(RunTimeout.with(this.config.get('timeout')), timeout => {
         this.testSuiteTimeout = timeout;
 
         timeout.on('timeout', () => {
@@ -176,7 +176,7 @@ module.exports = class App extends EventEmitter {
 
         return this.currentRun;
       }).then(() => {
-        return Bluebird.using(this.runHook('after_tests'), () => {});
+        return using(this.runHook('after_tests'), () => {});
       });
     }).catch(err => {
       if (err.hideFromReporter) {
@@ -221,7 +221,7 @@ module.exports = class App extends EventEmitter {
     return;
   }
 
-  startServer(callback) {
+  startServer() {
     log.info('Starting server');
     this.server = new Server(this.config);
     this.server.on('file-requested', this.onFileRequested.bind(this));
@@ -229,11 +229,11 @@ module.exports = class App extends EventEmitter {
     this.server.on('browser-relogin', this.onBrowserRelogin.bind(this));
     this.server.on('server-error', this.onServerError.bind(this));
 
-    return this.server.start().asCallback(callback);
+    return this.server.start();
   }
 
   getServer() {
-    return this.startServer().disposer(() => this.stopServer());
+    return disposer(Promise.resolve(this.startServer()), () => this.stopServer());
   }
 
   onFileRequested(filepath) {
@@ -294,12 +294,12 @@ module.exports = class App extends EventEmitter {
   }
 
   fileWatch() {
-    return this.configureFileWatch().disposer(() => {});
+    return disposer(Promise.resolve(this.configureFileWatch()), () => {});
   }
 
-  configureFileWatch(cb) {
+  configureFileWatch() {
     if (this.config.get('disable_watching')) {
-      return Bluebird.resolve().asCallback(cb);
+      return Promise.resolve();
     }
 
     this.fileWatcher = new FileWatcher(this.config);
@@ -316,7 +316,7 @@ module.exports = class App extends EventEmitter {
           this.triggerRun('Config changed');
         });
       } else {
-        Bluebird.using(this.runHook('on_change', {file: filepath}), () => {
+        using(this.runHook('on_change', {file: filepath}), () => {
           this.triggerRun('File changed: ' + filepath);
         });
       }
@@ -333,13 +333,13 @@ module.exports = class App extends EventEmitter {
       view.setErrorPopupMessage(new StyledString(text + '\n ').foreground('megenta'));
     });
 
-    return Bluebird.resolve().asCallback(cb);
+    return Promise.resolve();
   }
 
   getRunners() {
-    return Bluebird.fromCallback(callback => {
+    return disposer(fromCallback(callback => {
       this.createRunners(callback);
-    }).disposer(() => {
+    }), () => {
       return this.killRunners();
     });
   }
@@ -385,45 +385,38 @@ module.exports = class App extends EventEmitter {
   }
 
   withTestTimeout() {
-    return this.startClock().disposer(() => {
+    return disposer(this.startClock(), () => {
       return this.cancelExistingTimeout();
     });
   }
 
   singleRun(timeout) {
     let limit = this.config.get('parallel');
+    let concurrency = (limit && limit >= 1) ? parseInt(limit) : Infinity;
 
-    let options = {};
-
-    if (limit && limit >= 1) {
-      options.concurrency = parseInt(limit);
-    } else {
-      options.concurrency = Infinity;
-    }
-
-    return Bluebird.map(this.runners, (runner) => {
+    return mapLimit(this.runners, concurrency, runner => {
       if (this.exited) {
         let e = new Error('Run canceled.');
         e.hideFromReporter = true;
-        return Bluebird.reject(e);
+        return Promise.reject(e);
       }
       if (this.restarting) {
-        return Bluebird.resolve();
+        return Promise.resolve();
       }
       return timeout.try(() => runner.start());
-    }, options);
+    });
   }
 
   wrapUp(err) {
     this.exit(err);
   }
 
-  stopServer(callback) {
+  stopServer() {
     if (!this.server) {
-      return Bluebird.resolve().asCallback(callback);
+      return Promise.resolve();
     }
 
-    return this.server.stop().asCallback(callback);
+    return this.server.stop();
   }
 
   getExitCode() {
@@ -442,17 +435,17 @@ module.exports = class App extends EventEmitter {
   }
 
   stopRunners() {
-    return Bluebird.each(this.runners, runner => {
+    return Promise.all(this.runners.map(runner => {
       if (typeof runner.stop === 'function') {
         return runner.stop();
       }
 
       return runner.exit();
-    });
+    }));
   }
 
   killRunners() {
-    return Bluebird.each(this.runners, runner => runner.exit());
+    return Promise.all(this.runners.map(runner => runner.exit()));
   }
 
   launchers() {

package/lib/browser_launcher.js

@@ -8,10 +8,9 @@ This file more or less figures out how to launch any browser on any platform.
 */
 
 
-var Bluebird = require('bluebird');
-
 var fileutils = require('./utils/fileutils');
 var envWithLocalPath = require('./utils/env-with-local-path');
+const { filter, asCallback } = require('./utils/promises');
 
 var executableExists = function(exe, config) {
   return fileutils.executableExists(exe, { env: envWithLocalPath(config) });
@@ -24,7 +23,7 @@ function getAvailableBrowsers(config, browsers, cb) {
     b.protocol = 'browser';
   });
 
-  return Bluebird.filter(browsers, function(browser) {
+  return filter(browsers, function(browser) {
     return isInstalled(browser, config).then(function(result) {
       if (!result) {
         return false;
@@ -33,7 +32,7 @@ function getAvailableBrowsers(config, browsers, cb) {
       browser.exe = result;
       return true;
     });
-  }).asCallback(cb);
+  }).then(...asCallback(cb));
 }
 
 function isInstalled(browser, config) {
@@ -50,11 +49,11 @@ function isInstalled(browser, config) {
 
 function checkBrowser(browser, property, method) {
   if (!browser[property]) {
-    return Bluebird.resolve(false);
+    return Promise.resolve(false);
   }
 
   if (Array.isArray(browser[property])) {
-    return Bluebird.filter(browser[property], method).then(function(result) {
+    return filter(browser[property], method).then(function(result) {
       if (result.length === 0) {
         return false;
       }

package/lib/config.js

@@ -12,12 +12,12 @@ or `testem.json` config file.
 const os = require('os');
 const fs = require('fs');
 const yaml = require('js-yaml');
-const log = require('npmlog');
+const log = require('./log');
 const path = require('path');
-const glob = require('glob');
+const glob = require('glob').glob;
 const url = require('url');
 const querystring = require('querystring');
-const Bluebird = require('bluebird');
+const { filter, reduce } = require('./utils/promises');
 
 const browser_launcher = require('./browser_launcher');
 const LauncherFactory = require('./launcher-factory');
@@ -28,7 +28,8 @@ const fileExists = require('./utils/fileutils').fileExists;
 const _ = require('lodash');
 
 const knownBrowsers = require('./utils/known-browsers');
-const globAsync = Bluebird.promisify(glob);
+const { convertToPosix } = require('./utils/posix');
+const globAsync = glob;
 
 class Config {
   constructor(appMode, progOptions, config) {
@@ -71,7 +72,7 @@ class Config {
       // Try all testem.json, testem.yml and testem.js
       // testem.json gets precedence
       let files = ['testem.json', '.testem.json', '.testem.yml', 'testem.yml', 'testem.js', '.testem.js', 'testem.cjs', '.testem.cjs'];
-      return Bluebird.filter(files.map(this.resolveConfigPath.bind(this)), fileExists).then(matched => {
+      return filter(files.map(this.resolveConfigPath.bind(this)), fileExists).then(matched => {
         let configFile = matched[0];
         if (matched.length > 1) {
           let baseNames = matched.map(fileName => path.basename(fileName));
@@ -157,28 +158,28 @@ class Config {
   }
 
   readYAML(configFile, callback) {
-    fs.readFile(configFile, (err, data) => {
-      if (!err) {
-        let cfg = yaml.load(String(data));
-        this.fileOptions = cfg;
-      }
-      if (callback) {
-        callback.call(this);
-      }
-    });
+    return fs.promises.readFile(configFile)
+      .then(data => {
+        this.fileOptions = yaml.load(String(data));
+      }, () => {})
+      .then(() => {
+        if (callback) {
+          callback.call(this);
+        }
+      });
   }
 
   readJSON(configFile, callback) {
-    fs.readFile(configFile, (err, data) => {
-      if (!err) {
-        let cfg = JSON.parse(data.toString());
-        this.fileOptions = cfg;
+    return fs.promises.readFile(configFile)
+      .then(data => {
+        this.fileOptions = JSON.parse(data.toString());
         this.progOptions.file = configFile;
-      }
-      if (callback) {
-        callback.call(this);
-      }
-    });
+      }, () => {})
+      .then(() => {
+        if (callback) {
+          callback.call(this);
+        }
+      });
   }
 
   mergeUrlAndQueryParams(urlString, queryParamsObj) {
@@ -398,7 +399,7 @@ class Config {
     });
 
     dontWant = dontWant.map(p => p ? this.resolvePath(p) : p);
-    Bluebird.reduce(positiveWants, (allThatIWant, patternEntry) => {
+    return reduce(positiveWants, (allThatIWant, patternEntry) => {
       let pattern = isa(patternEntry, String) ? patternEntry : patternEntry.src;
       let attrs = patternEntry.attrs || [];
       let patternUrl = url.parse(pattern);
@@ -409,33 +410,41 @@ class Config {
         return allThatIWant.concat({ src: pattern, attrs: attrs });
       }
 
-      return globAsync(this.resolvePath(pattern), { ignore: dontWant }).then(files => allThatIWant.concat(files.map(f => {
-        f = this.reverseResolvePath(f);
-        return { src: f, attrs: attrs };
-      })));
+      return globAsync(convertToPosix(this.resolvePath(pattern)), { ignore: dontWant.map(convertToPosix) })
+        .then(files => files.sort())
+        .then(files => allThatIWant.concat(files.map(f => {
+          f = this.reverseResolvePath(f);
+          return { src: f, attrs: attrs };
+        })));
     }, [])
       .then(result => _.uniqBy(result, 'src'))
-      .asCallback(callback);
+      .then(result => {
+        if (callback) { callback(null, result); }
+        return result;
+      }, err => {
+        if (callback) { callback(err); }
+        throw err;
+      });
   }
 
   getSrcFiles(callback) {
     let srcFiles = this.get('src_files') || '*.js';
     let srcFilesIgnore = this.get('src_files_ignore') || '';
-    this.getFileSet(srcFiles, srcFilesIgnore, callback);
+    return this.getFileSet(srcFiles, srcFilesIgnore, callback);
   }
 
   getFooterScripts(callback) {
     var want = this.get('footer_scripts') || [];
     var dontWant = this.get('src_files_ignore') || '';
 
-    this.getFileSet(want, dontWant, callback);
+    return this.getFileSet(want, dontWant, callback);
   }
 
 
   getServeFiles(callback) {
     let want = this.get('serve_files') || this.get('src_files') || '*.js';
     let dontWant = this.get('serve_files_ignore') || this.get('src_files_ignore') || '';
-    this.getFileSet(want, dontWant, callback);
+    return this.getFileSet(want, dontWant, callback);
   }
 
   getUserDataDir() {
@@ -452,7 +461,7 @@ class Config {
 
   getCSSFiles(callback) {
     let want = this.get('css_files') || '';
-    this.getFileSet(want, '', callback);
+    return this.getFileSet(want, '', callback);
   }
 
   getAllOptions() {
@@ -472,7 +481,7 @@ class Config {
     return options;
   }
 
-  getTemplateData(cb) {
+  async getTemplateData(cb) {
     let ret = {};
     let options = this.getAllOptions();
     let key;
@@ -487,24 +496,31 @@ class Config {
     for (key in this.config) {
       ret[key] = this.config[key];
     }
-    this.getServeFiles((err, files) => {
-      let replaceSlashes = f => ({
-        src: f.src.replace(/\\/g, '/'),
-        attrs: f.attrs
-      });
-
-      ret.serve_files = files.map(replaceSlashes);
 
-      this.getCSSFiles((err, files) => {
-        ret.css_files = files.map(replaceSlashes);
-        this.getFooterScripts((err, files) => {
-          ret.footer_scripts = files;
-          if (cb) {
-            cb(err, ret);
-          }
-        });
-      });
+    const replaceSlashes = f => ({
+      src: f.src.replace(/\\/g, '/'),
+      attrs: f.attrs
     });
+
+    try {
+      const [serveFiles, cssFiles, footerScripts] = await Promise.all([
+        this.getServeFiles(),
+        this.getCSSFiles(),
+        this.getFooterScripts()
+      ]);
+
+      ret.serve_files = serveFiles.map(replaceSlashes);
+      ret.css_files = cssFiles.map(replaceSlashes);
+      ret.footer_scripts = footerScripts;
+
+      if (cb) {
+        cb(null, ret);
+      }
+    } catch (err) {
+      if (cb) {
+        cb(err, ret);
+      }
+    }
   }
 }
 

package/lib/launcher.js

@@ -1,9 +1,9 @@
 
 
-const log = require('npmlog');
+const log = require('./log');
 const tmp = require('tmp');
 const path = require('path');
-const Bluebird = require('bluebird');
+const { fromCallback } = require('./utils/promises');
 
 const template = require('./utils/strutils').template;
 const ProcessCtl = require('./process-ctl');
@@ -54,15 +54,11 @@ module.exports = class Launcher {
     const settings = this.settings;
     this.setupBrowserTmpDir();
 
-    return Bluebird.resolve().asCallback(() => {
-      if (settings.setup) {
-        return Bluebird.fromCallback(setupCallback => {
-          settings.setup.call(this, this.config, setupCallback);
-        });
-      }
+    const setupPromise = settings.setup
+      ? fromCallback(setupCallback => settings.setup.call(this, this.config, setupCallback))
+      : Promise.resolve();
 
-      return Bluebird.resolve();
-    }).then(() => this.doLaunch());
+    return setupPromise.then(() => this.doLaunch());
   }
 
   doLaunch() {
@@ -84,7 +80,7 @@ module.exports = class Launcher {
 
       return this.processCtl.exec(cmd, options);
     } else {
-      return Bluebird.reject(new Error('No command or exe/args specified for launcher ' + this.name));
+      return Promise.reject(new Error('No command or exe/args specified for launcher ' + this.name));
     }
   }
 

package/lib/log.js

@@ -0,0 +1,92 @@
+const EventEmitter = require('events');
+const procLog = require('proc-log').log;
+
+class Log extends EventEmitter {
+  constructor() {
+    super();
+    this.stream = process.stderr;
+  }
+
+  formatRecord(level, args) {
+    let prefix = '';
+    let message = '';
+
+    if (args.length === 1) {
+      message = args[0];
+    } else if (args.length >= 2) {
+      prefix = args[0] || '';
+      message = args.slice(1).join(' ');
+    }
+
+    return {
+      level,
+      prefix,
+      message: String(message)
+    };
+  }
+
+  write(record) {
+    if (this.stream && typeof this.stream.write === 'function') {
+      this.stream.write(record.message + '\n');
+    }
+  }
+
+  emitLog(level, args) {
+    const record = this.formatRecord(level, args);
+
+    this.emit(`log.${level}`, record);
+    this.write(record);
+
+    if (procLog && typeof procLog[level] === 'function') {
+      procLog[level](...args);
+    }
+  }
+
+  error(...args) {
+    this.emitLog('error', args);
+  }
+
+  notice(...args) {
+    this.emitLog('notice', args);
+  }
+
+  warn(...args) {
+    this.emitLog('warn', args);
+  }
+
+  info(...args) {
+    this.emitLog('info', args);
+  }
+
+  verbose(...args) {
+    this.emitLog('verbose', args);
+  }
+
+  http(...args) {
+    this.emitLog('http', args);
+  }
+
+  silly(...args) {
+    this.emitLog('silly', args);
+  }
+
+  timing(...args) {
+    this.emitLog('timing', args);
+  }
+
+  pause() {
+    this.emit('log.pause');
+    if (procLog && typeof procLog.pause === 'function') {
+      procLog.pause();
+    }
+  }
+
+  resume() {
+    this.emit('log.resume');
+    if (procLog && typeof procLog.resume === 'function') {
+      procLog.resume();
+    }
+  }
+}
+
+module.exports = new Log();