Alternative for deepEqual, formatting, diffs and snapshots

docs/recipes/watch-mode.md

@@ -65,7 +65,7 @@ AVA uses [`chokidar`] as the file watcher. Note that even if you see warnings ab
 
 In AVA there's a distinction between *source files* and *test files*. As you can imagine the *test files* contain your tests. *Source files* are all other files that are needed for the tests to run, be it your source code or test fixtures.
 
-By default AVA watches for changes to the test files, `package.json`, and any other `.js` files. It'll ignore files in [certain directories](https://github.com/novemberborn/ignore-by-default/blob/master/index.js) as provided by the [`ignore-by-default`] package.
+By default AVA watches for changes to the test files, snapshot files, `package.json`, and any other `.js` files. It'll ignore files in [certain directories](https://github.com/novemberborn/ignore-by-default/blob/master/index.js) as provided by the [`ignore-by-default`] package.
 
 You can configure patterns for the source files in the [`ava` section of your `package.json`] file, using the `source` key.
 

lib/assert.js

@@ -1,12 +1,32 @@
 'use strict';
+const concordance = require('concordance');
 const coreAssert = require('core-assert');
-const deepEqual = require('lodash.isequal');
 const observableToPromise = require('observable-to-promise');
 const isObservable = require('is-observable');
 const isPromise = require('is-promise');
-const jestDiff = require('jest-diff');
+const concordanceOptions = require('./concordance-options').default;
+const concordanceDiffOptions = require('./concordance-options').diff;
 const enhanceAssert = require('./enhance-assert');
-const formatAssertError = require('./format-assert-error');
+const snapshotManager = require('./snapshot-manager');
+
+function formatDescriptorDiff(actualDescriptor, expectedDescriptor, options) {
+	options = Object.assign({}, options, concordanceDiffOptions);
+	return {
+		label: 'Difference:',
+		formatted: concordance.diffDescriptors(actualDescriptor, expectedDescriptor, options)
+	};
+}
+
+function formatDescriptorWithLabel(label, descriptor) {
+	return {
+		label,
+		formatted: concordance.formatDescriptor(descriptor, concordanceOptions)
+	};
+}
+
+function formatWithLabel(label, value) {
+	return formatDescriptorWithLabel(label, concordance.describe(value, concordanceOptions));
+}
 
 class AssertionError extends Error {
 	constructor(opts) {
@@ -61,16 +81,12 @@ function wrapAssertions(callbacks) {
 			if (Object.is(actual, expected)) {
 				pass(this);
 			} else {
-				const diff = formatAssertError.formatDiff(actual, expected);
-				const values = diff ? [diff] : [
-					formatAssertError.formatWithLabel('Actual:', actual),
-					formatAssertError.formatWithLabel('Must be the same as:', expected)
-				];
-
+				const actualDescriptor = concordance.describe(actual, concordanceOptions);
+				const expectedDescriptor = concordance.describe(expected, concordanceOptions);
 				fail(this, new AssertionError({
 					assertion: 'is',
 					message,
-					values
+					values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)]
 				}));
 			}
 		},
@@ -80,37 +96,36 @@ function wrapAssertions(callbacks) {
 				fail(this, new AssertionError({
 					assertion: 'not',
 					message,
-					values: [formatAssertError.formatWithLabel('Value is the same as:', actual)]
+					values: [formatWithLabel('Value is the same as:', actual)]
 				}));
 			} else {
 				pass(this);
 			}
 		},
 
 		deepEqual(actual, expected, message) {
-			if (deepEqual(actual, expected)) {
+			const result = concordance.compare(actual, expected, concordanceOptions);
+			if (result.pass) {
 				pass(this);
 			} else {
-				const diff = formatAssertError.formatDiff(actual, expected);
-				const values = diff ? [diff] : [
-					formatAssertError.formatWithLabel('Actual:', actual),
-					formatAssertError.formatWithLabel('Must be deeply equal to:', expected)
-				];
-
+				const actualDescriptor = result.actual || concordance.describe(actual, concordanceOptions);
+				const expectedDescriptor = result.expected || concordance.describe(expected, concordanceOptions);
 				fail(this, new AssertionError({
 					assertion: 'deepEqual',
 					message,
-					values
+					values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)]
 				}));
 			}
 		},
 
 		notDeepEqual(actual, expected, message) {
-			if (deepEqual(actual, expected)) {
+			const result = concordance.compare(actual, expected, concordanceOptions);
+			if (result.pass) {
+				const actualDescriptor = result.actual || concordance.describe(actual, concordanceOptions);
 				fail(this, new AssertionError({
 					assertion: 'notDeepEqual',
 					message,
-					values: [formatAssertError.formatWithLabel('Value is deeply equal:', actual)]
+					values: [formatDescriptorWithLabel('Value is deeply equal:', actualDescriptor)]
 				}));
 			} else {
 				pass(this);
@@ -128,7 +143,7 @@ function wrapAssertions(callbacks) {
 					assertion: 'throws',
 					improperUsage: true,
 					message: '`t.throws()` must be called with a function, Promise, or Observable',
-					values: [formatAssertError.formatWithLabel('Called with:', fn)]
+					values: [formatWithLabel('Called with:', fn)]
 				}));
 				return;
 			}
