squash of PR #243

runner.js: simplify test data structure

split hooks to their own file

auto-generate runner.addXXX functions

add chaining

drop `map-obj` as a dependency (I did not end up needing it).

refactor tests to use chained methods

simplify chain builder

add chainable tests

make all hooks skippable

test title of skipped test

move test flags to metadata object, instead of right on test

remove unused property

Author: jamestalmage

index.js

@@ -70,11 +70,4 @@ setImmediate(function () {
 	runner.run().then(exit);
 });
 
-module.exports = runner.addTest.bind(runner);
-module.exports.serial = runner.addSerialTest.bind(runner);
-module.exports.before = runner.addBeforeHook.bind(runner);
-module.exports.after = runner.addAfterHook.bind(runner);
-module.exports.beforeEach = runner.addBeforeEachHook.bind(runner);
-module.exports.afterEach = runner.addAfterEachHook.bind(runner);
-module.exports.skip = runner.addSkippedTest.bind(runner);
-module.exports.only = runner.addOnlyTest.bind(runner);
+module.exports = runner.test;

lib/hook.js

@@ -0,0 +1,24 @@
+var Test = require('./test');
+
+module.exports = Hook;
+
+function Hook(title, fn) {
+	if (!(this instanceof Hook)) {
+		return new Hook(title, fn);
+	}
+
+	if (typeof title === 'function') {
+		fn = title;
+		title = null;
+	}
+
+	this.title = title;
+	this.fn = fn;
+}
+
+Hook.prototype.test = function (testTitle) {
+	var title = this.title || (this.metadata.type + ' for "' + testTitle + '"');
+	var test = new Test(title, this.fn);
+	test.metadata = this.metadata;
+	return test;
+};

lib/runner.js

@@ -4,7 +4,9 @@ var util = require('util');
 var Promise = require('bluebird');
 var hasFlag = require('has-flag');
 var Test = require('./test');
+var Hook = require('./hook');
 var send = require('./send');
+var objectAssign = require('object-assign');
 
 function noop() {}
 
