ava 0.16.0 → 0.18.2

package/lib/run-status.js

@@ -1,56 +1,21 @@
 'use strict';
-var EventEmitter = require('events').EventEmitter;
-var path = require('path');
-var util = require('util');
-var chalk = require('chalk');
-var isObj = require('is-obj');
-var flatten = require('arr-flatten');
-var figures = require('figures');
-
-function RunStatus(opts) {
-	if (!(this instanceof RunStatus)) {
-		throw new TypeError('Class constructor RunStatus cannot be invoked without \'new\'');
-	}
-	EventEmitter.call(this);
-
-	opts = opts || {};
-	this.prefixTitles = opts.prefixTitles !== false;
-	this.hasExclusive = Boolean(opts.runOnlyExclusive);
-	this.base = opts.base || '';
-
-	this.rejectionCount = 0;
-	this.exceptionCount = 0;
-	this.passCount = 0;
-	this.knownFailureCount = 0;
-	this.skipCount = 0;
-	this.todoCount = 0;
-	this.failCount = 0;
-	this.fileCount = 0;
-	this.testCount = 0;
-	this.previousFailCount = 0;
-	this.knownFailures = [];
-	this.errors = [];
-	this.stats = [];
-	this.tests = [];
-
-	Object.keys(RunStatus.prototype).forEach(function (key) {
-		this[key] = this[key].bind(this);
-	}, this);
-}
+const EventEmitter = require('events');
+const chalk = require('chalk');
+const isObj = require('is-obj');
+const flatten = require('arr-flatten');
+const figures = require('figures');
+const autoBind = require('auto-bind');
+const prefixTitle = require('./prefix-title');
 
