ava 0.16.0 → 0.18.2

package/lib/test.js

@@ -1,398 +1,369 @@
 'use strict';
-var inspect = require('util').inspect;
-var isGeneratorFn = require('is-generator-fn');
-var maxTimeout = require('max-timeout');
-var Promise = require('bluebird');
-var fnName = require('fn-name');
-var co = require('co-with-promise');
-var observableToPromise = require('observable-to-promise');
-var isPromise = require('is-promise');
-var isObservable = require('is-observable');
-var plur = require('plur');
-var assert = require('./assert');
-var enhanceAssert = require('./enhance-assert');
-var globals = require('./globals');
-var throwsHelper = require('./throws-helper');
-var formatter = enhanceAssert.formatter();
-
-function Test(title, fn, contextRef, report) {
-	if (!(this instanceof Test)) {
-		throw new TypeError('Class constructor Test cannot be invoked without \'new\'');
-	}
-
-	if (typeof title === 'function') {
-		contextRef = fn;
-		fn = title;
-		title = null;
-	}
-
-	assert.is(typeof fn, 'function', 'you must provide a callback');
-
-	this.title = title || fnName(fn) || '[anonymous]';
-	this.fn = isGeneratorFn(fn) ? co.wrap(fn) : fn;
-	this.assertions = [];
-	this.planCount = null;
-	this.duration = null;
-	this.assertError = undefined;
-	this.sync = true;
-	this.contextRef = contextRef;
-	this.report = report;
-	this.threwSync = false;
-
-	// TODO(jamestalmage): make this an optional constructor arg instead of having Runner set it after the fact.
-	// metadata should just always exist, otherwise it requires a bunch of ugly checks all over the place.
-	this.metadata = {};
-
-	// store the time point before test execution
-	// to calculate the total time spent in test
-	this._timeStart = null;
-
-	// workaround for Babel giving anonymous functions a name
-	if (this.title === 'callee$0$0') {
-		this.title = '[anonymous]';
+const inspect = require('util').inspect;
+const isGeneratorFn = require('is-generator-fn');
+const maxTimeout = require('max-timeout');
+const Promise = require('bluebird');
+const fnName = require('fn-name');
+const co = require('co-with-promise');
+const observableToPromise = require('observable-to-promise');
+const isPromise = require('is-promise');
+const isObservable = require('is-observable');
+const plur = require('plur');
+const assert = require('./assert');
+const enhanceAssert = require('./enhance-assert');
+const globals = require('./globals');
+const throwsHelper = require('./throws-helper');
+
+const formatter = enhanceAssert.formatter();
+
+class SkipApi {
+	constructor(test) {
+		this._test = test;
 	}
 }
 
-module.exports = Test;
+function skipFn() {
+	return this._test._assert(null);
+}
 
-Object.defineProperty(Test.prototype, 'assertCount', {
-	enumerable: true,
-	get: function () {
-		return this.assertions.length;
-	}
+Object.keys(assert).forEach(el => {
+	SkipApi.prototype[el] = skipFn;
 });
 
-Test.prototype._assert = function (promise) {
-	if (isPromise(promise)) {
-		this.sync = false;
+class PublicApi {
+	constructor(test) {
+		this._test = test;
+		this.skip = new SkipApi(test);
 	}
-
-	this.assertions.push(promise);
-};
-
-Test.prototype._setAssertError = function (err) {
-	throwsHelper(err);
-	if (this.assertError !== undefined) {
-		return;
+	plan(ct) {
+		const limitBefore = Error.stackTraceLimit;
+		Error.stackTraceLimit = 1;
+		const obj = {};
+		Error.captureStackTrace(obj, this.plan);
+		Error.stackTraceLimit = limitBefore;
+		this._test.plan(ct, obj.stack);
 	}
-
-	this.assertError = err;
-};
-
-Test.prototype.plan = function (count, planStack) {
-	if (typeof count !== 'number') {
-		throw new TypeError('Expected a number');
+	get context() {
+		const contextRef = this._test.contextRef;
+		return contextRef && contextRef.context;
 	}
+	set context(context) {
+		const contextRef = this._test.contextRef;
 
-	this.planCount = count;
-
-	// in case the `planCount` doesn't match `assertCount,
-	// we need the stack of this function to throw with a useful stack
-	this.planStack = planStack;
-};
-
-Test.prototype._run = function () {
-	var ret;
-
-	try {
-		ret = this.fn(this._publicApi());
-	} catch (err) {
-		this.threwSync = true;
-		if (err instanceof Error) {
-			this._setAssertError(err);
-		} else {
-			this._setAssertError(new assert.AssertionError({
-				actual: err,
-				message: 'Non-error thrown with value: ' + inspect(err, {depth: null}),
-				operator: 'catch'
-			}));
+		if (!contextRef) {
+			this._test._setAssertError(new Error(`t.context is not available in ${this._test.metadata.type} tests`));
+			return;
 		}
-	}
-
-	return ret;
-};
-
-Test.prototype.promise = function () {
-	var self = this;
 
-	if (!this._promise) {
-		this._promise = {};
-
-		this._promise.promise = new Promise(function (resolve, reject) { // eslint-disable-line no-use-extend-native/no-use-extend-native
-			self._promise.resolve = resolve;
-			self._promise.reject = reject;
-		}).tap(function (result) {
-			if (self.report) {
-				self.report(result);
-			}
-		});
+		contextRef.context = context;
 	}
+}
 
-	return this._promise;
-};
-
-Test.prototype.run = function () {
-	if (this.metadata.callback) {
-		this.sync = false;
+function onAssertionEvent(event) {
+	if (event.assertionThrew) {
+		if (event.powerAssertContext) {
+			event.error.statements = formatter(event.powerAssertContext);
+			event.error.message = event.originalMessage || '';
+		}
+		this._test._setAssertError(event.error);
+		this._test._assert(null);
+		return null;
 	}
 
-	var self = this;
-
-	this._timeStart = globals.now();
-
-	// wait until all assertions are complete
-	this._timeout = globals.setTimeout(function () {}, maxTimeout);
-
-	var ret = this._run();
-
-	var asyncType = 'promises';
+	let ret = event.returnValue;
 
 	if (isObservable(ret)) {
-		asyncType = 'observables';
 		ret = observableToPromise(ret);
 	}
 
 	if (isPromise(ret)) {
-		this.sync = false;
+		const promise = ret.then(null, err => {
+			err.originalMessage = event.originalMessage;
+			throw err;
+		});
 
-		if (this.metadata.callback) {
-			self._setAssertError(new Error('Do not return ' + asyncType + ' from tests declared via `test.cb(...)`, if you want to return a promise simply declare the test via `test(...)`'));
-		}
+		this._test._assert(promise);
 
-		ret.then(
-			function () {
-				self.exit();
-			},
-			function (err) {
-				if (!(err instanceof Error)) {
-					err = new assert.AssertionError({
-						actual: err,
-						message: 'Promise rejected with: ' + inspect(err, {depth: null}),
-						operator: 'promise'
-					});
-				}
+		return promise;
+	}
 
-				self._setAssertError(err);
-				self.exit();
-			});
+	this._test._assert(null);
 
-		return this.promise().promise;
-	}
+	return ret;
+}
 
-	if (this.metadata.callback && !this.threwSync) {
-		return this.promise().promise;
-	}
+Object.assign(PublicApi.prototype, enhanceAssert({
+	assert,
+	onSuccess: onAssertionEvent,
+	onError: onAssertionEvent
+}));
 
-	return this.exit();
-};
+// Getters
+[
+	'assertCount',
+	'title',
+	'end'
+]
+	.forEach(name => {
+		Object.defineProperty(PublicApi.prototype, name, {
+			get() {
+				return this._test[name];
+			}
+		});
+	});
 
-Test.prototype._result = function () {
-	var reason = this.assertError;
-	var passed = reason === undefined;
+Object.defineProperty(PublicApi.prototype, 'context', {enumerable: true});
 
-	if (this.metadata.failing) {
-		passed = !passed;
+class Test {
+	constructor(title, fn, contextRef, report) {
+		if (typeof title === 'function') {
+			contextRef = fn;
+			fn = title;
+			title = null;
+		}
 
-		if (passed) {
-			reason = undefined;
-		} else {
-			reason = new Error('Test was expected to fail, but succeeded, you should stop marking the test as failing');
+		assert.is(typeof fn, 'function', 'You must provide a callback');
+
+		this.title = title || fnName(fn) || '[anonymous]';
+		this.fn = isGeneratorFn(fn) ? co.wrap(fn) : fn;
+		this.assertions = [];
+		this.planCount = null;
+		this.duration = null;
+		this.assertError = undefined;
+		this.sync = true;
+		this.contextRef = contextRef;
+		this.report = report;
+		this.threwSync = false;
+
+		// TODO(jamestalmage): Make this an optional constructor arg instead of having Runner set it after the fact.
+		// metadata should just always exist, otherwise it requires a bunch of ugly checks all over the place.
+		this.metadata = {};
+
+		// Store the time point before test execution
+		// to calculate the total time spent in test
+		this._timeStart = null;
+
+		// Workaround for Babel giving anonymous functions a name
+		if (this.title === 'callee$0$0') {
+			this.title = '[anonymous]';
 		}
 	}
+	get assertCount() {
+		return this.assertions.length;
+	}
+	_assert(promise) {
+		if (isPromise(promise)) {
+			this.sync = false;
+		}
 
-	return {
-		passed: passed,
-		result: this,
-		reason: reason
-	};
-};
+		this.assertions.push(promise);
+	}
+	_setAssertError(err) {
+		throwsHelper(err);
 
-Object.defineProperty(Test.prototype, 'end', {
-	get: function () {
-		if (this.metadata.callback) {
-			return this._end.bind(this);
+		if (this.assertError !== undefined) {
+			return;
 		}
 
-		throw new Error('t.end is not supported in this context. To use t.end as a callback, you must use "callback mode" via `test.cb(testName, fn)`');
+		this.assertError = err;
 	}
-});
-
-Test.prototype._end = function (err) {
-	if (err) {
-		if (!(err instanceof Error)) {
-			err = new assert.AssertionError({
-				actual: err,
-				message: 'Callback called with an error: ' + inspect(err, {depth: null}),
-				operator: 'callback'
-			});
+	plan(count, planStack) {
+		if (typeof count !== 'number') {
+			throw new TypeError('Expected a number');
 		}
 
-		this._setAssertError(err);
-		this.exit();
+		this.planCount = count;
 
-		return;
+		// In case the `planCount` doesn't match `assertCount,
+		// we need the stack of this function to throw with a useful stack
+		this.planStack = planStack;
 	}
+	_run() {
+		let ret;
+
+		try {
+			ret = this.fn(this._publicApi());
+		} catch (err) {
+			this.threwSync = true;
+
+			if (err instanceof Error) {
+				this._setAssertError(err);
+			} else {
+				this._setAssertError(new assert.AssertionError({
+					actual: err,
+					message: `Non-error thrown with value: ${inspect(err, {depth: null})}`,
+					operator: 'catch'
+				}));
+			}
+		}
 
-	if (this.endCalled) {
-		this._setAssertError(new Error('.end() called more than once'));
-		return;
+		return ret;
 	}
+	promise() {
+		if (!this._promise) {
+			this._promise = {};
+
+			this._promise.promise = new Promise((resolve, reject) => {
+				this._promise.resolve = resolve;
+				this._promise.reject = reject;
+			}).tap(result => {
+				if (this.report) {
+					this.report(result);
+				}
+			});
+		}
 
-	this.endCalled = true;
-	this.exit();
-};
-
-Test.prototype._checkPlanCount = function () {
-	if (this.assertError === undefined && this.planCount !== null && this.planCount !== this.assertions.length) {
-		this._setAssertError(new assert.AssertionError({
-			actual: this.assertions.length,
-			expected: this.planCount,
-			message: 'Planned for ' + this.planCount + plur(' assertion', this.planCount) + ', but got ' + this.assertions.length + '.',
-			operator: 'plan'
-		}));
-
-		this.assertError.stack = this.planStack;
+		return this._promise;
 	}
-};
-
-Test.prototype.exit = function () {
-	var self = this;
+	run() {
+		if (this.metadata.callback) {
+			this.sync = false;
+		}
 
-	this._checkPlanCount();
+		this._timeStart = globals.now();
 
-	if (this.sync || this.threwSync) {
-		self.duration = globals.now() - self._timeStart;
-		globals.clearTimeout(self._timeout);
+		// Wait until all assertions are complete
+		this._timeout = globals.setTimeout(() => {}, maxTimeout);
 
-		var result = this._result();
+		let ret = this._run();
+		let asyncType = 'promises';
 
-		if (this.report) {
-			this.report(result);
+		if (isObservable(ret)) {
+			asyncType = 'observables';
+			ret = observableToPromise(ret);
 		}
 
-		return result;
-	}
-
-	Promise.all(this.assertions)
-		.catch(function (err) {
-			self._setAssertError(err);
-		})
-		.finally(function () {
-			// calculate total time spent in test
-			self.duration = globals.now() - self._timeStart;
-
-			// stop infinite timer
-			globals.clearTimeout(self._timeout);
+		if (isPromise(ret)) {
+			this.sync = false;
 
-			self._checkPlanCount();
+			if (this.metadata.callback) {
+				this._setAssertError(new Error(`Do not return ${asyncType} from tests declared via \`test.cb(...)\`, if you want to return a promise simply declare the test via \`test(...)\``));
+			}
 
-			self.promise().resolve(self._result());
-		});
+			// Convert to a Bluebird promise
+			return Promise.resolve(ret).then(
+				() => this.exit(),
+				err => {
+					if (!(err instanceof Error)) {
+						err = new assert.AssertionError({
+							actual: err,
+							message: `Promise rejected with: ${inspect(err, {depth: null})}`,
+							operator: 'promise'
+						});
+					}
+
+					this._setAssertError(err);
+					return this.exit();
+				}
+			);
+		}
 
-	return self.promise().promise;
-};
+		if (this.metadata.callback && !this.threwSync) {
+			return this.promise().promise;
+		}
 
-Test.prototype._publicApi = function () {
-	return new PublicApi(this);
-};
+		return this.exit();
+	}
+	_result() {
+		let reason = this.assertError;
+		let passed = reason === undefined;
 
-function PublicApi(test) {
-	this._test = test;
-	this.skip = new SkipApi(test);
-}
+		if (this.metadata.failing) {
+			passed = !passed;
 
-function onAssertionEvent(event) {
-	if (event.assertionThrew) {
-		if (event.powerAssertContext) {
-			event.error.message = formatter(event.powerAssertContext);
-			if (event.originalMessage) {
-				event.error.message = event.originalMessage + ' ' + event.error.message;
+			if (passed) {
+				reason = undefined;
+			} else {
+				reason = new Error('Test was expected to fail, but succeeded, you should stop marking the test as failing');
 			}
 		}
-		this._test._setAssertError(event.error);
-		this._test._assert(null);
-		return null;
-	}
 
-	var ret = event.returnValue;
+		return {
+			passed,
+			result: this,
+			reason
+		};
+	}
+	get end() {
+		if (this.metadata.callback) {
+			return this._end.bind(this);
+		}
 
-	if (isObservable(ret)) {
-		ret = observableToPromise(ret);
+		throw new Error('t.end is not supported in this context. To use t.end as a callback, you must use "callback mode" via `test.cb(testName, fn)`');
 	}
+	_end(err) {
+		if (err) {
+			if (!(err instanceof Error)) {
+				err = new assert.AssertionError({
+					actual: err,
+					message: 'Callback called with an error: ' + inspect(err, {depth: null}),
+					operator: 'callback'
+				});
+			}
 
-	if (isPromise(ret)) {
-		var promise = ret.then(null, function (err) {
-			err.originalMessage = event.originalMessage;
-			throw err;
-		});
+			this._setAssertError(err);
+			this.exit();
 
-		this._test._assert(promise);
+			return;
+		}
 
-		return promise;
-	}
+		if (this.endCalled) {
+			this._setAssertError(new Error('.end() called more than once'));
+			return;
+		}
 
-	this._test._assert(null);
+		this.endCalled = true;
+		this.exit();
+	}
+	_checkPlanCount() {
+		if (this.assertError === undefined && this.planCount !== null && this.planCount !== this.assertions.length) {
+			this._setAssertError(new assert.AssertionError({
+				actual: this.assertions.length,
+				expected: this.planCount,
+				message: `Planned for ${this.planCount} ${plur('assertion', this.planCount)}, but got ${this.assertions.length}.`,
+				operator: 'plan'
+			}));
 
-	return ret;
-}
+			this.assertError.stack = this.planStack;
+		}
+	}
+	exit() {
+		this._checkPlanCount();
 
-PublicApi.prototype = enhanceAssert({
-	assert: assert,
-	onSuccess: onAssertionEvent,
-	onError: onAssertionEvent
-});
+		if (this.sync || this.threwSync) {
+			this.duration = globals.now() - this._timeStart;
+			globals.clearTimeout(this._timeout);
 
-PublicApi.prototype.plan = function plan(ct) {
-	var limitBefore = Error.stackTraceLimit;
-	Error.stackTraceLimit = 1;
-	var obj = {};
-	Error.captureStackTrace(obj, plan);
-	Error.stackTraceLimit = limitBefore;
-	this._test.plan(ct, obj.stack);
-};
+			const result = this._result();
 
-// Getters
-[
-	'assertCount',
-	'title',
-	'end'
-]
-	.forEach(function (name) {
-		Object.defineProperty(PublicApi.prototype, name, {
-			enumerable: false,
-			get: function () {
-				return this._test[name];
+			if (this.report) {
+				this.report(result);
 			}
-		});
-	});
 
-// Get / Set
-Object.defineProperty(PublicApi.prototype, 'context', {
-	enumerable: true,
-	get: function () {
-		var contextRef = this._test.contextRef;
-		return contextRef && contextRef.context;
-	},
-	set: function (context) {
-		var contextRef = this._test.contextRef;
-
-		if (!contextRef) {
-			this._test._setAssertError(new Error('t.context is not available in ' + this._test.metadata.type + ' tests'));
-			return;
+			return result;
 		}
 
-		contextRef.context = context;
-	}
-});
+		Promise.all(this.assertions)
+			.catch(err => {
+				this._setAssertError(err);
+			})
+			.finally(() => {
+				// Calculate total time spent in test
+				this.duration = globals.now() - this._timeStart;
 
-function skipFn() {
-	return this._test._assert(null);
-}
+				// Stop infinite timer
+				globals.clearTimeout(this._timeout);
+
+				this._checkPlanCount();
 
-function SkipApi(test) {
-	this._test = test;
+				this.promise().resolve(this._result());
+			});
+
+		return this.promise().promise;
+	}
+	_publicApi() {
+		return new PublicApi(this);
+	}
 }
 
-Object.keys(assert).forEach(function (el) {
-	SkipApi.prototype[el] = skipFn;
-});
+module.exports = Test;