@@ -157,15 +172,13 @@ function wrapAssertions(callbacks) {
 					}, coreAssertThrowsErrorArg);
 					return actual;
 				} catch (err) {
-					const values = threw ?
-						[formatAssertError.formatWithLabel('Threw unexpected exception:', actual)] :
-						null;
-
 					throw new AssertionError({
 						assertion: 'throws',
 						message,
 						stack,
-						values
+						values: threw ?
+							[formatWithLabel('Threw unexpected exception:', actual)] :
+							null
 					});
 				}
 			};
@@ -177,7 +190,7 @@ function wrapAssertions(callbacks) {
 					throw new AssertionError({
 						assertion: 'throws',
 						message: 'Expected promise to be rejected, but it was resolved instead',
-						values: [formatAssertError.formatWithLabel('Resolved with:', value)]
+						values: [formatWithLabel('Resolved with:', value)]
 					});
 				}, reason => test(makeRethrow(reason), stack));
 
@@ -206,7 +219,7 @@ function wrapAssertions(callbacks) {
 					assertion: 'notThrows',
 					improperUsage: true,
 					message: '`t.notThrows()` must be called with a function, Promise, or Observable',
-					values: [formatAssertError.formatWithLabel('Called with:', fn)]
+					values: [formatWithLabel('Called with:', fn)]
 				}));
 				return;
 			}
@@ -219,7 +232,7 @@ function wrapAssertions(callbacks) {
 						assertion: 'notThrows',
 						message,
 						stack,
-						values: [formatAssertError.formatWithLabel('Threw:', err.actual)]
+						values: [formatWithLabel('Threw:', err.actual)]
 					});
 				}
 			};
@@ -246,28 +259,57 @@ function wrapAssertions(callbacks) {
 				fail(this, new AssertionError({
 					assertion: 'ifError',
 					message,
-					values: [formatAssertError.formatWithLabel('Error:', actual)]
+					values: [formatWithLabel('Error:', actual)]
 				}));
 			} else {
 				pass(this);
 			}
 		},
 
-		snapshot(actual, message) {
-			const state = this._test.getSnapshotState();
-			const result = state.match(this.title, actual);
+		snapshot(expected, optionsOrMessage, message) {
+			const options = {};
+			if (typeof optionsOrMessage === 'string') {
+				message = optionsOrMessage;
+			} else if (optionsOrMessage) {
+				options.id = optionsOrMessage.id;
+			}
+			options.expected = expected;
+			options.message = message;
+
+			let result;
+			try {
+				result = this._test.compareWithSnapshot(options);
+			} catch (err) {
+				if (!(err instanceof snapshotManager.SnapshotError)) {
+					throw err;
+				}
+
+				const improperUsage = {name: err.name, snapPath: err.snapPath};
+				if (err instanceof snapshotManager.VersionMismatchError) {
+					improperUsage.snapVersion = err.snapVersion;
+					improperUsage.expectedVersion = err.expectedVersion;
+				}
+
+				fail(this, new AssertionError({
+					assertion: 'snapshot',
+					message: message || 'Could not compare snapshot',
+					improperUsage
+				}));
+				return;
+			}
+
 			if (result.pass) {
 				pass(this);
-			} else {
-				const diff = jestDiff(result.expected.trim(), result.actual.trim(), {expand: true})
-					// Remove annotation
-					.split('\n')
-					.slice(3)
-					.join('\n');
+			} else if (result.actual) {
 				fail(this, new AssertionError({
 					assertion: 'snapshot',
 					message: message || 'Did not match snapshot',
-					values: [{label: 'Difference:', formatted: diff}]
+					values: [formatDescriptorDiff(result.actual, result.expected, {invert: true})]
+				}));
+			} else {
+				fail(this, new AssertionError({
+					assertion: 'snapshot',
+					message: message || 'No snapshot available, run with --update-snapshots'
 				}));
 			}
 		}
@@ -280,7 +322,7 @@ function wrapAssertions(callbacks) {
 					assertion: 'truthy',
 					message,
 					operator: '!!',
-					values: [formatAssertError.formatWithLabel('Value is not truthy:', actual)]
+					values: [formatWithLabel('Value is not truthy:', actual)]
 				});
 			}
 		},
