ava 0.16.0 → 0.18.2

package/lib/concurrent.js

@@ -1,96 +1,83 @@
 'use strict';
-var Promise = require('bluebird');
-var isPromise = require('is-promise');
-var AvaError = require('./ava-error');
-
-function noop() {}
-
-module.exports = Concurrent;
+const Promise = require('bluebird');
+const isPromise = require('is-promise');
+const autoBind = require('auto-bind');
+const AvaError = require('./ava-error');
+
+class Concurrent {
+	constructor(tests, bail) {
+		if (!Array.isArray(tests)) {
+			throw new TypeError('Expected an array of tests');
+		}
 
-function Concurrent(tests, bail) {
-	if (!(this instanceof Concurrent)) {
-		throw new TypeError('Class constructor Concurrent cannot be invoked without \'new\'');
-	}
+		this.results = [];
+		this.passed = true;
+		this.reason = null;
+		this.tests = tests;
+		this.bail = bail || false;
 
-	if (!Array.isArray(tests)) {
-		throw new TypeError('Expected an array of tests');
+		autoBind(this);
 	}
+	run() {
+		let results;
 
-	this.results = [];
-	this.passed = true;
-	this.reason = null;
-	this.tests = tests;
-	this.bail = bail || false;
+		try {
+			results = this.tests.map(this._runTest);
+		} catch (err) {
+			if (err instanceof AvaError) {
+				return this._results();
+			}
 
-	Object.keys(Concurrent.prototype).forEach(function (key) {
-		this[key] = this[key].bind(this);
-	}, this);
-}
-
-Concurrent.prototype.run = function () {
-	var results;
-
-	try {
-		results = this.tests.map(this._runTest);
-	} catch (err) {
-		if (err instanceof AvaError) {
-			return this._results();
+			throw err;
 		}
 
-		throw err;
-	}
+		const isAsync = results.some(isPromise);
 
-	var isAsync = results.some(isPromise);
+		if (isAsync) {
+			return Promise.all(results)
+				.catch(AvaError, () => {})
+				.then(this._results);
+		}
 
-	if (isAsync) {
-		return Promise.all(results)
-			.catch(AvaError, noop)
-			.then(this._results);
+		return this._results();
 	}
+	_runTest(test, index) {
+		const result = test.run();
 
-	return this._results();
-};
-
-Concurrent.prototype._runTest = function (test, index) {
-	var result = test.run();
-
-	if (isPromise(result)) {
-		var self = this;
+		if (isPromise(result)) {
+			return result.then(result => this._addResult(result, index));
+		}
 
-		return result.then(function (result) {
-			return self._addResult(result, index);
-		});
+		return this._addResult(result, index);
 	}
+	_addResult(result, index) {
+		// Always save result when not in bail mode or all previous tests pass
+		if ((this.bail && this.passed) || !this.bail) {
+			this.results[index] = result;
+		}
 
-	return this._addResult(result, index);
-};
-
-Concurrent.prototype._addResult = function (result, index) {
-	// always save result when not in bail mode or all previous tests pass
-	if ((this.bail && this.passed) || !this.bail) {
-		this.results[index] = result;
-	}
+		if (result.passed === false) {
+			this.passed = false;
 
-	if (result.passed === false) {
-		this.passed = false;
+			// Only set reason once
+			if (!this.reason) {
+				this.reason = result.reason;
+			}
 
-		// only set reason once
-		if (!this.reason) {
-			this.reason = result.reason;
+			if (this.bail) {
+				throw new AvaError('Error in Concurrent while in bail mode');
+			}
 		}
 
-		if (this.bail) {
-			throw new AvaError('Error in Concurrent while in bail mode');
-		}
+		return result;
 	}
+	_results() {
+		return {
+			passed: this.passed,
+			reason: this.reason,
+			result: this.results
+		};
+	}
+}
 
-	return result;
-};
-
-Concurrent.prototype._results = function () {
-	return {
-		passed: this.passed,
-		reason: this.reason,
-		result: this.results
-	};
-};
+module.exports = Concurrent;

package/lib/enhance-assert.js

@@ -1,68 +1,76 @@
 'use strict';
+const dotProp = require('dot-prop');
 
-module.exports = enhanceAssert;
-module.exports.formatter = formatter;
-
-module.exports.PATTERNS = [
+// When adding patterns, don't forget to add to
+// https://github.com/avajs/babel-preset-transform-test-files/blob/master/espower-patterns.json
+// Then release a new version of that preset and bump the SemVer range here.
+const PATTERNS = [
 	't.truthy(value, [message])',
 	't.falsy(value, [message])',
 	't.true(value, [message])',
 	't.false(value, [message])',
-	't.is(value, expected, [message])',
-	't.not(value, expected, [message])',
-	't.deepEqual(value, expected, [message])',
-	't.notDeepEqual(value, expected, [message])',
 	't.regex(contents, regex, [message])',
-	't.notRegex(contents, regex, [message])',
-	// deprecated apis
-	't.ok(value, [message])',
-	't.notOk(value, [message])',
-	't.same(value, expected, [message])',
-	't.notSame(value, expected, [message])'
+	't.notRegex(contents, regex, [message])'
 ];
 
-module.exports.NON_ENHANCED_PATTERNS = [
+const NON_ENHANCED_PATTERNS = [
 	't.pass([message])',
 	't.fail([message])',
 	't.throws(fn, [message])',
 	't.notThrows(fn, [message])',
-	't.ifError(error, [message])'
+	't.ifError(error, [message])',
+	't.snapshot(contents, [message])',
+	't.is(value, expected, [message])',
+	't.not(value, expected, [message])',
+	't.deepEqual(value, expected, [message])',
+	't.notDeepEqual(value, expected, [message])'
 ];
 
-function enhanceAssert(opts) {
-	var empower = require('empower-core');
-
-	var enhanced = empower(
-		opts.assert,
-		{
-			destructive: false,
-			onError: opts.onError,
-			onSuccess: opts.onSuccess,
-			patterns: module.exports.PATTERNS,
-			wrapOnlyPatterns: module.exports.NON_ENHANCED_PATTERNS,
-			bindReceiver: false
-		}
-	);
+const enhanceAssert = opts => {
+	const empower = require('empower-core');
+	const enhanced = empower(opts.assert, {
+		destructive: false,
+		onError: opts.onError,
+		onSuccess: opts.onSuccess,
+		patterns: PATTERNS,
+		wrapOnlyPatterns: NON_ENHANCED_PATTERNS,
+		bindReceiver: false
+	});
 
 	return enhanced;
-}
+};
 
-function formatter() {
-	var createFormatter = require('power-assert-context-formatter');
-	var SuccinctRenderer = require('power-assert-renderer-succinct');
-	var AssertionRenderer = require('power-assert-renderer-assertion');
+const isRangeMatch = (a, b) => {
+	return (a[0] === b[0] && a[1] === b[1]) ||
+		(a[0] > b[0] && a[0] < b[1]) ||
+		(a[1] > b[0] && a[1] < b[1]);
+};
 
-	return createFormatter({
-		renderers: [
-			{
-				ctor: AssertionRenderer
-			},
-			{
-				ctor: SuccinctRenderer,
-				options: {
-					maxDepth: 3
-				}
-			}
-		]
-	});
-}
+const computeStatement = (tokens, range) => {
+	return tokens
+		.filter(token => isRangeMatch(token.range, range))
+		.map(token => token.value === undefined ? token.type.label : token.value)
+		.join('');
+};
+
+const getNode = (ast, path) => dotProp.get(ast, path.replace(/\//g, '.'));
+
+const formatter = () => {
+	return context => {
+		const ast = JSON.parse(context.source.ast);
+		const tokens = JSON.parse(context.source.tokens);
+		const args = context.args[0].events;
+
+		return args
+			.map(arg => {
+				const range = getNode(ast, arg.espath).range;
+				return [computeStatement(tokens, range), arg.value];
+			})
+			.reverse();
+	};
+};
+
+module.exports = enhanceAssert;
+module.exports.PATTERNS = PATTERNS;
+module.exports.NON_ENHANCED_PATTERNS = NON_ENHANCED_PATTERNS;
+module.exports.formatter = formatter;

package/lib/extract-stack.js

@@ -0,0 +1,10 @@
+'use strict';
+const stackLineRegex = /^.+ \(.+:[0-9]+:[0-9]+\)$/;
+
+module.exports = stack => {
+	return stack
+		.split('\n')
+		.filter(line => stackLineRegex.test(line))
+		.map(line => line.trim())
+		.join('\n');
+};

package/lib/fork.js

@@ -1,39 +1,34 @@
 'use strict';
-var childProcess = require('child_process');
-var path = require('path');
-var fs = require('fs');
-var objectAssign = require('object-assign');
-var Promise = require('bluebird');
-var debug = require('debug')('ava');
-var AvaError = require('./ava-error');
-var doSend = require('./send');
+const childProcess = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const Promise = require('bluebird');
+const debug = require('debug')('ava');
+const AvaError = require('./ava-error');
 
 if (fs.realpathSync(__filename) !== __filename) {
-	console.warn(
-		'WARNING: `npm link ava` and the `--preserve-symlink` flag are incompatible. ' +
-		'We have detected that AVA is linked via `npm link`, and that you are using either ' +
-		'an early version of Node 6, or the `--preserve-symlink` flag. This breaks AVA. ' +
-		'You should upgrade to Node 6.2.0+, avoid the `--preserve-symlink` flag, or avoid using `npm link ava`.'
-	);
+	console.warn('WARNING: `npm link ava` and the `--preserve-symlink` flag are incompatible. We have detected that AVA is linked via `npm link`, and that you are using either an early version of Node 6, or the `--preserve-symlink` flag. This breaks AVA. You should upgrade to Node 6.2.0+, avoid the `--preserve-symlink` flag, or avoid using `npm link ava`.');
 }
 
-var env = process.env;
+let env = process.env;
 
-// ensure NODE_PATH paths are absolute
+// Ensure NODE_PATH paths are absolute
 if (env.NODE_PATH) {
-	env = objectAssign({}, env);
+	env = Object.assign({}, env);
 
 	env.NODE_PATH = env.NODE_PATH
 		.split(path.delimiter)
-		.map(function (x) {
-			return path.resolve(x);
-		})
+		.map(x => path.resolve(x))
 		.join(path.delimiter);
 }
 
-module.exports = function (file, opts) {
-	opts = objectAssign({
-		file: file,
+// In case the test file imports a different AVA install,
+// the presence of this variable allows it to require this one instead
+env.AVA_PATH = path.resolve(__dirname, '..');
+
+module.exports = (file, opts, execArgv) => {
+	opts = Object.assign({
+		file,
 		baseDir: process.cwd(),
 		tty: process.stdout.isTTY ? {
 			columns: process.stdout.columns,
@@ -41,37 +36,44 @@ module.exports = function (file, opts) {
 		} : false
 	}, opts);
 
-	var ps = childProcess.fork(path.join(__dirname, 'test-worker.js'), [JSON.stringify(opts)], {
-		cwd: path.dirname(file),
+	const args = [JSON.stringify(opts), opts.color ? '--color' : '--no-color'];
+
+	const ps = childProcess.fork(path.join(__dirname, 'test-worker.js'), args, {
+		cwd: opts.projectDir,
 		silent: true,
-		env: env
+		env,
+		execArgv: execArgv || process.execArgv
 	});
 
-	var relFile = path.relative('.', file);
+	const relFile = path.relative('.', file);
 
-	var exiting = false;
-	var send = function (ps, name, data) {
+	let exiting = false;
+	const send = (name, data) => {
 		if (!exiting) {
 			// This seems to trigger a Node bug which kills the AVA master process, at
 			// least while running AVA's tests. See
 			// <https://github.com/novemberborn/_ava-tap-crash> for more details.
-			doSend(ps, name, data);
+			ps.send({
+				name: `ava-${name}`,
+				data,
+				ava: true
+			});
 		}
 	};
 
-	var testResults = [];
-	var results;
+	const testResults = [];
+	let results;
 
-	var promise = new Promise(function (resolve, reject) {
+	const promise = new Promise((resolve, reject) => {
 		ps.on('error', reject);
 
-		// emit `test` and `stats` events
-		ps.on('message', function (event) {
+		// Emit `test` and `stats` events
+		ps.on('message', event => {
 			if (!event.ava) {
 				return;
 			}
 
-			event.name = event.name.replace(/^ava\-/, '');
+			event.name = event.name.replace(/^ava-/, '');
 			event.data.file = relFile;
 
 			debug('ipc %s:\n%o', event.name, event.data);
@@ -79,36 +81,36 @@ module.exports = function (file, opts) {
 			ps.emit(event.name, event.data);
 		});
 
-		ps.on('test', function (props) {
+		ps.on('test', props => {
 			testResults.push(props);
 		});
 
-		ps.on('results', function (data) {
+		ps.on('results', data => {
 			results = data;
 			data.tests = testResults;
-			send(ps, 'teardown');
+			send('teardown');
 		});
 
-		ps.on('exit', function (code, signal) {
+		ps.on('exit', (code, signal) => {
 			if (code > 0) {
-				return reject(new AvaError(relFile + ' exited with a non-zero exit code: ' + code));
+				return reject(new AvaError(`${relFile} exited with a non-zero exit code: ${code}`));
 			}
 
 			if (code === null && signal) {
-				return reject(new AvaError(relFile + ' exited due to ' + signal));
+				return reject(new AvaError(`${relFile} exited due to ${signal}`));
 			}
 
 			if (results) {
 				resolve(results);
 			} else {
-				reject(new AvaError('Test results were not received from ' + relFile));
+				reject(new AvaError(`Test results were not received from ${relFile}`));
 			}
 		});
 
-		ps.on('no-tests', function (data) {
-			send(ps, 'teardown');
+		ps.on('no-tests', data => {
+			send('teardown');
 
-			var message = 'No tests found in ' + relFile;
+			let message = `No tests found in ${relFile}`;
 
 			if (!data.avaRequired) {
 				message += ', make sure to import "ava" at the top of your test file';
@@ -118,58 +120,55 @@ module.exports = function (file, opts) {
 		});
 	});
 
-	// teardown finished, now exit
-	ps.on('teardown', function () {
-		send(ps, 'exit');
+	// Teardown finished, now exit
+	ps.on('teardown', () => {
+		send('exit');
 		exiting = true;
 	});
 
-	// uncaught exception in fork, need to exit
-	ps.on('uncaughtException', function () {
-		send(ps, 'teardown');
+	// Uncaught exception in fork, need to exit
+	ps.on('uncaughtException', () => {
+		send('teardown');
 	});
 
-	ps.stdout.on('data', function (data) {
+	ps.stdout.on('data', data => {
 		ps.emit('stdout', data);
 	});
 
-	ps.stderr.on('data', function (data) {
+	ps.stderr.on('data', data => {
 		ps.emit('stderr', data);
 	});
 
 	promise.on = function () {
 		ps.on.apply(ps, arguments);
-
 		return promise;
 	};
 
-	promise.send = function (name, data) {
-		send(ps, name, data);
-
+	promise.send = (name, data) => {
+		send(name, data);
 		return promise;
 	};
 
-	promise.exit = function () {
-		send(ps, 'init-exit');
-
+	promise.exit = () => {
+		send('init-exit');
 		return promise;
 	};
 
-	// send 'run' event only when fork is listening for it
-	var isReady = false;
+	// Send 'run' event only when fork is listening for it
+	let isReady = false;
 
-	ps.on('stats', function () {
+	ps.on('stats', () => {
 		isReady = true;
 	});
 
-	promise.run = function (options) {
+	promise.run = options => {
 		if (isReady) {
-			send(ps, 'run', options);
+			send('run', options);
 			return promise;
 		}
 
-		ps.on('stats', function () {
-			send(ps, 'run', options);
+		ps.on('stats', () => {
+			send('run', options);
 		});
 
 		return promise;

package/lib/format-assert-error.js

@@ -0,0 +1,72 @@
+'use strict';
+const indentString = require('indent-string');
+const chalk = require('chalk');
+const diff = require('diff');
+
+const cleanUp = line => {
+	if (line[0] === '+') {
+		return `${chalk.green('+')} ${line.slice(1)}`;
+	}
+
+	if (line[0] === '-') {
+		return `${chalk.red('-')} ${line.slice(1)}`;
+	}
+
+	if (line.match(/@@/)) {
+		return null;
+	}
+
+	if (line.match(/\\ No newline/)) {
+		return null;
+	}
+
+	return ` ${line}`;
+};
+
+module.exports = err => {
+	if (err.statements) {
+		const statements = JSON.parse(err.statements);
+
+		return statements
+			.map(statement => `${statement[0]}\n${chalk.grey('=>')} ${statement[1]}`)
+			.join('\n\n') + '\n';
+	}
+
+	if ((err.actualType === 'object' || err.actualType === 'array') && err.actualType === err.expectedType) {
+		const patch = diff.createPatch('string', err.actual, err.expected);
+		const msg = patch
+			.split('\n')
+			.slice(4)
+			.map(cleanUp)
+			.filter(Boolean)
+			.join('\n');
+
+		return `Difference:\n\n${msg}`;
+	}
+
+	if (err.actualType === 'string' && err.expectedType === 'string') {
+		const patch = diff.diffChars(err.actual, err.expected);
+		const msg = patch
+			.map(part => {
+				if (part.added) {
+					return chalk.bgGreen.black(part.value);
+				}
+
+				if (part.removed) {
+					return chalk.bgRed.black(part.value);
+				}
+
+				return part.value;
+			})
+			.join('');
+
+		return `Difference:\n\n${msg}\n`;
+	}
+
+	return [
+		'Actual:\n',
+		`${indentString(err.actual, 2)}\n`,
+		'Expected:\n',
+		`${indentString(err.expected, 2)}\n`
+	].join('\n');
+};

package/lib/globals.js

@@ -1,15 +1,10 @@
 'use strict';
 
-// Global objects / functions to be bound before requiring test file, so tests do not interfere.
-
-var x = module.exports;
+// Global objects / functions to be bound before requiring test file, so tests do not interfere
 
+const x = module.exports;
 x.now = Date.now;
-
 x.setTimeout = setTimeout;
-
 x.clearTimeout = clearTimeout;
-
-x.setImmediate = require('set-immediate-shim');
-
+x.setImmediate = setImmediate;
 x.options = {};

package/lib/hook.js

@@ -1,27 +1,22 @@
 'use strict';
-var Test = require('./test');
+const Test = require('./test');
 
-module.exports = Hook;
+class Hook {
+	constructor(title, fn) {
+		if (typeof title === 'function') {
+			fn = title;
+			title = null;
+		}
 
-function Hook(title, fn) {
-	if (!(this instanceof Hook)) {
-		throw new TypeError('Class constructor Hook cannot be invoked without \'new\'');
+		this.title = title;
+		this.fn = fn;
 	}
-
-	if (typeof title === 'function') {
-		fn = title;
-		title = null;
+	test(testTitle) {
+		const title = this.title || `${this.metadata.type} for "${testTitle}"`;
+		const test = new Test(title, this.fn);
+		test.metadata = this.metadata;
+		return test;
 	}
-
-	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;
-};
+module.exports = Hook;