ava 0.16.0 → 0.18.2

package/lib/assert.js

@@ -1,85 +1,88 @@
 'use strict';
-var util = require('util');
-var assert = require('core-assert');
-var deepEqual = require('not-so-shallow');
-var observableToPromise = require('observable-to-promise');
-var isObservable = require('is-observable');
-var isPromise = require('is-promise');
-
-var x = module.exports;
+const assert = require('core-assert');
+const deepEqual = require('lodash.isequal');
+const observableToPromise = require('observable-to-promise');
+const indentString = require('indent-string');
+const isObservable = require('is-observable');
+const isPromise = require('is-promise');
+const jestSnapshot = require('jest-snapshot');
+const snapshotState = require('./snapshot-state');
+
+const x = module.exports;
+const noop = () => {};
 
 Object.defineProperty(x, 'AssertionError', {value: assert.AssertionError});
 
-function noop() {}
-
 function create(val, expected, operator, msg, fn) {
 	return {
 		actual: val,
-		expected: expected,
-		message: msg,
-		operator: operator,
+		expected,
+		message: msg || ' ',
+		operator,
 		stackStartFunction: fn
 	};
 }
 
 function test(ok, opts) {
 	if (!ok) {
-		throw new assert.AssertionError(opts);
+		const err = new assert.AssertionError(opts);
+		err.showOutput = ['fail', 'throws', 'notThrows'].indexOf(err.operator) === -1;
+		throw err;
 	}
 }
 
