testem 3.19.1 → 3.20.1

package/lib/app.js

@@ -1,5 +1,3 @@
-
-
 const EventEmitter = require('events').EventEmitter;
 const { fromCallback, using, disposer, mapLimit } = require('./utils/promises');
 const Path = require('path');
@@ -40,7 +38,7 @@ module.exports = class App extends EventEmitter {
 
     let alreadyExit = false;
 
-    this.cleanExit = err => {
+    this.cleanExit = (err) => {
       if (!alreadyExit) {
         alreadyExit = true;
 
@@ -52,7 +50,9 @@ module.exports = class App extends EventEmitter {
 
         if (this.testSuiteTimedOut === true) {
           let timeoutSeconds = this.testSuiteTimeout.timeout;
-          err = new Error(`Test suite execution has timed out (config.timeout = ${timeoutSeconds} seconds). Terminated all test runners.`);
+          err = new Error(
+            `Test suite execution has timed out (config.timeout = ${timeoutSeconds} seconds). Terminated all test runners.`,
+          );
           exitCode = 1;
         }
 
@@ -64,53 +64,63 @@ module.exports = class App extends EventEmitter {
   start(cb) {
     log.info('Starting ' + this.config.appMode);
 
-    return using(SignalListeners.with(), signalListeners => {
-      signalListeners.on('signal', err => this.exit(err));
+    return using(SignalListeners.with(), (signalListeners) => {
+      signalListeners.on('signal', (err) => this.exit(err));
 
-      return using(Reporter.with(this, this.stdoutStream, this.reportFileName), reporter => {
-        this.reporter = reporter;
+      return using(
+        Reporter.with(this, this.stdoutStream, this.reportFileName),
+        (reporter) => {
+          this.reporter = reporter;
 
-        return using(this.fileWatch(), () => {
-          return using(this.getServer(), () => {
-            return using(this.getRunners(), () => {
-              return using(this.runHook('on_start'), () => {
-                let w = this.waitForTests();
+          return using(this.fileWatch(), () => {
+            return using(this.getServer(), () => {
+              return using(this.getRunners(), () => {
+                return using(this.runHook('on_start'), () => {
+                  let w = this.waitForTests();
 
-                if (cb) {
-                  cb();
-                }
+                  if (cb) {
+                    cb();
+                  }
 
-                return w;
-              }).then(() => {
-                log.info('Stopping ' + this.config.appMode);
+                  return w;
+                })
+                  .then(() => {
+                    log.info('Stopping ' + this.config.appMode);
 
-                this.emit('tests-finish');
+                    this.emit('tests-finish');
 
-                return using(this.runHook('on_exit'), () => {});
-              }).catch(error => {
-                log.error(error);
-                log.info('Stopping ' + this.config.appMode);
+                    return using(this.runHook('on_exit'), () => {});
+                  })
+                  .catch((error) => {
+                    log.error(error);
+                    log.info('Stopping ' + this.config.appMode);
 
-                this.emit('tests-error');
+                    this.emit('tests-error');
 
-                return new Promise((resolve, reject) => {
-                  using(this.runHook('on_exit'), () => {}).then(() => {
-                    reject(error);
+                    return new Promise((resolve, reject) => {
+                      using(this.runHook('on_exit'), () => {}).then(() => {
+                        reject(error);
+                      });
+                    });
                   });
-                });
               });
             });
           });
-        });
-      });
-    }).then(() => this.cleanExit(), err => this.cleanExit(err));
+        },
+      );
+    }).then(
+      () => this.cleanExit(),
+      (err) => this.cleanExit(err),
+    );
   }
 
   waitForTests() {
     log.info('Waiting for tests.');
 
     if (this.exited) {
-      return Promise.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');
@@ -133,11 +143,13 @@ module.exports = class App extends EventEmitter {
     }
     this.restarting = true;
 
-    return this.stopCurrentRun().catch(this.exit.bind(this)).then(() => {
-      this.restarting = false;
+    return this.stopCurrentRun()
+      .catch(this.exit.bind(this))
+      .then(() => {
+        this.restarting = false;
 
-      return this.runTests();
-    });
+        return this.runTests();
+      });
   }
 
   stopCurrentRun() {
@@ -145,7 +157,7 @@ module.exports = class App extends EventEmitter {
       return Promise.resolve();
     }
 
-    return Promise.all([ this.stopRunners(), this.currentRun ]);
+    return Promise.all([this.stopRunners(), this.currentRun]);
   }
 
   runTests() {
@@ -158,13 +170,15 @@ module.exports = class App extends EventEmitter {
     this.reporter.onStart('testem', { launcherId: 0 });
 
     return using(this.runHook('before_tests'), () => {
-      return using(RunTimeout.with(this.config.get('timeout')), timeout => {
+      return using(RunTimeout.with(this.config.get('timeout')), (timeout) => {
         this.testSuiteTimeout = timeout;
 
         timeout.on('timeout', () => {
           let timeoutSeconds = timeout.timeout;
 
-          log.info(`Test suite execution has timed out (config.timeout = ${timeoutSeconds} seconds). Terminating all test runners`);
+          log.info(
+            `Test suite execution has timed out (config.timeout = ${timeoutSeconds} seconds). Terminating all test runners`,
+          );
           this.testSuiteTimedOut = true;
           this.killRunners();
         });
@@ -178,23 +192,25 @@ module.exports = class App extends EventEmitter {
       }).then(() => {
         return using(this.runHook('after_tests'), () => {});
       });
-    }).catch(err => {
-      if (err.hideFromReporter) {
-        return;
-      }
-
-      let result = {
-        failed: 1,
-        passed: 0,
-        name: 'testem',
-        launcherId: 0,
-        error: {
-          message: err.toString()
+    })
+      .catch((err) => {
+        if (err.hideFromReporter) {
+          return;
         }
-      };
 
-      this.reporter.report('testem', result);
-    }).finally(() => this.reporter.onEnd('testem', { launcherId: 0 }));
+        let result = {
+          failed: 1,
+          passed: 0,
+          name: 'testem',
+          launcherId: 0,
+          error: {
+            message: err.toString(),
+          },
+        };
+
+        this.reporter.report('testem', result);
+      })
+      .finally(() => this.reporter.onEnd('testem', { launcherId: 0 }));
   }
 
   exit(err, cb) {
@@ -233,12 +249,25 @@ module.exports = class App extends EventEmitter {
   }
 
   getServer() {
-    return disposer(Promise.resolve(this.startServer()), () => this.stopServer());
+    return disposer(Promise.resolve(this.startServer()), () =>
+      this.stopServer(),
+    );
   }
 
-  onFileRequested(filepath) {
+  /**
+   * When the server requests a file, add it to the file watcher if it is not already being watched.
+   * If the file watcher is disabled, do nothing.
+   *
+   * @param {string} filepath
+   * @returns {Promise<void>}
+   */
+  async onFileRequested(filepath) {
     if (this.fileWatcher && !this.config.get('serve_files')) {
-      this.fileWatcher.add(filepath);
+      try {
+        await this.fileWatcher.add(filepath);
+      } catch (err) {
+        log.error(err);
+      }
     }
   }
 
@@ -251,18 +280,30 @@ module.exports = class App extends EventEmitter {
   }
 
   onBrowserLogin(browserName, id, socket) {
-    let browser = _.find(this.runners, runner => {
-      return runner.launcherId === id && (!runner.socket || !runner.socket.connected);
+    let browser = _.find(this.runners, (runner) => {
+      return (
+        runner.launcherId === id && (!runner.socket || !runner.socket.connected)
+      );
     });
 
     if (!browser) {
-      let launcher = new LauncherFactory(browserName, {
-        id: id,
-        protocol: 'browser'
-      }, this.config).create();
+      let launcher = new LauncherFactory(
+        browserName,
+        {
+          id: id,
+          protocol: 'browser',
+        },
+        this.config,
+      ).create();
       const singleRun = this.config.get('single_run');
 
-      browser = new BrowserTestRunner(launcher, this.reporter, this.runnerIndex++, singleRun, this.config);
+      browser = new BrowserTestRunner(
+        launcher,
+        this.reporter,
+        this.runnerIndex++,
+        singleRun,
+        this.config,
+      );
       this.addRunner(browser);
     }
 
@@ -270,10 +311,12 @@ module.exports = class App extends EventEmitter {
   }
 
   onBrowserRelogin(browserName, id, socket) {
-    let browser = _.find(this.runners, runner => {
+    let browser = _.find(this.runners, (runner) => {
       // a browser relogin can happen if a client socket was disconnected, which may not be reflected in runner.socket's connected state
       // or if the socket was nulled by 'onDisconnect'
-      return runner.launcherId === id && (runner.socket || runner.socket === null);
+      return (
+        runner.launcherId === id && (runner.socket || runner.socket === null)
+      );
     });
 
     if (!browser) {
@@ -293,8 +336,15 @@ module.exports = class App extends EventEmitter {
     this.emit('runnerAdded', runner);
   }
 
+  // Watcher teardown is this disposer's cleanup (using() awaits it on success and on setup failure).
   fileWatch() {
-    return disposer(Promise.resolve(this.configureFileWatch()), () => {});
+    return disposer(Promise.resolve(this.configureFileWatch()), () => {
+      if (this.fileWatcher) {
+        const w = this.fileWatcher;
+        this.fileWatcher = undefined;
+        return w.close();
+      }
+    });
   }
 
   configureFileWatch() {
@@ -302,46 +352,58 @@ module.exports = class App extends EventEmitter {
       return Promise.resolve();
     }
 
-    this.fileWatcher = new FileWatcher(this.config);
-    this.fileWatcher.on('fileChanged', filepath => {
-      log.info(filepath + ' changed (' + (this.disableFileWatch ? 'disabled' : 'enabled') + ').');
-      if (this.disableFileWatch || this.paused) {
-        return;
-      }
-      let configFile = this.config.get('file');
-      if ((configFile && filepath === Path.resolve(configFile)) ||
-        (this.config.isCwdMode() && filepath === process.cwd())) {
-        // config changed
-        this.configure(() => {
-          this.triggerRun('Config changed');
-        });
-      } else {
-        using(this.runHook('on_change', {file: filepath}), () => {
-          this.triggerRun('File changed: ' + filepath);
-        });
-      }
-    });
-    this.fileWatcher.on('EMFILE', () => {
-      let view = this.view;
-      let text = [
-        'The file watcher received a EMFILE system error, which means that ',
-        'it has hit the maximum number of files that can be open at a time. ',
-        'Luckily, you can increase this limit as a workaround. See the directions below \n \n',
-        'Linux: http://stackoverflow.com/a/34645/5304\n',
-        'Mac OS: http://serverfault.com/a/15575/47234'
-      ].join('');
-      view.setErrorPopupMessage(new StyledString(text + '\n ').foreground('megenta'));
+    return FileWatcher.create(this.config).then((fw) => {
+      this.fileWatcher = fw;
+      this.fileWatcher.on('fileChanged', (filepath) => {
+        log.info(
+          filepath +
+            ' changed (' +
+            (this.disableFileWatch ? 'disabled' : 'enabled') +
+            ').',
+        );
+        if (this.disableFileWatch || this.paused) {
+          return;
+        }
+        let configFile = this.config.get('file');
+        if (
+          (configFile && filepath === Path.resolve(configFile)) ||
+          (this.config.isCwdMode() && filepath === process.cwd())
+        ) {
+          // config changed
+          this.configure(() => {
+            this.triggerRun('Config changed');
+          });
+        } else {
+          using(this.runHook('on_change', { file: filepath }), () => {
+            this.triggerRun('File changed: ' + filepath);
+          });
+        }
+      });
+      this.fileWatcher.on('EMFILE', () => {
+        let view = this.view;
+        let text = [
+          'The file watcher received a EMFILE system error, which means that ',
+          'it has hit the maximum number of files that can be open at a time. ',
+          'Luckily, you can increase this limit as a workaround. See the directions below \n \n',
+          'Linux: http://stackoverflow.com/a/34645/5304\n',
+          'Mac OS: http://serverfault.com/a/15575/47234',
+        ].join('');
+        view.setErrorPopupMessage(
+          new StyledString(text + '\n ').foreground('megenta'),
+        );
+      });
     });
-
-    return Promise.resolve();
   }
 
   getRunners() {
-    return disposer(fromCallback(callback => {
-      this.createRunners(callback);
-    }), () => {
-      return this.killRunners();
-    });
+    return disposer(
+      fromCallback((callback) => {
+        this.createRunners(callback);
+      }),
+      () => {
+        return this.killRunners();
+      },
+    );
   }
 
   createRunners(callback) {
@@ -374,14 +436,20 @@ module.exports = class App extends EventEmitter {
       case 'tap':
         return TapProcessTestRunner;
       default:
-        throw new Error('Don\'t know about ' + protocol + ' protocol.');
+        throw new Error('Unknown protocol: ' + protocol);
     }
   }
 
   createTestRunner(launcher, reporter) {
     let singleRun = this.config.get('single_run');
 
-    return new (this.getRunnerFactory(launcher))(launcher, reporter, this.runnerIndex++, singleRun, this.config);
+    return new (this.getRunnerFactory(launcher))(
+      launcher,
+      reporter,
+      this.runnerIndex++,
+      singleRun,
+      this.config,
+    );
   }
 
   withTestTimeout() {
@@ -392,9 +460,9 @@ module.exports = class App extends EventEmitter {
 
   singleRun(timeout) {
     let limit = this.config.get('parallel');
-    let concurrency = (limit && limit >= 1) ? parseInt(limit) : Infinity;
+    let concurrency = limit && limit >= 1 ? parseInt(limit) : Infinity;
 
-    return mapLimit(this.runners, concurrency, runner => {
+    return mapLimit(this.runners, concurrency, (runner) => {
       if (this.exited) {
         let e = new Error('Run canceled.');
         e.hideFromReporter = true;
@@ -435,20 +503,22 @@ module.exports = class App extends EventEmitter {
   }
 
   stopRunners() {
-    return Promise.all(this.runners.map(runner => {
-      if (typeof runner.stop === 'function') {
-        return runner.stop();
-      }
+    return Promise.all(
+      this.runners.map((runner) => {
+        if (typeof runner.stop === 'function') {
+          return runner.stop();
+        }
 
-      return runner.exit();
-    }));
+        return runner.exit();
+      }),
+    );
   }
 
   killRunners() {
-    return Promise.all(this.runners.map(runner => runner.exit()));
+    return Promise.all(this.runners.map((runner) => runner.exit()));
   }
 
   launchers() {
-    return this.runners.map(runner => runner.launcher);
+    return this.runners.map((runner) => runner.launcher);
   }
 };

package/lib/cli-local-delegation.js

@@ -0,0 +1,93 @@
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+/**
+ * Walks upward from `startDir` looking for `node_modules/testem/testem.js`.
+ *
+ * @param {string} startDir
+ * @returns {string | null}
+ */
+function findLocalTestemScript(startDir) {
+  let dir = path.resolve(startDir);
+  const { root } = path.parse(dir);
+  while (true) {
+    const candidate = path.join(dir, 'node_modules', 'testem', 'testem.js');
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    if (dir === root) {
+      break;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * If a local install exists and is not the same file as the running CLI (e.g. global),
+ * returns the path to the local `testem.js`. Otherwise returns null.
+ *
+ * @param {string} currentFile - `__filename` of the running CLI
+ * @param {string} cwd
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {string | null}
+ */
+function resolveLocalTestemCliOrNull(currentFile, cwd, env = process.env) {
+  if (env.TESTEM_USE_GLOBAL === '1') {
+    return null;
+  }
+  const local = findLocalTestemScript(cwd);
+  if (!local) {
+    return null;
+  }
+  let cur;
+  let loc;
+  try {
+    cur = fs.realpathSync(currentFile);
+    loc = fs.realpathSync(local);
+  } catch {
+    return null;
+  }
+  if (cur === loc) {
+    return null;
+  }
+  return local;
+}
+
+/**
+ * When the globally installed `testem` is run inside a project that has a local
+ * `testem` dependency, re-exec that local copy so CLI and project stay in sync.
+ *
+ * Exits the process when delegation runs; otherwise returns normally.
+ *
+ * @param {string} currentFile
+ * @param {string[]} argv
+ * @param {string} cwd
+ * @param {NodeJS.ProcessEnv} env
+ */
+function tryDelegateToLocalTestem(currentFile, argv, cwd, env) {
+  const local = resolveLocalTestemCliOrNull(currentFile, cwd, env);
+  if (!local) {
+    return;
+  }
+  const result = spawnSync(process.execPath, [local, ...argv.slice(2)], {
+    stdio: 'inherit',
+    env,
+    windowsHide: true,
+  });
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  if (result.signal) {
+    process.exit(1);
+  }
+  process.exit(result.status === null ? 0 : result.status);
+}
+
+module.exports = {
+  findLocalTestemScript,
+  resolveLocalTestemCliOrNull,
+  tryDelegateToLocalTestem,
+};