@@ -13,7 +15,7 @@ function each(items, fn, context) {
 }
 
 function eachSeries(items, fn, context) {
-	return Promise.resolve(items).each(fn.bind(context));
+	return Promise.each(items, fn.bind(context));
 }
 
 function Runner(opts) {
@@ -25,112 +27,77 @@ function Runner(opts) {
 
 	this.results = [];
 
-	this.stats = {
-		failCount: 0,
-		passCount: 0,
-		testCount: 0
-	};
+	this.tests = [];
 
-	this.tests = {
-		concurrent: [],
-		serial: [],
-		only: [],
-		before: [],
-		after: [],
-		beforeEach: [],
-		afterEach: []
-	};
+	this.test = makeChain({
+		type: 'test',
+		serial: false,
+		exclusive: false,
+		skipped: false
+	}, this._addFn.bind(this));
 }
 
 util.inherits(Runner, EventEmitter);
 module.exports = Runner;
 
-Runner.prototype.addTest = function (title, cb) {
-	this.stats.testCount++;
-	this.tests.concurrent.push(new Test(title, cb));
-};
-
-Runner.prototype.addSerialTest = function (title, cb) {
-	this.stats.testCount++;
-	this.tests.serial.push(new Test(title, cb));
-};
-
-Runner.prototype.addBeforeHook = function (title, cb) {
-	var test = new Test(title, cb);
-	test.type = 'hook';
-
-	this.tests.before.push(test);
-};
-
-Runner.prototype.addAfterHook = function (title, cb) {
-	var test = new Test(title, cb);
-	test.type = 'hook';
-
-	this.tests.after.push(test);
+var chainableFunctions = {
+	serial: {serial: true},
+	before: {type: 'before'},
+	after: {type: 'after'},
+	skip: {skipped: true},
+	only: {exclusive: true},
+	beforeEach: {type: 'beforeEach'},
+	afterEach: {type: 'afterEach'}
 };
 
-Runner.prototype.addBeforeEachHook = function (title, cb) {
-	if (!cb) {
-		cb = title;
-		title = undefined;
+function makeChain(defaults, parentAdd) {
+	function fn(title, fn) {
+		parentAdd(defaults, title, fn);
 	}
 
-	this.tests.beforeEach.push({
-		title: title,
-		fn: cb
-	});
-};
-
-Runner.prototype.addAfterEachHook = function (title, cb) {
-	if (!cb) {
-		cb = title;
-		title = undefined;
+	function add(opts, title, fn) {
+		opts = objectAssign({}, defaults, opts);
+		parentAdd(objectAssign({}, defaults, opts), title, fn);
 	}
 
-	this.tests.afterEach.push({
-		title: title,
-		fn: cb
+	Object.keys(chainableFunctions).forEach(function (key) {
+		Object.defineProperty(fn, key, {
+			get: function () {
+				return makeChain(objectAssign({}, defaults, chainableFunctions[key]), add);
+			}
+		});
 	});
-};
 
-Runner.prototype.addSkippedTest = function (title, cb) {
-	var test = new Test(title, cb);
-	test.skip = true;
+	return fn;
+}
 
-	this.tests.concurrent.push(test);
-};
+Object.keys(chainableFunctions).forEach(function (key) {
+	Object.defineProperty(Runner.prototype, key, {
+		get: function () {
+			return this.test[key];
+		}
+	});
+});
 
-Runner.prototype.addOnlyTest = function (title, cb) {
-	this.stats.testCount++;
-	this.tests.only.push(new Test(title, cb));
+Runner.prototype._addFn = function (opts, title, fn) {
+	var Constructor = (opts && /Each/.test(opts.type)) ? Hook : Test;
+	var test = new Constructor(title, fn);
+	test.metadata = objectAssign({}, opts);
+	this.tests.push(test);
 };
 
 Runner.prototype._runTestWithHooks = function (test) {
 	if (test.skip) {
 		return this._addTestResult(test);
 	}
 
-	var beforeHooks = this.tests.beforeEach.map(function (hook) {
-		var title = hook.title || 'beforeEach for "' + test.title + '"';
-		hook = new Test(title, hook.fn);
-		hook.type = 'eachHook';
-
-		return hook;
-	});
-
-	var afterHooks = this.tests.afterEach.map(function (hook) {
-		var title = hook.title || 'afterEach for "' + test.title + '"';
-		hook = new Test(title, hook.fn);
-		hook.type = 'eachHook';
-
-		return hook;
-	});
-
-	var tests = [];
+	function hookToTest(hook) {
+		return hook.test(test.title);
+	}
 
-	tests.push.apply(tests, beforeHooks);
+	var tests = this.select({type: 'beforeEach', skipped: false}).map(hookToTest);
 	tests.push(test);
-	tests.push.apply(tests, afterHooks);
+	tests.push.apply(tests, this.select({type: 'afterEach', skipped: false}).map(hookToTest));
 
 	var context = {};
 
@@ -158,15 +125,15 @@ Runner.prototype._runTest = function (test) {
 	});
 };
 
-Runner.prototype.concurrent = function (tests) {
+Runner.prototype._runConcurrent = function (tests) {
 	if (hasFlag('serial')) {
-		return this.serial(tests);
+		return this._runSerial(tests);
 	}
 
 	return each(tests, this._runTestWithHooks, this);
 };
 
-Runner.prototype.serial = function (tests) {
+Runner.prototype._runSerial = function (tests) {
 	return eachSeries(tests, this._runTestWithHooks, this);
 };
 
@@ -179,7 +146,7 @@ Runner.prototype._addTestResult = function (test) {
 		duration: test.duration,
 		title: test.title,
 		error: test.assertError,
-		type: test.type,
+		type: test.metadata.type,
 		skip: test.skip
 	};
 
@@ -188,43 +155,49 @@ Runner.prototype._addTestResult = function (test) {
 };
 
 Runner.prototype.run = function () {
-	var tests = this.tests;
-	var stats = this.stats;
 	var self = this;
+	var hasExclusive = Boolean(this.select({exclusive: true, skipped: false, type: 'test'}).length);
+	var serial = this.select({exclusive: hasExclusive, skipped: false, serial: true, type: 'test'});
+	var concurrent = this.select({exclusive: hasExclusive, skipped: false, serial: false, type: 'test'});
 
-	var hasOnlyTests = tests.only.length > 0;
+	var stats = this.stats = {
+		failCount: 0,
+		passCount: 0,
+		testCount: serial.length + concurrent.length
+	};
 
 	// Runner is executed directly in tests, in that case process.send() == undefined
 	if (process.send) {
 		send('stats', stats);
 	}
 
-	return eachSeries(tests.before, this._runTest, this)
+	return eachSeries(this.select({type: 'before', skipped: false}), this._runTest, this)
 		.catch(noop)
 		.then(function () {
 			if (stats.failCount > 0) {
 				return Promise.reject();
 			}
 		})
 		.then(function () {
-			return self.concurrent(tests.only);
-		})
-		.then(function () {
-			if (!hasOnlyTests) {
-				return self.serial(tests.serial);
-			}
+			return self._runSerial(serial);
 		})
 		.then(function () {
-			if (!hasOnlyTests) {
-				return self.concurrent(tests.concurrent);
-			}
+			return self._runConcurrent(concurrent);
 		})
 		.then(function () {
-			return eachSeries(tests.after, self._runTest, self);
+			return eachSeries(self.select({type: 'after', skipped: false}), self._runTest, self);
 		})
 		.catch(noop)
 		.then(function () {
-			stats.testCount = tests.only.length || stats.testCount;
 			stats.passCount = stats.testCount - stats.failCount;
 		});
 };
+
+Runner.prototype.select = function (filter) {
+	function filterFn(test) {
+		return Object.keys(filter).every(function (key) {
+			return filter[key] === test.metadata[key];
+		});
+	}
+	return this.tests.filter(filterFn);
+};

lib/test.js

@@ -28,9 +28,6 @@ function Test(title, fn) {
 	this.duration = null;
 	this.context = {};
 
-	// test type, can be: test, hook, eachHook
-	this.type = 'test';
-
 	// store the time point before test execution
 	// to calculate the total time spent in test
 	this._timeStart = null;

package.json

@@ -93,6 +93,7 @@
     "loud-rejection": "^1.2.0",
     "max-timeout": "^1.0.0",
     "meow": "^3.6.0",
+    "object-assign": "^4.0.1",
     "observable-to-promise": "^0.1.0",
     "plur": "^2.0.0",
     "power-assert-formatter": "^1.3.0",