ava 0.16.0 → 0.18.2

package/lib/sequence.js

@@ -1,103 +1,87 @@
 'use strict';
-var isPromise = require('is-promise');
-var AvaError = require('./ava-error');
-
-function noop() {}
-
-module.exports = Sequence;
-
-function Sequence(tests, bail) {
-	if (!(this instanceof Sequence)) {
-		throw new TypeError('Class constructor Sequence cannot be invoked without \'new\'');
-	}
-
-	if (!tests) {
-		throw new Error('Sequence items can\'t be undefined');
-	}
-
-	this.results = [];
-	this.passed = true;
-	this.reason = null;
-	this.tests = tests;
-	this.bail = bail || false;
-
-	// TODO(vdemedes): separate into a utility (it's being used in serveral places)
-	Object.keys(Sequence.prototype).forEach(function (key) {
-		this[key] = this[key].bind(this);
-	}, this);
-}
-
-Sequence.prototype.run = function () {
-	var length = this.tests.length;
-
-	for (var i = 0; i < length; i++) {
-		// if last item failed and we should bail, return results and stop
-		if (this.bail && !this.passed) {
-			return this._results();
+const isPromise = require('is-promise');
+const autoBind = require('auto-bind');
+const AvaError = require('./ava-error');
+
+class Sequence {
+	constructor(tests, bail) {
+		if (!tests) {
+			throw new Error('Sequence items can\'t be undefined');
 		}
 
-		var result = this.tests[i].run();
+		this.results = [];
+		this.passed = true;
+		this.reason = null;
+		this.tests = tests;
+		this.bail = bail || false;
 
-		// if a Promise returned, we don't need to check for Promises after this test
-		// so we can just use Promise.each() on the rest of the tests
-		if (isPromise(result)) {
-			return result
-				.then(this._addResult)
-				.return(this.tests.slice(i + 1))
-				.each(this._runTest)
-				.catch(AvaError, noop)
-				.then(this._results);
-		}
+		autoBind(this);
+	}
+	run() {
+		const length = this.tests.length;
 
-		try {
-			this._addResult(result);
-		} catch (err) {
-			// in bail mode, don't execute the next tests
-			if (err instanceof AvaError) {
+		for (let i = 0; i < length; i++) {
+			// If last item failed and we should bail, return results and stop
+			if (this.bail && !this.passed) {
 				return this._results();
 			}
 
-			throw err;
-		}
-	}
+			const result = this.tests[i].run();
+
+			// If a Promise returned, we don't need to check for Promises after this test
+			// so we can just use Promise.each() on the rest of the tests
+			if (isPromise(result)) {
+				return result
+					.then(this._addResult)
+					.return(this.tests.slice(i + 1))
+					.each(this._runTest)
+					.catch(AvaError, () => {})
+					.then(this._results);
+			}
 
-	return this._results();
-};
+			try {
+				this._addResult(result);
+			} catch (err) {
+				// In bail mode, don't execute the next tests
+				if (err instanceof AvaError) {
+					return this._results();
+				}
 
-Sequence.prototype._runTest = function (test) {
-	var result = test.run();
+				throw err;
+			}
+		}
 
-	if (isPromise(result)) {
-		return result
-			.then(this._addResult);
+		return this._results();
 	}
+	_runTest(test) {
+		const result = test.run();
+		return isPromise(result) ? result.then(this._addResult) : this._addResult(result);
+	}
+	_addResult(result) {
+		this.results.push(result);
 
-	return this._addResult(result);
-};
-
-Sequence.prototype._addResult = function (result) {
-	this.results.push(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 Sequence while in bail mode');
+			}
 		}
 
-		if (this.bail) {
-			throw new AvaError('Error in Sequence while in bail mode');
-		}
+		return result;
 	}
+	_results() {
+		return {
+			passed: this.passed,
+			reason: this.reason,
+			result: this.results
+		};
+	}
+}
 
-	return result;
-};
-
-Sequence.prototype._results = function () {
-	return {
-		passed: this.passed,
-		reason: this.reason,
-		result: this.results
-	};
-};
+module.exports = Sequence;

package/lib/serialize-error.js

@@ -1,6 +1,19 @@
 'use strict';
-var cleanYamlObject = require('clean-yaml-object');
-var beautifyStack = require('./beautify-stack');
+const path = require('path');
+const cleanYamlObject = require('clean-yaml-object');
+const StackUtils = require('stack-utils');
+const prettyFormat = require('@ava/pretty-format');
+const reactTestPlugin = require('@ava/pretty-format/plugins/ReactTestComponent');
+const beautifyStack = require('./beautify-stack');
+const extractStack = require('./extract-stack');
+
+function serializeValue(value) {
+	return prettyFormat(value, {
+		callToJSON: false,
+		plugins: [reactTestPlugin],
+		highlight: true
+	});
+}
 
 function filter(propertyName, isRoot, source, target) {
 	if (!isRoot) {
@@ -12,9 +25,60 @@ function filter(propertyName, isRoot, source, target) {
 		return false;
 	}
 
+	if (propertyName === 'statements') {
+		if (source.showOutput) {
+			target.statements = JSON.stringify(source[propertyName].map(statement => {
+				const path = statement[0];
+				const value = serializeValue(statement[1]);
+
+				return [path, value];
+			}));
+		}
+
+		return false;
+	}
+
+	if (propertyName === 'actual' || propertyName === 'expected') {
+		if (source.showOutput) {
+			const value = source[propertyName];
+			target[propertyName + 'Type'] = typeof value;
+			target[propertyName] = serializeValue(value);
+		}
+
+		return false;
+	}
+
 	return true;
 }
 
-module.exports = function (error) {
-	return cleanYamlObject(error, filter);
+const stackUtils = new StackUtils();
+
+module.exports = error => {
+	const err = cleanYamlObject(error, filter);
+
+	if (err.stack) {
+		const firstStackLine = extractStack(err.stack).split('\n')[0];
+		const source = stackUtils.parseLine(firstStackLine);
+		if (source) {
+			// Assume the CWD is the project directory. This holds since this function
+			// is only called in test workers, which are created with their working
+			// directory set to the project directory.
+			const projectDir = process.cwd();
+
+			const file = path.resolve(projectDir, source.file.trim());
+			const rel = path.relative(projectDir, file);
+
+			const isWithinProject = rel.split(path.sep)[0] !== '..';
+			const isDependency = isWithinProject && path.dirname(rel).split(path.sep).indexOf('node_modules') > -1;
+
+			err.source = {
+				isDependency,
+				isWithinProject,
+				file,
+				line: source.line
+			};
+		}
+	}
+
+	return err;
 };

package/lib/snapshot-state.js

@@ -0,0 +1,30 @@
+'use strict';
+const path = require('path');
+const jestSnapshot = require('jest-snapshot');
+const globals = require('./globals');
+
+const x = module.exports;
+
+x.get = (initializeState, globalsOptions) => {
+	if (!x.state) {
+		// Set defaults - this allows tests to mock deps easily
+		const options = globalsOptions || globals.options;
+		const initializeSnapshotState = initializeState || jestSnapshot.initializeSnapshotState;
+
+		const filename = options.file;
+		const dirname = path.dirname(filename);
+		const snapshotFileName = path.basename(filename) + '.snap';
+		const snapshotsFolder = path.join(dirname, '__snapshots__', snapshotFileName);
+
+		x.state = initializeSnapshotState(
+			filename,
+			options.updateSnapshots,
+			snapshotsFolder,
+			true
+		);
+	}
+
+	return x.state;
+};
+
+x.state = null;

package/lib/test-collection.js

@@ -1,196 +1,184 @@
 'use strict';
-var EventEmitter = require('events').EventEmitter;
-var util = require('util');
-var fnName = require('fn-name');
-var Concurrent = require('./concurrent');
-var Sequence = require('./sequence');
-var Test = require('./test');
-
-module.exports = TestCollection;
+const EventEmitter = require('events');
+const fnName = require('fn-name');
+const Concurrent = require('./concurrent');
+const Sequence = require('./sequence');
+const Test = require('./test');
+
+class TestCollection extends EventEmitter {
+	constructor() {
+		super();
+
+		this.hasExclusive = false;
+		this.testCount = 0;
+
+		this.tests = {
+			concurrent: [],
+			serial: []
+		};
+
+		this.hooks = {
+			before: [],
+			beforeEach: [],
+			after: [],
+			afterAlways: [],
+			afterEach: [],
+			afterEachAlways: []
+		};
+
+		this._emitTestResult = this._emitTestResult.bind(this);
+	}
+	add(test) {
+		const metadata = test.metadata;
+		const type = metadata.type;
+
+		if (!type) {
+			throw new Error('Test type must be specified');
+		}
 
-function TestCollection() {
-	if (!(this instanceof TestCollection)) {
-		throw new TypeError('Class constructor TestCollection cannot be invoked without \'new\'');
-	}
+		if (!test.title && test.fn) {
+			test.title = fnName(test.fn);
+		}
 
-	EventEmitter.call(this);
+		// Workaround for Babel giving anonymous functions a name
+		if (test.title === 'callee$0$0') {
+			test.title = null;
+		}
 
-	this.hasExclusive = false;
-	this.tests = {
-		concurrent: [],
-		serial: []
-	};
+		if (!test.title) {
+			if (type === 'test') {
+				test.title = '[anonymous]';
+			} else {
+				test.title = type;
+			}
+		}
 
-	this.hooks = {
-		before: [],
-		beforeEach: [],
-		after: [],
-		afterAlways: [],
-		afterEach: [],
-		afterEachAlways: []
-	};
+		if (metadata.always && type !== 'after' && type !== 'afterEach') {
+			throw new Error('"always" can only be used with after and afterEach hooks');
+		}
 
-	this._emitTestResult = this._emitTestResult.bind(this);
-}
+		// Add a hook
+		if (type !== 'test') {
+			if (metadata.exclusive) {
+				throw new Error(`"only" cannot be used with a ${type} hook`);
+			}
 
-util.inherits(TestCollection, EventEmitter);
+			this.hooks[type + (metadata.always ? 'Always' : '')].push(test);
+			return;
+		}
 
-TestCollection.prototype.add = function (test) {
-	var metadata = test.metadata;
-	var type = metadata.type;
+		this.testCount++;
 
-	if (!type) {
-		throw new Error('Test type must be specified');
-	}
-
-	if (!test.title && test.fn) {
-		test.title = fnName(test.fn);
-	}
+		// Add `.only()` tests if `.only()` was used previously
+		if (this.hasExclusive && !metadata.exclusive) {
+			return;
+		}
 
-	// workaround for Babel giving anonymous functions a name
-	if (test.title === 'callee$0$0') {
-		test.title = null;
-	}
+		if (metadata.exclusive && !this.hasExclusive) {
+			this.tests.concurrent = [];
+			this.tests.serial = [];
+			this.hasExclusive = true;
+		}
 
-	if (!test.title) {
-		if (type === 'test') {
-			test.title = '[anonymous]';
+		if (metadata.serial) {
+			this.tests.serial.push(test);
 		} else {
-			test.title = type;
+			this.tests.concurrent.push(test);
 		}
 	}
+	_skippedTest(test) {
+		const self = this;
 
-	if (metadata.always && type !== 'after' && type !== 'afterEach') {
-		throw new Error('"always" can only be used with after and afterEach hooks');
-	}
+		return {
+			run() {
+				const result = {
+					passed: true,
+					result: test
+				};
 
-	// add a hook
-	if (type !== 'test') {
-		if (metadata.exclusive) {
-			throw new Error('"only" cannot be used with a ' + type + ' hook');
-		}
+				self._emitTestResult(result);
 
-		this.hooks[type + (metadata.always ? 'Always' : '')].push(test);
-		return;
+				return result;
+			}
+		};
 	}
-
-	// add .only() tests if .only() was used previously
-	if (this.hasExclusive && !metadata.exclusive) {
-		return;
+	_emitTestResult(test) {
+		this.emit('test', test);
 	}
+	_buildHooks(hooks, testTitle, context) {
+		return hooks.map(hook => {
+			const test = this._buildHook(hook, testTitle, context);
 
-	if (metadata.exclusive && !this.hasExclusive) {
-		this.tests.concurrent = [];
-		this.tests.serial = [];
-		this.hasExclusive = true;
-	}
+			if (hook.metadata.skipped || hook.metadata.todo) {
+				return this._skippedTest(test);
+			}
 
-	if (metadata.serial) {
-		this.tests.serial.push(test);
-	} else {
-		this.tests.concurrent.push(test);
+			return test;
+		});
 	}
-};
-
-TestCollection.prototype._skippedTest = function (test) {
-	var self = this;
+	_buildHook(hook, testTitle, context) {
+		let title = hook.title;
 
-	return {
-		run: function () {
-			var result = {
-				passed: true,
-				result: test
-			};
-
-			self._emitTestResult(result);
-
-			return result;
+		if (testTitle) {
+			title += ` for ${testTitle}`;
 		}
-	};
-};
-
-TestCollection.prototype._emitTestResult = function (test) {
-	this.emit('test', test);
-};
 
-TestCollection.prototype._buildHooks = function (hooks, testTitle, context) {
-	return hooks.map(function (hook) {
-		var test = this._buildHook(hook, testTitle, context);
-
-		if (hook.metadata.skipped || hook.metadata.todo) {
-			return this._skippedTest(test);
+		if (!context) {
+			context = null;
 		}
 
-		return test;
-	}, this);
-};
-
-TestCollection.prototype._buildHook = function (hook, testTitle, context) {
-	var title = hook.title;
+		const test = new Test(title, hook.fn, context, this._emitTestResult);
+		test.metadata = hook.metadata;
 
-	if (testTitle) {
-		title += ' for ' + testTitle;
-	}
-
-	if (!context) {
-		context = null;
+		return test;
 	}
+	_buildTest(test, context) {
+		if (!context) {
+			context = null;
+		}
 
-	var test = new Test(title, hook.fn, context, this._emitTestResult);
-	test.metadata = hook.metadata;
+		const metadata = test.metadata;
 
-	return test;
-};
+		test = new Test(test.title, test.fn, context, this._emitTestResult);
+		test.metadata = metadata;
 
-TestCollection.prototype._buildTest = function (test, context) {
-	if (!context) {
-		context = null;
+		return test;
 	}
+	_buildTestWithHooks(test) {
+		if (test.metadata.skipped) {
+			return new Sequence([this._skippedTest(this._buildTest(test))], true);
+		}
 
-	var metadata = test.metadata;
-
-	test = new Test(test.title, test.fn, context, this._emitTestResult);
-	test.metadata = metadata;
+		const context = {context: {}};
 
-	return test;
-};
+		const beforeHooks = this._buildHooks(this.hooks.beforeEach, test.title, context);
+		const afterHooks = this._buildHooks(this.hooks.afterEach, test.title, context);
 
-TestCollection.prototype._buildTestWithHooks = function (test) {
-	if (test.metadata.skipped) {
-		return new Sequence([this._skippedTest(this._buildTest(test))], true);
+		let sequence = new Sequence([].concat(beforeHooks, this._buildTest(test, context), afterHooks), true);
+		if (this.hooks.afterEachAlways.length > 0) {
+			const afterAlwaysHooks = new Sequence(this._buildHooks(this.hooks.afterEachAlways, test.title, context));
+			sequence = new Sequence([sequence, afterAlwaysHooks], false);
+		}
+		return sequence;
 	}
+	_buildTests(tests) {
+		return tests.map(test => this._buildTestWithHooks(test));
+	}
+	build(bail) {
+		const beforeHooks = new Sequence(this._buildHooks(this.hooks.before));
+		const afterHooks = new Sequence(this._buildHooks(this.hooks.after));
 
-	var context = {context: {}};
-
-	var beforeHooks = this._buildHooks(this.hooks.beforeEach, test.title, context);
-	var afterHooks = this._buildHooks(this.hooks.afterEach, test.title, context);
+		const serialTests = new Sequence(this._buildTests(this.tests.serial), bail);
+		const concurrentTests = new Concurrent(this._buildTests(this.tests.concurrent), bail);
+		const allTests = new Sequence([serialTests, concurrentTests]);
 
-	var sequence = new Sequence([].concat(beforeHooks, this._buildTest(test, context), afterHooks), true);
-	if (this.hooks.afterEachAlways.length !== 0) {
-		var afterAlwaysHooks = new Sequence(this._buildHooks(this.hooks.afterEachAlways, test.title, context));
-		sequence = new Sequence([sequence, afterAlwaysHooks], false);
-	}
-	return sequence;
-};
-
-TestCollection.prototype._buildTests = function (tests) {
-	return tests.map(function (test) {
-		return this._buildTestWithHooks(test);
-	}, this);
-};
-
-TestCollection.prototype.build = function (bail) {
-	var beforeHooks = new Sequence(this._buildHooks(this.hooks.before));
-	var afterHooks = new Sequence(this._buildHooks(this.hooks.after));
-
-	var serialTests = new Sequence(this._buildTests(this.tests.serial), bail);
-	var concurrentTests = new Concurrent(this._buildTests(this.tests.concurrent), bail);
-	var allTests = new Sequence([serialTests, concurrentTests]);
-
-	var finalTests = new Sequence([beforeHooks, allTests, afterHooks], true);
-	if (this.hooks.afterAlways.length !== 0) {
-		var afterAlwaysHooks = new Sequence(this._buildHooks(this.hooks.afterAlways));
-		finalTests = new Sequence([finalTests, afterAlwaysHooks], false);
+		let finalTests = new Sequence([beforeHooks, allTests, afterHooks], true);
+		if (this.hooks.afterAlways.length > 0) {
+			const afterAlwaysHooks = new Sequence(this._buildHooks(this.hooks.afterAlways));
+			finalTests = new Sequence([finalTests, afterAlwaysHooks], false);
+		}
+		return finalTests;
 	}
-	return finalTests;
-};
+}
+
+module.exports = TestCollection;