@@ -291,7 +333,7 @@ function wrapAssertions(callbacks) {
 					assertion: 'falsy',
 					message,
 					operator: '!',
-					values: [formatAssertError.formatWithLabel('Value is not falsy:', actual)]
+					values: [formatWithLabel('Value is not falsy:', actual)]
 				});
 			}
 		},
@@ -301,7 +343,7 @@ function wrapAssertions(callbacks) {
 				throw new AssertionError({
 					assertion: 'true',
 					message,
-					values: [formatAssertError.formatWithLabel('Value is not `true`:', actual)]
+					values: [formatWithLabel('Value is not `true`:', actual)]
 				});
 			}
 		},
@@ -311,7 +353,7 @@ function wrapAssertions(callbacks) {
 				throw new AssertionError({
 					assertion: 'false',
 					message,
-					values: [formatAssertError.formatWithLabel('Value is not `false`:', actual)]
+					values: [formatWithLabel('Value is not `false`:', actual)]
 				});
 			}
 		},
@@ -322,15 +364,15 @@ function wrapAssertions(callbacks) {
 					assertion: 'regex',
 					improperUsage: true,
 					message: '`t.regex()` must be called with a string',
-					values: [formatAssertError.formatWithLabel('Called with:', string)]
+					values: [formatWithLabel('Called with:', string)]
 				});
 			}
 			if (!(regex instanceof RegExp)) {
 				throw new AssertionError({
 					assertion: 'regex',
 					improperUsage: true,
 					message: '`t.regex()` must be called with a regular expression',
-					values: [formatAssertError.formatWithLabel('Called with:', regex)]
+					values: [formatWithLabel('Called with:', regex)]
 				});
 			}
 
@@ -339,8 +381,8 @@ function wrapAssertions(callbacks) {
 					assertion: 'regex',
 					message,
 					values: [
-						formatAssertError.formatWithLabel('Value must match expression:', string),
-						formatAssertError.formatWithLabel('Regular expression:', regex)
+						formatWithLabel('Value must match expression:', string),
+						formatWithLabel('Regular expression:', regex)
 					]
 				});
 			}
@@ -352,15 +394,15 @@ function wrapAssertions(callbacks) {
 					assertion: 'notRegex',
 					improperUsage: true,
 					message: '`t.notRegex()` must be called with a string',
-					values: [formatAssertError.formatWithLabel('Called with:', string)]
+					values: [formatWithLabel('Called with:', string)]
 				});
 			}
 			if (!(regex instanceof RegExp)) {
 				throw new AssertionError({
 					assertion: 'notRegex',
 					improperUsage: true,
 					message: '`t.notRegex()` must be called with a regular expression',
-					values: [formatAssertError.formatWithLabel('Called with:', regex)]
+					values: [formatWithLabel('Called with:', regex)]
 				});
 			}
 
@@ -369,8 +411,8 @@ function wrapAssertions(callbacks) {
 					assertion: 'notRegex',
 					message,
 					values: [
-						formatAssertError.formatWithLabel('Value must not match expression:', string),
-						formatAssertError.formatWithLabel('Regular expression:', regex)
+						formatWithLabel('Value must not match expression:', string),
+						formatWithLabel('Regular expression:', regex)
 					]
 				});
 			}

lib/ava-files.js

@@ -265,7 +265,7 @@ class AvaFiles {
 		ignored = getDefaultIgnorePatterns().concat(ignored, overrideDefaultIgnorePatterns);
 
 		if (paths.length === 0) {
-			paths = ['package.json', '**/*.js'];
+			paths = ['package.json', '**/*.js', '**/*.snap'];
 		}
 
 		paths = paths.concat(this.files);