-x.pass = function (msg) {
+x.pass = msg => {
 	test(true, create(true, true, 'pass', msg, x.pass));
 };
 
-x.fail = function (msg) {
+x.fail = msg => {
 	msg = msg || 'Test failed via t.fail()';
 	test(false, create(false, false, 'fail', msg, x.fail));
 };
 
-x.truthy = function (val, msg) {
+x.truthy = (val, msg) => {
 	test(val, create(val, true, '==', msg, x.truthy));
 };
 
-x.falsy = function (val, msg) {
+x.falsy = (val, msg) => {
 	test(!val, create(val, false, '==', msg, x.falsy));
 };
 
-x.true = function (val, msg) {
+x.true = (val, msg) => {
 	test(val === true, create(val, true, '===', msg, x.true));
 };
 
-x.false = function (val, msg) {
+x.false = (val, msg) => {
 	test(val === false, create(val, false, '===', msg, x.false));
 };
 
-x.is = function (val, expected, msg) {
+x.is = (val, expected, msg) => {
 	test(val === expected, create(val, expected, '===', msg, x.is));
 };
 
-x.not = function (val, expected, msg) {
+x.not = (val, expected, msg) => {
 	test(val !== expected, create(val, expected, '!==', msg, x.not));
 };
 
-x.deepEqual = function (val, expected, msg) {
+x.deepEqual = (val, expected, msg) => {
 	test(deepEqual(val, expected), create(val, expected, '===', msg, x.deepEqual));
 };
 
-x.notDeepEqual = function (val, expected, msg) {
+x.notDeepEqual = (val, expected, msg) => {
 	test(!deepEqual(val, expected), create(val, expected, '!==', msg, x.notDeepEqual));
 };
 
-x.throws = function (fn, err, msg) {
+x.throws = (fn, err, msg) => {
 	if (isObservable(fn)) {
 		fn = observableToPromise(fn);
 	}
 
 	if (isPromise(fn)) {
 		return fn
-			.then(function () {
+			.then(() => {
 				x.throws(noop, err, msg);
-			}, function (fnErr) {
-				return x.throws(function () {
+			}, fnErr => {
+				return x.throws(() => {
 					throw fnErr;
 				}, err, msg);
 			});
@@ -91,15 +94,13 @@ x.throws = function (fn, err, msg) {
 
 	try {
 		if (typeof err === 'string') {
-			var errMsg = err;
-			err = function (err) {
-				return err.message === errMsg;
-			};
+			const errMsg = err;
+			err = err => err.message === errMsg;
 		}
 
-		var result;
+		let result;
 
-		assert.throws(function () {
+		assert.throws(() => {
 			try {
 				fn();
 			} catch (err) {
@@ -110,19 +111,19 @@ x.throws = function (fn, err, msg) {
 
 		return result;
 	} catch (err) {
-		test(false, create(err.actual, err.expected, err.operator, err.message, x.throws));
+		test(false, create(err.actual, err.expected, 'throws', err.message, x.throws));
 	}
 };
 
-x.notThrows = function (fn, msg) {
+x.notThrows = (fn, msg) => {
 	if (isObservable(fn)) {
 		fn = observableToPromise(fn);
 	}
 
 	if (isPromise(fn)) {
 		return fn
-			.catch(function (err) {
-				x.notThrows(function () {
+			.catch(err => {
+				x.notThrows(() => {
 					throw err;
 				}, msg);
 			});
@@ -135,31 +136,64 @@ x.notThrows = function (fn, msg) {
 	try {
 		assert.doesNotThrow(fn, msg);
 	} catch (err) {
-		test(false, create(err.actual, err.expected, err.operator, err.message, x.notThrows));
+		test(false, create(err.actual, err.expected, 'notThrows', err.message, x.notThrows));
 	}
 };
 
-x.regex = function (contents, regex, msg) {
+x.regex = (contents, regex, msg) => {
 	test(regex.test(contents), create(regex, contents, '===', msg, x.regex));
 };
 
-x.notRegex = function (contents, regex, msg) {
+x.notRegex = (contents, regex, msg) => {
 	test(!regex.test(contents), create(regex, contents, '!==', msg, x.notRegex));
 };
 
-x.ifError = x.error = function (err, msg) {
+x.ifError = (err, msg) => {
 	test(!err, create(err, 'Error', '!==', msg, x.ifError));
 };
 
-/*
- * deprecated APIs
- */
-x.doesNotThrow = util.deprecate(x.notThrows, getDeprecationNotice('doesNotThrow()', 'notThrows()'));
-x.ok = util.deprecate(x.truthy, getDeprecationNotice('ok()', 'truthy()'));
-x.notOk = util.deprecate(x.falsy, getDeprecationNotice('notOk()', 'falsy()'));
-x.same = util.deprecate(x.deepEqual, getDeprecationNotice('same()', 'deepEqual()'));
-x.notSame = util.deprecate(x.notDeepEqual, getDeprecationNotice('notSame()', 'notDeepEqual()'));
+x._snapshot = function (tree, optionalMessage, match, snapshotStateGetter) {
+	// Set defaults - this allows tests to mock deps easily
+	const toMatchSnapshot = match || jestSnapshot.toMatchSnapshot;
+	const getState = snapshotStateGetter || snapshotState.get;
 
-function getDeprecationNotice(oldApi, newApi) {
-	return 'DEPRECATION NOTICE: ' + oldApi + ' has been renamed to ' + newApi + ' and will eventually be removed. See https://github.com/avajs/ava-codemods to help upgrade your codebase automatically.';
-}
+	const state = getState();
+
+	const context = {
+		dontThrow() {},
+		currentTestName: this.title,
+		snapshotState: state
+	};
+
+	// Symbols can't be serialized and saved in a snapshot, that's why tree
+	// is saved in the `__ava_react_jsx` prop, so that JSX can be detected later
+	const serializedTree = tree.$$typeof === Symbol.for('react.test.json') ? {__ava_react_jsx: tree} : tree; // eslint-disable-line camelcase
+	const result = toMatchSnapshot.call(context, JSON.stringify(serializedTree));
+
+	let message = 'Please check your code or --update-snapshots';
+
+	if (optionalMessage) {
+		message += '\n\n' + indentString(optionalMessage, 2);
+	}
+
+	state.save();
+
+	let expected;
+
+	if (result.expected) {
+		// JSON in a snapshot is surrounded with `"`, because jest-snapshot
+		// serializes snapshot values too, so it ends up double JSON encoded
+		expected = JSON.parse(result.expected.slice(1).slice(0, -1));
+		// Define a `$$typeof` symbol, so that pretty-format detects it as React tree
+		if (expected.__ava_react_jsx) { // eslint-disable-line camelcase
+			expected = expected.__ava_react_jsx; // eslint-disable-line camelcase
+			Object.defineProperty(expected, '$$typeof', {value: Symbol.for('react.test.json')});
+		}
+	}
+
+	test(result.pass, create(tree, expected, 'snapshot', message, x.snapshot));
+};
+
+x.snapshot = function (tree, optionalMessage) {
+	x._snapshot.call(this, tree, optionalMessage);
+};

package/lib/ava-error.js

@@ -1,14 +1,10 @@
 'use strict';
 
-function AvaError(message) {
-	if (!(this instanceof AvaError)) {
-		throw new TypeError('Class constructor AvaError cannot be invoked without \'new\'');
+class AvaError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = 'AvaError';
 	}
-
-	this.message = message;
-	this.name = 'AvaError';
 }
 
-AvaError.prototype = Object.create(Error.prototype);
-
 module.exports = AvaError;

package/lib/ava-files.js

@@ -0,0 +1,282 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const Promise = require('bluebird');
+const slash = require('slash');
+const globby = require('globby');
+const flatten = require('lodash.flatten');
+const autoBind = require('auto-bind');
+const defaultIgnore = require('ignore-by-default').directories();
+const multimatch = require('multimatch');
+
+function handlePaths(files, excludePatterns, globOptions) {
+	// Convert Promise to Bluebird
+	files = Promise.resolve(globby(files.concat(excludePatterns), globOptions));
+
+	const searchedParents = new Set();
+	const foundFiles = new Set();
+
+	function alreadySearchingParent(dir) {
+		if (searchedParents.has(dir)) {
+			return true;
+		}
+
+		const parentDir = path.dirname(dir);
+
+		if (parentDir === dir) {
+			// We have reached the root path
+			return false;
+		}
+
+		return alreadySearchingParent(parentDir);
+	}
+
+	return files
+		.map(file => {
+			file = path.resolve(globOptions.cwd, file);
+
+			if (fs.statSync(file).isDirectory()) {
+				if (alreadySearchingParent(file)) {
+					return null;
+				}
+
+				searchedParents.add(file);
+
+				let pattern = path.join(file, '**', '*.js');
+
+				if (process.platform === 'win32') {
+					// Always use `/` in patterns, harmonizing matching across platforms
+					pattern = slash(pattern);
+				}
+
+				return handlePaths([pattern], excludePatterns, globOptions);
+			}
+
+			// `globby` returns slashes even on Windows. Normalize here so the file
+			// paths are consistently platform-accurate as tests are run.
+			return path.normalize(file);
+		})
+		.then(flatten)
+		.filter(file => file && path.extname(file) === '.js')
+		.filter(file => {
+			if (path.basename(file)[0] === '_' && globOptions.includeUnderscoredFiles !== true) {
+				return false;
+			}
+
+			return true;
+		})
+		.map(file => path.resolve(file))
+		.filter(file => {
+			const alreadyFound = foundFiles.has(file);
+			foundFiles.add(file);
+			return !alreadyFound;
+		});
+}
+
+const defaultExcludePatterns = () => [
+	'!**/node_modules/**',
+	'!**/fixtures/**',
+	'!**/helpers/**'
+];
+
+const defaultIncludePatterns = () => [
+	'test.js',
+	'test-*.js',
+	'test',
+	'**/__tests__',
+	'**/*.test.js'
+];
+
+const defaultHelperPatterns = () => [
+	'**/__tests__/helpers/**/*.js',
+	'**/__tests__/**/_*.js',
+	'**/test/helpers/**/*.js',
+	'**/test/**/_*.js'
+];
+
+const getDefaultIgnorePatterns = () => defaultIgnore.map(dir => `${dir}/**/*`);
+
+// Used on paths before they're passed to multimatch to harmonize matching
+// across platforms
+const matchable = process.platform === 'win32' ? slash : (path => path);
+
+class AvaFiles {
+	constructor(options) {
+		options = options || {};
+
+		let files = (options.files || []).map(file => {
+			// `./` should be removed from the beginning of patterns because
+			// otherwise they won't match change events from Chokidar
+			if (file.slice(0, 2) === './') {
+				return file.slice(2);
+			}
+
+			return file;
+		});
+
+		if (files.length === 0) {
+			files = defaultIncludePatterns();
+		}
+
+		this.excludePatterns = defaultExcludePatterns();
+		this.files = files;
+		this.sources = options.sources || [];
+		this.cwd = options.cwd || process.cwd();
+
+		autoBind(this);
+	}
+	findTestFiles() {
+		return handlePaths(this.files, this.excludePatterns, {
+			cwd: this.cwd,
+			cache: Object.create(null),
+			statCache: Object.create(null),
+			realpathCache: Object.create(null),
+			symlinks: Object.create(null)
+		});
+	}
+	findTestHelpers() {
+		return handlePaths(defaultHelperPatterns(), ['!**/node_modules/**'], {
+			cwd: this.cwd,
+			includeUnderscoredFiles: true,
+			cache: Object.create(null),
+			statCache: Object.create(null),
+			realpathCache: Object.create(null),
+			symlinks: Object.create(null)
+		});
+	}
+	isSource(filePath) {
+		let mixedPatterns = [];
+		const defaultIgnorePatterns = getDefaultIgnorePatterns();
+		const overrideDefaultIgnorePatterns = [];
+
+		let hasPositivePattern = false;
+		this.sources.forEach(pattern => {
+			mixedPatterns.push(pattern);
+
+			// TODO: Why not just `pattern[0] !== '!'`?
+			if (!hasPositivePattern && pattern[0] !== '!') {
+				hasPositivePattern = true;
+			}
+
+			// Extract patterns that start with an ignored directory. These need to be
+			// rematched separately.
+			if (defaultIgnore.indexOf(pattern.split('/')[0]) >= 0) {
+				overrideDefaultIgnorePatterns.push(pattern);
+			}
+		});
+
+		// Same defaults as used for Chokidar
+		if (!hasPositivePattern) {
+			mixedPatterns = ['package.json', '**/*.js'].concat(mixedPatterns);
+		}
+
+		filePath = matchable(filePath);
+
+		// Ignore paths outside the current working directory.
+		// They can't be matched to a pattern.
+		if (/^\.\.\//.test(filePath)) {
+			return false;
+		}
+
+		const isSource = multimatch(filePath, mixedPatterns).length === 1;
+		if (!isSource) {
+			return false;
+		}
+
+		const isIgnored = multimatch(filePath, defaultIgnorePatterns).length === 1;
+		if (!isIgnored) {
+			return true;
+		}
+
+		const isErroneouslyIgnored = multimatch(filePath, overrideDefaultIgnorePatterns).length === 1;
+		if (isErroneouslyIgnored) {
+			return true;
+		}
+
+		return false;
+	}
+	isTest(filePath) {
+		const excludePatterns = this.excludePatterns;
+		const initialPatterns = this.files.concat(excludePatterns);
+
+		// Like in `api.js`, tests must be `.js` files and not start with `_`
+		if (path.extname(filePath) !== '.js' || path.basename(filePath)[0] === '_') {
+			return false;
+		}
+
+		// Check if the entire path matches a pattern
+		if (multimatch(matchable(filePath), initialPatterns).length === 1) {
+			return true;
+		}
+
+		// Check if the path contains any directory components
+		const dirname = path.dirname(filePath);
+		if (dirname === '.') {
+			return false;
+		}
+
+		// Compute all possible subpaths. Note that the dirname is assumed to be
+		// relative to the working directory, without a leading `./`.
+		const subpaths = dirname.split(/[\\/]/).reduce((subpaths, component) => {
+			const parent = subpaths[subpaths.length - 1];
+
+			if (parent) {
+				// Always use `/`` to makes multimatch consistent across platforms
+				subpaths.push(`${parent}/${component}`);
+			} else {
+				subpaths.push(component);
+			}
+
+			return subpaths;
+		}, []);
+
+		// Check if any of the possible subpaths match a pattern. If so, generate a
+		// new pattern with **/*.js.
+		const recursivePatterns = subpaths
+			.filter(subpath => multimatch(subpath, initialPatterns).length === 1)
+			// Always use `/` to makes multimatch consistent across platforms
+			.map(subpath => `${subpath}/**/*.js`);
+
+		// See if the entire path matches any of the subpaths patterns, taking the
+		// excludePatterns into account. This mimicks the behavior in api.js
+		return multimatch(matchable(filePath), recursivePatterns.concat(excludePatterns)).length === 1;
+	}
+	getChokidarPatterns() {
+		let paths = [];
+		let ignored = [];
+
+		this.sources.forEach(pattern => {
+			if (pattern[0] === '!') {
+				ignored.push(pattern.slice(1));
+			} else {
+				paths.push(pattern);
+			}
+		});
+
+		// Allow source patterns to override the default ignore patterns. Chokidar
+		// ignores paths that match the list of ignored patterns. It uses anymatch
+		// under the hood, which supports negation patterns. For any source pattern
+		// that starts with an ignored directory, ensure the corresponding negation
+		// pattern is added to the ignored paths.
+		const overrideDefaultIgnorePatterns = paths
+			.filter(pattern => defaultIgnore.indexOf(pattern.split('/')[0]) >= 0)
+			.map(pattern => `!${pattern}`);
+
+		ignored = getDefaultIgnorePatterns().concat(ignored, overrideDefaultIgnorePatterns);
+
+		if (paths.length === 0) {
+			paths = ['package.json', '**/*.js'];
+		}
+
+		paths = paths.concat(this.files);
+
+		return {
+			paths,
+			ignored
+		};
+	}
+}
+
+module.exports = AvaFiles;
+module.exports.defaultIncludePatterns = defaultIncludePatterns;
+module.exports.defaultExcludePatterns = defaultExcludePatterns;