make .only sticky in watch mode

A second argument can be passed to Api#run(). If true the tests will be run
in exclusive mode, regardless of whether exclusive tests are detected.

The Api now remits the 'stats' event from the forks.

The watcher keeps track of exclusive tests. If all test files that contained
exclusive tests need to be rerun it runs them without forcing exclusive mode.
This means the exclusivity is determined by the tests themselves.

If a test file, containing exclusive tests, is not one of the files being rerun,
it forces exclusive mode. This ensures only exclusive tests are run in the
changed files, making .only sticky.

If all test files that contained exclusive tests are removed, sticky mode is
disabled. The same happens if there are no more exclusive tests after a run.

Fixes #593.

Author: novemberborn

api.js

@@ -106,6 +106,8 @@ Api.prototype._handleTeardown = function (data) {
 };
 
 Api.prototype._handleStats = function (stats) {
+	this.emit('stats', stats);
+
 	if (this.hasExclusive && !stats.hasExclusive) {
 		return;
 	}
@@ -165,10 +167,15 @@ Api.prototype._prefixTitle = function (file) {
 	return prefix;
 };
 
-Api.prototype.run = function (files) {
+Api.prototype.run = function (files, options) {
 	var self = this;
 
 	this._reset();
+
+	if (options && options.runOnlyExclusive) {
+		this.hasExclusive = true;
+	}
+
 	return handlePaths(files, this.excludePatterns)
 		.map(function (file) {
 			return path.resolve(file);

lib/watcher.js

@@ -39,14 +39,29 @@ function Watcher(logger, api, files, sources) {
 	this.isTest = makeTestMatcher(files, api.excludePatterns);
 	this.run = function (specificFiles) {
 		logger.reset();
-		this.busy = api.run(specificFiles || files).then(function () {
+
+		var runOnlyExclusive = false;
+		if (specificFiles) {
+			var exclusiveFiles = specificFiles.filter(function (file) {
+				return this.filesWithExclusiveTests.indexOf(file) !== -1;
+			}, this);
+
+			runOnlyExclusive = exclusiveFiles.length !== this.filesWithExclusiveTests.length;
+		}
+
+		this.busy = api.run(specificFiles || files, {
+			runOnlyExclusive: runOnlyExclusive
+		}).then(function () {
 			logger.finish();
 		}, rethrowAsync);
 	};
 
 	this.testDependencies = [];
 	this.trackTestDependencies(api, sources);
 
+	this.filesWithExclusiveTests = [];
+	this.trackExclusivity(api);
+
 	this.dirtyStates = {};
 	this.watchFiles(files, sources);
 	this.rerunAll();
@@ -85,12 +100,6 @@ Watcher.prototype.trackTestDependencies = function (api, sources) {
 	});
 };
 
-Watcher.prototype.removeUnlinkedTestDependencies = function (unlinkedTests) {
-	unlinkedTests.forEach(function (testFile) {
-		this.updateTestDependencies(testFile, []);
-	}, this);
-};
-
 Watcher.prototype.updateTestDependencies = function (file, sources) {
 	if (sources.length === 0) {
 		this.testDependencies = this.testDependencies.filter(function (dep) {
@@ -113,6 +122,30 @@ Watcher.prototype.updateTestDependencies = function (file, sources) {
 	}
 };
 
+Watcher.prototype.trackExclusivity = function (api) {
+	var self = this;
+	api.on('stats', function (stats) {
+		self.updateExclusivity(stats.file, stats.hasExclusive);
+	});
+};
+
+Watcher.prototype.updateExclusivity = function (file, hasExclusiveTests) {
+	var index = this.filesWithExclusiveTests.indexOf(file);
+
+	if (hasExclusiveTests && index === -1) {
+		this.filesWithExclusiveTests.push(file);
+	} else if (!hasExclusiveTests && index !== -1) {
+		this.filesWithExclusiveTests.splice(index, 1);
+	}
+};
+
+Watcher.prototype.cleanUnlinkedTests = function (unlinkedTests) {
+	unlinkedTests.forEach(function (testFile) {
+		this.updateTestDependencies(testFile, []);
+		this.updateExclusivity(testFile, false);
+	}, this);
+};
+
 Watcher.prototype.observeStdin = function (stdin) {
 	var self = this;
 
@@ -153,7 +186,7 @@ Watcher.prototype.runAfterChanges = function () {
 	});
 	var unlinkedTests = diff(dirtyTests, addedOrChangedTests);
 
-	this.removeUnlinkedTestDependencies(unlinkedTests);
+	this.cleanUnlinkedTests(unlinkedTests);
 	// No need to rerun tests if the only change is that tests were deleted.
 	if (unlinkedTests.length === dirtyPaths.length) {
 		return;

test/api.js

@@ -621,6 +621,21 @@ test('test file with exclusive tests causes non-exclusive tests in other files t
 		});
 });
 
+test('test files can be forced to run in exclusive mode', function (t) {
+	t.plan(4);
+
+	var api = new Api();
+	return api.run(
+		[path.join(__dirname, 'fixture/es2015.js')],
+		{runOnlyExclusive: true}
+	).then(function () {
+		t.ok(api.hasExclusive);
+		t.is(api.testCount, 0);
+		t.is(api.passCount, 0);
+		t.is(api.failCount, 0);
+	});
+});
+
 test('resets state before running', function (t) {
 	t.plan(2);
 
@@ -666,6 +681,26 @@ test('emits dependencies for test files', function (t) {
 	result.catch(function () {});
 });
 
+test('emits stats for test files', function (t) {
+	t.plan(2);
+
+	var api = new Api();
+	api.on('stats', function (stats) {
+		if (stats.file === path.normalize('test/fixture/exclusive.js')) {
+			t.is(stats.hasExclusive, true);
+		} else if (stats.file === path.normalize('test/fixture/generators.js')) {
+			t.is(stats.hasExclusive, false);
+		} else {
+			t.ok(false);
+		}
+	});
+
+	return api.run([
+		'test/fixture/exclusive.js',
+		'test/fixture/generators.js'
+	]);
+});
+
 test('verify test count', function (t) {
 	t.plan(8);