-util.inherits(RunStatus, EventEmitter);
-module.exports = RunStatus;
+function sum(arr, key) {
+	let result = 0;
 
-RunStatus.prototype.observeFork = function (emitter) {
-	emitter
-		.on('teardown', this.handleTeardown)
-		.on('stats', this.handleStats)
-		.on('test', this.handleTest)
-		.on('unhandledRejections', this.handleRejections)
-		.on('uncaughtException', this.handleExceptions)
-		.on('stdout', this.handleOutput.bind(this, 'stdout'))
-		.on('stderr', this.handleOutput.bind(this, 'stderr'));
-};
+	arr.forEach(item => {
+		result += item[key];
+	});
+
+	return result;
+}
 
 function normalizeError(err) {
 	if (!isObj(err)) {
@@ -63,122 +28,115 @@ function normalizeError(err) {
 	return err;
 }
 
-RunStatus.prototype.handleRejections = function (data) {
-	this.rejectionCount += data.rejections.length;
-
-	data.rejections.forEach(function (err) {
-		err = normalizeError(err);
-		err.type = 'rejection';
+class RunStatus extends EventEmitter {
+	constructor(opts) {
+		super();
+
+		opts = opts || {};
+		this.prefixTitles = opts.prefixTitles !== false;
+		this.hasExclusive = Boolean(opts.runOnlyExclusive);
+		this.base = opts.base || '';
+		this.rejectionCount = 0;
+		this.exceptionCount = 0;
+		this.passCount = 0;
+		this.knownFailureCount = 0;
+		this.skipCount = 0;
+		this.todoCount = 0;
+		this.failCount = 0;
+		this.fileCount = 0;
+		this.testCount = 0;
+		this.remainingCount = 0;
+		this.previousFailCount = 0;
+		this.knownFailures = [];
+		this.errors = [];
+		this.stats = [];
+		this.tests = [];
+		this.failFastEnabled = opts.failFast || false;
+
+		autoBind(this);
+	}
+	observeFork(emitter) {
+		emitter
+			.on('teardown', this.handleTeardown)
+			.on('stats', this.handleStats)
+			.on('test', this.handleTest)
+			.on('unhandledRejections', this.handleRejections)
+			.on('uncaughtException', this.handleExceptions)
+			.on('stdout', this.handleOutput.bind(this, 'stdout'))
+			.on('stderr', this.handleOutput.bind(this, 'stderr'));
+	}
+	handleRejections(data) {
+		this.rejectionCount += data.rejections.length;
+
+		data.rejections.forEach(err => {
+			err = normalizeError(err);
+			err.type = 'rejection';
+			err.file = data.file;
+			this.emit('error', err, this);
+			this.errors.push(err);
+		});
+	}
+	handleExceptions(data) {
+		this.exceptionCount++;
+		const err = normalizeError(data.exception);
+		err.type = 'exception';
 		err.file = data.file;
 		this.emit('error', err, this);
 		this.errors.push(err);
-	}, this);
-};
-
-RunStatus.prototype.handleExceptions = function (data) {
-	this.exceptionCount++;
-	var err = normalizeError(data.exception);
-	err.type = 'exception';
-	err.file = data.file;
-	this.emit('error', err, this);
-	this.errors.push(err);
-};
-
-RunStatus.prototype.handleTeardown = function (data) {
-	this.emit('dependencies', data.file, data.dependencies, this);
-};
-
-RunStatus.prototype.handleStats = function (stats) {
-	this.emit('stats', stats, this);
-
-	if (this.hasExclusive && !stats.hasExclusive) {
-		return;
 	}
-
-	if (!this.hasExclusive && stats.hasExclusive) {
-		this.hasExclusive = true;
-		this.testCount = 0;
+	handleTeardown(data) {
+		this.emit('dependencies', data.file, data.dependencies, this);
 	}
+	handleStats(stats) {
+		this.emit('stats', stats, this);
 
-	this.testCount += stats.testCount;
-};
-
-RunStatus.prototype.handleTest = function (test) {
-	test.title = this.prefixTitle(test.file) + test.title;
-
-	if (test.error) {
-		if (test.error.name !== 'AssertionError') {
-			test.error.message = 'failed with "' + test.error.message + '"';
+		if (stats.hasExclusive) {
+			this.hasExclusive = true;
 		}
 
-		this.errors.push(test);
+		this.testCount += stats.testCount;
 	}
+	handleTest(test) {
+		test.title = this.prefixTitle(test.file) + test.title;
 
-	if (test.failing && !test.error) {
-		this.knownFailures.push(test);
-	}
+		if (test.error) {
+			if (test.error.name !== 'AssertionError') {
+				test.error.message = `Error: ${test.error.message}`;
+			}
 
-	this.emit('test', test, this);
-};
+			this.errors.push(test);
+		}
 
-RunStatus.prototype.prefixTitle = function (file) {
-	if (!this.prefixTitles) {
-		return '';
-	}
+		if (test.failing && !test.error) {
+			this.knownFailures.push(test);
+		}
 
-	var separator = ' ' + chalk.gray.dim(figures.pointerSmall) + ' ';
-
-	var prefix = path.relative('.', file)
-		.replace(this.base, function (match, offset) {
-			// only replace this.base if it is found at the start of the path
-			return offset === 0 ? '' : match;
-		})
-		.replace(/\.spec/, '')
-		.replace(/\.test/, '')
-		.replace(/test\-/g, '')
-		.replace(/\.js$/, '')
-		.split(path.sep)
-		.filter(function (p) {
-			return p !== '__tests__';
-		})
-		.join(separator);
-
-	if (prefix.length > 0) {
-		prefix += separator;
+		this.emit('test', test, this);
 	}
+	prefixTitle(file) {
+		if (!this.prefixTitles) {
+			return '';
+		}
 
-	return prefix;
-};
-
-RunStatus.prototype.handleOutput = function (channel, data) {
-	this.emit(channel, data, this);
-};
-
-RunStatus.prototype.processResults = function (results) {
-	// assemble stats from all tests
-	this.stats = results.map(function (result) {
-		return result.stats;
-	});
-
-	this.tests = results.map(function (result) {
-		return result.tests;
-	});
-
-	this.tests = flatten(this.tests);
-
-	this.passCount = sum(this.stats, 'passCount');
-	this.knownFailureCount = sum(this.stats, 'knownFailureCount');
-	this.skipCount = sum(this.stats, 'skipCount');
-	this.todoCount = sum(this.stats, 'todoCount');
-	this.failCount = sum(this.stats, 'failCount');
-};
-
-function sum(arr, key) {
-	var result = 0;
-
-	arr.forEach(function (item) {
-		result += item[key];
-	});
+		const separator = ' ' + chalk.gray.dim(figures.pointerSmall) + ' ';
 
-	return result;
+		return prefixTitle(file, this.base, separator);
+	}
+	handleOutput(channel, data) {
+		this.emit(channel, data, this);
+	}
+	processResults(results) {
+		// Assemble stats from all tests
+		this.stats = results.map(result => result.stats);
+		this.tests = results.map(result => result.tests);
+		this.tests = flatten(this.tests);
+		this.passCount = sum(this.stats, 'passCount');
+		this.knownFailureCount = sum(this.stats, 'knownFailureCount');
+		this.skipCount = sum(this.stats, 'skipCount');
+		this.todoCount = sum(this.stats, 'todoCount');
+		this.failCount = sum(this.stats, 'failCount');
+		this.remainingCount = this.testCount - this.passCount - this.failCount - this.skipCount - this.todoCount - this.knownFailureCount;
+	}
 }
+
+module.exports = RunStatus;

package/lib/runner.js

@@ -1,14 +1,14 @@
 'use strict';
-var EventEmitter = require('events').EventEmitter;
-var util = require('util');
-var Promise = require('bluebird');
-var optionChain = require('option-chain');
-var matcher = require('matcher');
-var TestCollection = require('./test-collection');
+const EventEmitter = require('events');
+const Promise = require('bluebird');
+const optionChain = require('option-chain');
+const matcher = require('matcher');
+const TestCollection = require('./test-collection');
+const validateTest = require('./validate-test');
 
 function noop() {}
 
-var chainableMethods = {
+const chainableMethods = {
 	defaults: {
 		type: 'test',
 		serial: false,
@@ -35,32 +35,129 @@ var chainableMethods = {
 	}
 };
 
-function Runner(options) {
-	if (!(this instanceof Runner)) {
-		throw new TypeError('Class constructor Runner cannot be invoked without \'new\'');
+function wrapFunction(fn, args) {
+	return function (t) {
+		return fn.apply(this, [t].concat(args));
+	};
+}
+
+class Runner extends EventEmitter {
+	constructor(options) {
+		super();
+
+		options = options || {};
+
+		this.results = [];
+		this.tests = new TestCollection();
+		this.hasStarted = false;
+		this._bail = options.bail;
+		this._serial = options.serial;
+		this._match = options.match || [];
+		this._addTestResult = this._addTestResult.bind(this);
+		this._buildStats = this._buildStats.bind(this);
 	}
+	_addTest(title, opts, fn, args) {
+		if (args) {
+			if (fn.title) {
+				title = fn.title.apply(fn, [title || ''].concat(args));
+			}
 
-	EventEmitter.call(this);
+			fn = wrapFunction(fn, args);
+		}
 
-	options = options || {};
+		if (opts.type === 'test' && this._match.length > 0) {
+			opts.exclusive = title !== null && matcher([title], this._match).length === 1;
+		}
 
-	this.results = [];
-	this.tests = new TestCollection();
-	this.hasStarted = false;
-	this._bail = options.bail;
-	this._serial = options.serial;
-	this._match = options.match || [];
-	this._addTestResult = this._addTestResult.bind(this);
-	this._buildStats = this._buildStats.bind(this);
-}
+		const validationError = validateTest(title, fn, opts);
+		if (validationError !== null) {
+			throw new TypeError(validationError);
+		}
 
-util.inherits(Runner, EventEmitter);
-module.exports = Runner;
+		if (opts.todo) {
+			fn = noop;
+		}
+
+		this.tests.add({
+			metadata: opts,
+			fn,
+			title
+		});
+	}
+	_addTestResult(result) {
+		const test = result.result;
+		const props = {
+			duration: test.duration,
+			title: test.title,
+			error: result.reason,
+			type: test.metadata.type,
+			skip: test.metadata.skipped,
+			todo: test.metadata.todo,
+			failing: test.metadata.failing
+		};
+
+		this.results.push(result);
+		this.emit('test', props);
+	}
+	_buildStats() {
+		const stats = {
+			testCount: 0,
+			skipCount: 0,
+			todoCount: 0
+		};
+
+		this.results
+			.map(result => {
+				return result.result;
+			})
+			.filter(test => {
+				return test.metadata.type === 'test';
+			})
+			.forEach(test => {
+				stats.testCount++;
+
+				if (test.metadata.skipped) {
+					stats.skipCount++;
+				}
+
+				if (test.metadata.todo) {
+					stats.todoCount++;
+				}
+			});
+
+		stats.failCount = this.results
+			.filter(result => {
+				return result.passed === false;
+			})
+			.length;
+
+		stats.knownFailureCount = this.results
+			.filter(result => {
+				return result.passed === true && result.result.metadata.failing;
+			})
+			.length;
+
+		stats.passCount = stats.testCount - stats.failCount - stats.skipCount - stats.todoCount;
+
+		return stats;
+	}
+	run(options) {
+		if (options.runOnlyExclusive && !this.tests.hasExclusive) {
+			return Promise.resolve(null);
+		}
+
+		this.tests.on('test', this._addTestResult);
+
+		this.hasStarted = true;
+
+		return Promise.resolve(this.tests.build(this._bail).run()).then(this._buildStats);
+	}
+}
 
 optionChain(chainableMethods, function (opts, args) {
-	var title;
-	var fn;
-	var macroArgIndex;
+	let title;
+	let fn;
+	let macroArgIndex;
 
 	if (this.hasStarted) {
 		throw new Error('All tests and hooks must be declared synchronously in your ' +
@@ -96,115 +193,6 @@ optionChain(chainableMethods, function (opts, args) {
 	}
 }, Runner.prototype);
 
-function wrapFunction(fn, args) {
-	return function (t) {
-		return fn.apply(this, [t].concat(args));
-	};
-}
-
-Runner.prototype._addTest = function (title, opts, fn, args) {
-	if (args) {
-		if (fn.title) {
-			title = fn.title.apply(fn, [title || ''].concat(args));
-		}
-
-		fn = wrapFunction(fn, args);
-	}
-
-	if (opts.type === 'test' && this._match.length > 0) {
-		opts.exclusive = title !== null && matcher([title], this._match).length === 1;
-	}
-
-	if (opts.todo) {
-		if (typeof fn === 'function') {
-			throw new TypeError('`todo` tests are not allowed to have an implementation. Use `test.skip()` for tests with an implementation.');
-		}
-
-		fn = noop;
-
-		if (typeof title !== 'string') {
-			throw new TypeError('`todo` tests require a title');
-		}
-	} else if (typeof fn !== 'function') {
-		throw new TypeError('Expected an implementation. Use `test.todo()` for tests without an implementation.');
-	}
-
-	this.tests.add({
-		metadata: opts,
-		fn: fn,
-		title: title
-	});
-};
-
-Runner.prototype._addTestResult = function (result) {
-	var test = result.result;
-	var props = {
-		duration: test.duration,
-		title: test.title,
-		error: result.reason,
-		type: test.metadata.type,
-		skip: test.metadata.skipped,
-		todo: test.metadata.todo,
-		failing: test.metadata.failing
-	};
-
-	this.results.push(result);
-	this.emit('test', props);
-};
-
-Runner.prototype._buildStats = function () {
-	var stats = {
-		testCount: 0,
-		skipCount: 0,
-		todoCount: 0
-	};
-
-	this.results
-		.map(function (result) {
-			return result.result;
-		})
-		.filter(function (test) {
-			return test.metadata.type === 'test';
-		})
-		.forEach(function (test) {
-			stats.testCount++;
-
-			if (test.metadata.skipped) {
-				stats.skipCount++;
-			}
-
-			if (test.metadata.todo) {
-				stats.todoCount++;
-			}
-		});
-
-	stats.failCount = this.results
-		.filter(function (result) {
-			return result.passed === false;
-		})
-		.length;
-
-	stats.knownFailureCount = this.results
-		.filter(function (result) {
-			return result.passed === true && result.result.metadata.failing;
-		})
-		.length;
-
-	stats.passCount = stats.testCount - stats.failCount - stats.skipCount - stats.todoCount;
-
-	return stats;
-};
-
-Runner.prototype.run = function (options) {
-	if (options.runOnlyExclusive && !this.tests.hasExclusive) {
-		return Promise.resolve(null);
-	}
-
-	this.tests.on('test', this._addTestResult);
-
-	this.hasStarted = true;
-
-	return Promise.resolve(this.tests.build(this._bail).run()).then(this._buildStats);
-};
-
 Runner._chainableMethods = chainableMethods.chainableMethods;
+
+module.exports = Runner;