diff --git a/docs/recipes/watch-mode.md b/docs/recipes/watch-mode.md
index d4e764007..800d72e69 100644
--- a/docs/recipes/watch-mode.md
+++ b/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.
diff --git a/lib/assert.js b/lib/assert.js
index b15568109..8d0b1e4c8 100644
--- a/lib/assert.js
+++ b/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,7 +96,7 @@ 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);
@@ -88,29 +104,28 @@ function wrapAssertions(callbacks) {
},
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,7 +364,7 @@ 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)) {
@@ -330,7 +372,7 @@ function wrapAssertions(callbacks) {
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,7 +394,7 @@ 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)) {
@@ -360,7 +402,7 @@ function wrapAssertions(callbacks) {
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)
]
});
}
diff --git a/lib/ava-files.js b/lib/ava-files.js
index dd9a2ee6d..cfdc9f202 100644
--- a/lib/ava-files.js
+++ b/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);
diff --git a/lib/concordance-options.js b/lib/concordance-options.js
new file mode 100644
index 000000000..e3aca849e
--- /dev/null
+++ b/lib/concordance-options.js
@@ -0,0 +1,129 @@
+'use strict';
+const ansiStyles = require('ansi-styles');
+const chalk = require('chalk');
+const cloneDeepWith = require('lodash.clonedeepwith');
+const reactPlugin = require('@concordance/react');
+const options = require('./globals').options;
+
+// Wrap Concordance's React plugin. Change the name to avoid collisions if in
+// the future users can register plugins themselves.
+const avaReactPlugin = Object.assign({}, reactPlugin, {name: 'ava-plugin-react'});
+const plugins = [avaReactPlugin];
+
+const forceColor = new chalk.constructor({enabled: true});
+
+const colorTheme = {
+ boolean: ansiStyles.yellow,
+ circular: forceColor.grey('[Circular]'),
+ date: {
+ invalid: forceColor.red('invalid'),
+ value: ansiStyles.blue
+ },
+ diffGutters: {
+ actual: forceColor.red('-') + ' ',
+ expected: forceColor.green('+') + ' ',
+ padding: ' '
+ },
+ error: {
+ ctor: {open: ansiStyles.grey.open + '(', close: ')' + ansiStyles.grey.close},
+ name: ansiStyles.magenta
+ },
+ function: {
+ name: ansiStyles.blue,
+ stringTag: ansiStyles.magenta
+ },
+ global: ansiStyles.magenta,
+ item: {after: forceColor.grey(',')},
+ list: {openBracket: forceColor.grey('['), closeBracket: forceColor.grey(']')},
+ mapEntry: {after: forceColor.grey(',')},
+ maxDepth: forceColor.grey('…'),
+ null: ansiStyles.yellow,
+ number: ansiStyles.yellow,
+ object: {
+ openBracket: forceColor.grey('{'),
+ closeBracket: forceColor.grey('}'),
+ ctor: ansiStyles.magenta,
+ stringTag: {open: ansiStyles.magenta.open + '@', close: ansiStyles.magenta.close},
+ secondaryStringTag: {open: ansiStyles.grey.open + '@', close: ansiStyles.grey.close}
+ },
+ property: {
+ after: forceColor.grey(','),
+ keyBracket: {open: forceColor.grey('['), close: forceColor.grey(']')},
+ valueFallback: forceColor.grey('…')
+ },
+ react: {
+ functionType: forceColor.grey('\u235F'),
+ openTag: {
+ start: forceColor.grey('<'),
+ end: forceColor.grey('>'),
+ selfClose: forceColor.grey('/'),
+ selfCloseVoid: ' ' + forceColor.grey('/')
+ },
+ closeTag: {
+ open: forceColor.grey('')
+ },
+ tagName: ansiStyles.magenta,
+ attribute: {
+ separator: '=',
+ value: {
+ openBracket: forceColor.grey('{'),
+ closeBracket: forceColor.grey('}'),
+ string: {
+ line: {open: forceColor.blue('"'), close: forceColor.blue('"'), escapeQuote: '"'}
+ }
+ }
+ },
+ child: {
+ openBracket: forceColor.grey('{'),
+ closeBracket: forceColor.grey('}')
+ }
+ },
+ regexp: {
+ source: {open: ansiStyles.blue.open + '/', close: '/' + ansiStyles.blue.close},
+ flags: ansiStyles.yellow
+ },
+ stats: {separator: forceColor.grey('---')},
+ string: {
+ open: ansiStyles.blue.open,
+ close: ansiStyles.blue.close,
+ line: {open: forceColor.blue('\''), close: forceColor.blue('\'')},
+ multiline: {start: forceColor.blue('`'), end: forceColor.blue('`')},
+ controlPicture: ansiStyles.grey,
+ diff: {
+ insert: {
+ open: ansiStyles.bgGreen.open + ansiStyles.black.open,
+ close: ansiStyles.black.close + ansiStyles.bgGreen.close
+ },
+ delete: {
+ open: ansiStyles.bgRed.open + ansiStyles.black.open,
+ close: ansiStyles.black.close + ansiStyles.bgRed.close
+ },
+ equal: ansiStyles.blue,
+ insertLine: {
+ open: ansiStyles.green.open,
+ close: ansiStyles.green.close
+ },
+ deleteLine: {
+ open: ansiStyles.red.open,
+ close: ansiStyles.red.close
+ }
+ }
+ },
+ symbol: ansiStyles.yellow,
+ typedArray: {
+ bytes: ansiStyles.yellow
+ },
+ undefined: ansiStyles.yellow
+};
+
+const plainTheme = cloneDeepWith(colorTheme, value => {
+ if (typeof value === 'string') {
+ return chalk.stripColor(value);
+ }
+});
+
+const theme = options.color === false ? plainTheme : colorTheme;
+exports.default = {maxDepth: 3, plugins, theme};
+exports.diff = {maxDepth: 1, plugins, theme};
+exports.snapshotManager = {plugins, theme: plainTheme};
diff --git a/lib/enhance-assert.js b/lib/enhance-assert.js
index 7808765b7..6e127b3d6 100644
--- a/lib/enhance-assert.js
+++ b/lib/enhance-assert.js
@@ -1,6 +1,7 @@
'use strict';
+const concordance = require('concordance');
const dotProp = require('dot-prop');
-const formatValue = require('./format-assert-error').formatValue;
+const concordanceOptions = require('./concordance-options').default;
// When adding patterns, don't forget to add to
// https://github.com/avajs/babel-preset-transform-test-files/blob/master/espower-patterns.json
@@ -37,7 +38,10 @@ const formatter = context => {
return args
.map(arg => {
const range = getNode(ast, arg.espath).range;
- return [computeStatement(tokens, range), formatValue(arg.value, {maxDepth: 1})];
+ const statement = computeStatement(tokens, range);
+
+ const formatted = concordance.format(arg.value, concordanceOptions);
+ return [statement, formatted];
})
.reverse();
};
diff --git a/lib/format-assert-error.js b/lib/format-assert-error.js
deleted file mode 100644
index a899af463..000000000
--- a/lib/format-assert-error.js
+++ /dev/null
@@ -1,121 +0,0 @@
-'use strict';
-const prettyFormat = require('@ava/pretty-format');
-const reactTestPlugin = require('@ava/pretty-format/plugins/ReactTestComponent');
-const chalk = require('chalk');
-const diff = require('diff');
-const DiffMatchPatch = require('diff-match-patch');
-const indentString = require('indent-string');
-const globals = require('./globals');
-
-function formatValue(value, options) {
- return prettyFormat(value, Object.assign({
- callToJSON: false,
- plugins: [reactTestPlugin],
- highlight: globals.options.color !== false
- }, options));
-}
-exports.formatValue = formatValue;
-
-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}`;
-};
-
-const getType = value => {
- const type = typeof value;
- if (type === 'object') {
- if (type === null) {
- return 'null';
- }
- if (Array.isArray(value)) {
- return 'array';
- }
- }
- return type;
-};
-
-function formatDiff(actual, expected) {
- const actualType = getType(actual);
- const expectedType = getType(expected);
- if (actualType !== expectedType) {
- return null;
- }
-
- if (actualType === 'array' || actualType === 'object') {
- const formatted = diff.createPatch('string', formatValue(actual), formatValue(expected))
- .split('\n')
- .slice(4)
- .map(cleanUp)
- .filter(Boolean)
- .join('\n')
- .trimRight();
-
- return {label: 'Difference:', formatted};
- }
-
- if (actualType === 'string') {
- const formatted = new DiffMatchPatch()
- .diff_main(formatValue(actual, {highlight: false}), formatValue(expected, {highlight: false}))
- .map(part => {
- if (part[0] === 1) {
- return chalk.bgGreen.black(part[1]);
- }
-
- if (part[0] === -1) {
- return chalk.bgRed.black(part[1]);
- }
-
- return chalk.red(part[1]);
- })
- .join('')
- .trimRight();
-
- return {label: 'Difference:', formatted};
- }
-
- return null;
-}
-exports.formatDiff = formatDiff;
-
-function formatWithLabel(label, value) {
- return {label, formatted: formatValue(value)};
-}
-exports.formatWithLabel = formatWithLabel;
-
-function formatSerializedError(error) {
- if (error.statements.length === 0 && error.values.length === 0) {
- return null;
- }
-
- let result = error.values
- .map(value => `${value.label}\n\n${indentString(value.formatted, 2).trimRight()}\n`)
- .join('\n');
-
- if (error.statements.length > 0) {
- if (error.values.length > 0) {
- result += '\n';
- }
-
- result += error.statements
- .map(statement => `${statement[0]}\n${chalk.grey('=>')} ${statement[1]}\n`)
- .join('\n');
- }
-
- return result;
-}
-exports.formatSerializedError = formatSerializedError;
diff --git a/lib/main.js b/lib/main.js
index 52618e8b7..1b03cc854 100644
--- a/lib/main.js
+++ b/lib/main.js
@@ -11,6 +11,7 @@ const runner = new Runner({
failWithoutAssertions: opts.failWithoutAssertions,
file: opts.file,
match: opts.match,
+ projectDir: opts.projectDir,
serial: opts.serial,
updateSnapshots: opts.updateSnapshots
});
diff --git a/lib/process-adapter.js b/lib/process-adapter.js
index b50f37398..5f9c0d79d 100644
--- a/lib/process-adapter.js
+++ b/lib/process-adapter.js
@@ -94,7 +94,7 @@ exports.installDependencyTracking = (dependencies, testPath) => {
require.extensions[ext] = (module, filename) => {
if (filename !== testPath) {
- dependencies.push(filename);
+ dependencies.add(filename);
}
wrappedHandler(module, filename);
diff --git a/lib/reporters/format-serialized-error.js b/lib/reporters/format-serialized-error.js
new file mode 100644
index 000000000..6ab59e47c
--- /dev/null
+++ b/lib/reporters/format-serialized-error.js
@@ -0,0 +1,26 @@
+'use strict';
+const chalk = require('chalk');
+const trimOffNewlines = require('trim-off-newlines');
+
+function formatSerializedError(error) {
+ const printMessage = error.values.length === 0 ?
+ Boolean(error.message) :
+ !error.values[0].label.startsWith(error.message);
+
+ if (error.statements.length === 0 && error.values.length === 0) {
+ return {formatted: null, printMessage};
+ }
+
+ let formatted = '';
+ for (const value of error.values) {
+ formatted += `${value.label}\n\n${trimOffNewlines(value.formatted)}\n\n`;
+ }
+
+ for (const statement of error.statements) {
+ formatted += `${statement[0]}\n${chalk.grey('=>')} ${trimOffNewlines(statement[1])}\n\n`;
+ }
+
+ formatted = trimOffNewlines(formatted);
+ return {formatted, printMessage};
+}
+module.exports = formatSerializedError;
diff --git a/lib/reporters/improper-usage-messages.js b/lib/reporters/improper-usage-messages.js
index 0a2626638..298ef79a5 100644
--- a/lib/reporters/improper-usage-messages.js
+++ b/lib/reporters/improper-usage-messages.js
@@ -7,15 +7,48 @@ exports.forError = error => {
}
const assertion = error.assertion;
- if (assertion !== 'throws' || !assertion === 'notThrows') {
- return null;
- }
-
- return `Try wrapping the first argument to \`t.${assertion}()\` in a function:
+ if (assertion === 'throws' || assertion === 'notThrows') {
+ return `Try wrapping the first argument to \`t.${assertion}()\` in a function:
${chalk.cyan(`t.${assertion}(() => { `)}${chalk.grey('/* your code here */')}${chalk.cyan(' })')}
Visit the following URL for more details:
${chalk.blue.underline('https://github.com/avajs/ava#throwsfunctionpromise-error-message')}`;
+ } else if (assertion === 'snapshot') {
+ const name = error.improperUsage.name;
+ const snapPath = error.improperUsage.snapPath;
+
+ if (name === 'ChecksumError') {
+ return `The snapshot file is corrupted.
+
+File path: ${chalk.yellow(snapPath)}
+
+Please run AVA again with the ${chalk.cyan('--update-snapshots')} flag to recreate it.`;
+ }
+
+ if (name === 'LegacyError') {
+ return `The snapshot file was created with AVA 0.19. It's not supported by this AVA version.
+
+File path: ${chalk.yellow(snapPath)}
+
+Please run AVA again with the ${chalk.cyan('--update-snapshots')} flag to upgrade.`;
+ }
+
+ if (name === 'VersionMismatchError') {
+ const snapVersion = error.improperUsage.snapVersion;
+ const expectedVersion = error.improperUsage.expectedVersion;
+ const upgradeMessage = snapVersion < expectedVersion ?
+ `Please run AVA again with the ${chalk.cyan('--update-snapshots')} flag to upgrade.` :
+ 'You should upgrade AVA.';
+
+ return `The snapshot file is v${snapVersion}, but only v${expectedVersion} is supported.
+
+File path: ${chalk.yellow(snapPath)}
+
+${upgradeMessage}`;
+ }
+ }
+
+ return null;
};
diff --git a/lib/reporters/mini.js b/lib/reporters/mini.js
index 1f552bdaa..8acfab8e7 100644
--- a/lib/reporters/mini.js
+++ b/lib/reporters/mini.js
@@ -9,10 +9,11 @@ const cliTruncate = require('cli-truncate');
const cross = require('figures').cross;
const indentString = require('indent-string');
const ansiEscapes = require('ansi-escapes');
-const formatAssertError = require('../format-assert-error');
+const trimOffNewlines = require('trim-off-newlines');
const extractStack = require('../extract-stack');
const codeExcerpt = require('../code-excerpt');
const colors = require('../colors');
+const formatSerializedError = require('./format-serialized-error');
const improperUsageMessages = require('./improper-usage-messages');
class MiniReporter {
@@ -131,38 +132,37 @@ class MiniReporter {
time = chalk.gray.dim('[' + new Date().toLocaleTimeString('en-US', {hour12: false}) + ']');
}
- let status = this.reportCounts(time);
+ let status = this.reportCounts(time) + '\n';
if (this.rejectionCount > 0) {
- status += '\n ' + colors.error(this.rejectionCount, plur('rejection', this.rejectionCount));
+ status += ' ' + colors.error(this.rejectionCount, plur('rejection', this.rejectionCount)) + '\n';
}
if (this.exceptionCount > 0) {
- status += '\n ' + colors.error(this.exceptionCount, plur('exception', this.exceptionCount));
+ status += ' ' + colors.error(this.exceptionCount, plur('exception', this.exceptionCount)) + '\n';
}
if (runStatus.previousFailCount > 0) {
- status += '\n ' + colors.error(runStatus.previousFailCount, 'previous', plur('failure', runStatus.previousFailCount), 'in test files that were not rerun');
+ status += ' ' + colors.error(runStatus.previousFailCount, 'previous', plur('failure', runStatus.previousFailCount), 'in test files that were not rerun') + '\n';
}
if (this.knownFailureCount > 0) {
for (const test of runStatus.knownFailures) {
const title = test.title;
- status += '\n\n ' + colors.title(title);
+ status += '\n ' + colors.title(title) + '\n';
// TODO: Output description with link
// status += colors.stack(description);
}
}
+ status += '\n';
if (this.failCount > 0) {
- runStatus.errors.forEach((test, index) => {
+ runStatus.errors.forEach(test => {
if (!test.error) {
return;
}
- const beforeSpacing = index === 0 ? '\n\n' : '\n\n\n\n';
-
- status += beforeSpacing + ' ' + colors.title(test.title) + '\n';
+ status += ' ' + colors.title(test.title) + '\n';
if (test.error.source) {
status += ' ' + colors.errorSource(test.error.source.file + ':' + test.error.source.line) + '\n';
@@ -172,28 +172,32 @@ class MiniReporter {
}
}
- if (test.error.message) {
- status += '\n' + indentString(test.error.message, 2) + '\n';
- }
-
if (test.error.avaAssertionError) {
- const formatted = formatAssertError.formatSerializedError(test.error);
- if (formatted) {
- status += '\n' + indentString(formatted, 2);
+ const result = formatSerializedError(test.error);
+ if (result.printMessage) {
+ status += '\n' + indentString(test.error.message, 2) + '\n';
+ }
+
+ if (result.formatted) {
+ status += '\n' + indentString(result.formatted, 2) + '\n';
}
const message = improperUsageMessages.forError(test.error);
if (message) {
status += '\n' + indentString(message, 2) + '\n';
}
+ } else if (test.error.message) {
+ status += '\n' + indentString(test.error.message, 2) + '\n';
}
if (test.error.stack) {
const extracted = extractStack(test.error.stack);
if (extracted.includes('\n')) {
- status += '\n' + indentString(colors.errorStack(extracted), 2);
+ status += '\n' + indentString(colors.errorStack(extracted), 2) + '\n';
}
}
+
+ status += '\n\n\n';
});
}
@@ -205,7 +209,7 @@ class MiniReporter {
}
if (err.type === 'exception' && err.name === 'AvaError') {
- status += '\n\n ' + colors.error(cross + ' ' + err.message);
+ status += ' ' + colors.error(cross + ' ' + err.message) + '\n\n';
} else {
const title = err.type === 'rejection' ? 'Unhandled Rejection' : 'Uncaught Exception';
let description = err.stack ? err.stack.trimRight() : JSON.stringify(err);
@@ -213,23 +217,23 @@ class MiniReporter {
const errorTitle = err.name ? description[0] : 'Threw non-error: ' + description[0];
const errorStack = description.slice(1).join('\n');
- status += '\n\n ' + colors.title(title) + '\n';
+ status += ' ' + colors.title(title) + '\n';
status += ' ' + colors.stack(errorTitle) + '\n';
- status += colors.errorStack(errorStack);
+ status += colors.errorStack(errorStack) + '\n\n';
}
});
}
if (runStatus.failFastEnabled === true && runStatus.remainingCount > 0 && runStatus.failCount > 0) {
const remaining = 'At least ' + runStatus.remainingCount + ' ' + plur('test was', 'tests were', runStatus.remainingCount) + ' skipped.';
- status += '\n\n ' + colors.information('`--fail-fast` is on. ' + remaining);
+ status += ' ' + colors.information('`--fail-fast` is on. ' + remaining) + '\n\n';
}
if (runStatus.hasExclusive === true && runStatus.remainingCount > 0) {
- status += '\n\n ' + colors.information('The .only() modifier is used in some tests.', runStatus.remainingCount, plur('test', runStatus.remainingCount), plur('was', 'were', runStatus.remainingCount), 'not run');
+ status += ' ' + colors.information('The .only() modifier is used in some tests.', runStatus.remainingCount, plur('test', runStatus.remainingCount), plur('was', 'were', runStatus.remainingCount), 'not run');
}
- return status + '\n\n';
+ return '\n' + trimOffNewlines(status) + '\n';
}
section() {
return '\n' + chalk.gray.dim('\u2500'.repeat(process.stdout.columns || 80));
diff --git a/lib/reporters/verbose.js b/lib/reporters/verbose.js
index 1be43ce5e..cd47683e8 100644
--- a/lib/reporters/verbose.js
+++ b/lib/reporters/verbose.js
@@ -4,10 +4,11 @@ const prettyMs = require('pretty-ms');
const figures = require('figures');
const chalk = require('chalk');
const plur = require('plur');
-const formatAssertError = require('../format-assert-error');
+const trimOffNewlines = require('trim-off-newlines');
const extractStack = require('../extract-stack');
const codeExcerpt = require('../code-excerpt');
const colors = require('../colors');
+const formatSerializedError = require('./format-serialized-error');
const improperUsageMessages = require('./improper-usage-messages');
class VerboseReporter {
@@ -70,7 +71,7 @@ class VerboseReporter {
return output;
}
finish(runStatus) {
- let output = '\n';
+ let output = '';
const lines = [
runStatus.failCount > 0 ?
@@ -86,23 +87,23 @@ class VerboseReporter {
if (lines.length > 0) {
lines[0] += ' ' + chalk.gray.dim('[' + new Date().toLocaleTimeString('en-US', {hour12: false}) + ']');
- output += lines.join('\n');
+ output += lines.join('\n') + '\n';
}
if (runStatus.knownFailureCount > 0) {
runStatus.knownFailures.forEach(test => {
- output += '\n\n\n ' + colors.error(test.title);
+ output += '\n\n ' + colors.error(test.title) + '\n';
});
}
+ output += '\n';
if (runStatus.failCount > 0) {
- runStatus.tests.forEach((test, index) => {
+ runStatus.tests.forEach(test => {
if (!test.error) {
return;
}
- const beforeSpacing = index === 0 ? '\n\n' : '\n\n\n\n';
- output += beforeSpacing + ' ' + colors.title(test.title) + '\n';
+ output += ' ' + colors.title(test.title) + '\n';
if (test.error.source) {
output += ' ' + colors.errorSource(test.error.source.file + ':' + test.error.source.line) + '\n';
@@ -112,41 +113,45 @@ class VerboseReporter {
}
}
- if (test.error.message) {
- output += '\n' + indentString(test.error.message, 2) + '\n';
- }
-
if (test.error.avaAssertionError) {
- const formatted = formatAssertError.formatSerializedError(test.error);
- if (formatted) {
- output += '\n' + indentString(formatted, 2);
+ const result = formatSerializedError(test.error);
+ if (result.printMessage) {
+ output += '\n' + indentString(test.error.message, 2) + '\n';
+ }
+
+ if (result.formatted) {
+ output += '\n' + indentString(result.formatted, 2) + '\n';
}
const message = improperUsageMessages.forError(test.error);
if (message) {
output += '\n' + indentString(message, 2) + '\n';
}
+ } else if (test.error.message) {
+ output += '\n' + indentString(test.error.message, 2) + '\n';
}
if (test.error.stack) {
const extracted = extractStack(test.error.stack);
if (extracted.includes('\n')) {
- output += '\n' + indentString(colors.errorStack(extracted), 2);
+ output += '\n' + indentString(colors.errorStack(extracted), 2) + '\n';
}
}
+
+ output += '\n\n\n';
});
}
if (runStatus.failFastEnabled === true && runStatus.remainingCount > 0 && runStatus.failCount > 0) {
const remaining = 'At least ' + runStatus.remainingCount + ' ' + plur('test was', 'tests were', runStatus.remainingCount) + ' skipped.';
- output += '\n\n\n ' + colors.information('`--fail-fast` is on. ' + remaining);
+ output += ' ' + colors.information('`--fail-fast` is on. ' + remaining) + '\n\n';
}
if (runStatus.hasExclusive === true && runStatus.remainingCount > 0) {
- output += '\n\n\n ' + colors.information('The .only() modifier is used in some tests.', runStatus.remainingCount, plur('test', runStatus.remainingCount), plur('was', 'were', runStatus.remainingCount), 'not run');
+ output += ' ' + colors.information('The .only() modifier is used in some tests.', runStatus.remainingCount, plur('test', runStatus.remainingCount), plur('was', 'were', runStatus.remainingCount), 'not run');
}
- return output + '\n';
+ return '\n' + trimOffNewlines(output) + '\n';
}
section() {
return chalk.gray.dim('\u2500'.repeat(process.stdout.columns || 80));
diff --git a/lib/run-status.js b/lib/run-status.js
index 6526f7bdc..609c79a87 100644
--- a/lib/run-status.js
+++ b/lib/run-status.js
@@ -73,6 +73,7 @@ class RunStatus extends EventEmitter {
}
handleTeardown(data) {
this.emit('dependencies', data.file, data.dependencies, this);
+ this.emit('touchedFiles', data.touchedFiles);
}
handleStats(stats) {
this.emit('stats', stats, this);
diff --git a/lib/runner.js b/lib/runner.js
index 5f0edacb2..bda2132fd 100644
--- a/lib/runner.js
+++ b/lib/runner.js
@@ -2,9 +2,9 @@
const EventEmitter = require('events');
const path = require('path');
const Bluebird = require('bluebird');
-const jestSnapshot = require('jest-snapshot');
const optionChain = require('option-chain');
const matcher = require('matcher');
+const snapshotManager = require('./snapshot-manager');
const TestCollection = require('./test-collection');
const validateTest = require('./validate-test');
@@ -49,16 +49,17 @@ class Runner extends EventEmitter {
this.file = options.file;
this.match = options.match || [];
+ this.projectDir = options.projectDir;
this.serial = options.serial;
this.updateSnapshots = options.updateSnapshots;
this.hasStarted = false;
this.results = [];
- this.snapshotState = null;
+ this.snapshots = null;
this.tests = new TestCollection({
bail: options.bail,
failWithoutAssertions: options.failWithoutAssertions,
- getSnapshotState: () => this.getSnapshotState()
+ compareTestSnapshot: this.compareTestSnapshot.bind(this)
});
this.chain = optionChain(chainableMethods, (opts, args) => {
@@ -179,26 +180,31 @@ class Runner extends EventEmitter {
return stats;
}
- getSnapshotState() {
- if (this.snapshotState) {
- return this.snapshotState;
+ compareTestSnapshot(options) {
+ if (!this.snapshots) {
+ this.snapshots = snapshotManager.load({
+ name: path.basename(this.file),
+ projectDir: this.projectDir,
+ relFile: path.relative(this.projectDir, this.file),
+ testDir: path.dirname(this.file),
+ updating: this.updateSnapshots
+ });
+ this.emit('dependency', this.snapshots.snapPath);
}
- const name = path.basename(this.file) + '.snap';
- const dir = path.dirname(this.file);
-
- const snapshotPath = path.join(dir, '__snapshots__', name);
- const testPath = this.file;
- const update = this.updateSnapshots;
-
- const state = jestSnapshot.initializeSnapshotState(testPath, update, snapshotPath);
- this.snapshotState = state;
- return state;
+ return this.snapshots.compare(options);
}
saveSnapshotState() {
- if (this.snapshotState) {
- this.snapshotState.save(this.updateSnapshots);
+ if (this.snapshots) {
+ const files = this.snapshots.save();
+ if (files) {
+ this.emit('touched', files);
+ }
+ } else if (this.updateSnapshots) {
+ // TODO: There may be unused snapshot files if no test caused the
+ // snapshots to be loaded. Prune them. But not if tests (including hooks!)
+ // were skipped. Perhaps emit a warning if this occurs?
}
}
diff --git a/lib/snapshot-manager.js b/lib/snapshot-manager.js
new file mode 100644
index 000000000..e7a053919
--- /dev/null
+++ b/lib/snapshot-manager.js
@@ -0,0 +1,395 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+
+const writeFileAtomic = require('@ava/write-file-atomic');
+const concordance = require('concordance');
+const indentString = require('indent-string');
+const makeDir = require('make-dir');
+const md5Hex = require('md5-hex');
+
+const concordanceOptions = require('./concordance-options').snapshotManager;
+
+// Increment if encoding layout or Concordance serialization versions change. Previous AVA versions will not be able to
+// decode buffers generated by a newer version, so changing this value will require a major version bump of AVA itself.
+// The version is encoded as an unsigned 16 bit integer.
+const VERSION = 1;
+
+const VERSION_HEADER = Buffer.alloc(2);
+VERSION_HEADER.writeUInt16LE(VERSION);
+
+// The decoder matches on the trailing newline byte (0x0A).
+const READABLE_PREFIX = Buffer.from(`AVA Snapshot v${VERSION}\n`, 'ascii');
+const REPORT_SEPARATOR = Buffer.from('\n\n', 'ascii');
+const REPORT_TRAILING_NEWLINE = Buffer.from('\n', 'ascii');
+
+const MD5_HASH_LENGTH = 16;
+
+class SnapshotError extends Error {
+ constructor(message, snapPath) {
+ super(message);
+ this.name = 'SnapshotError';
+ this.snapPath = snapPath;
+ }
+}
+exports.SnapshotError = SnapshotError;
+
+class ChecksumError extends SnapshotError {
+ constructor(snapPath) {
+ super('Checksum mismatch', snapPath);
+ this.name = 'ChecksumError';
+ }
+}
+exports.ChecksumError = ChecksumError;
+
+class VersionMismatchError extends SnapshotError {
+ constructor(snapPath, version) {
+ super('Unexpected snapshot version', snapPath);
+ this.name = 'VersionMismatchError';
+ this.snapVersion = version;
+ this.expectedVersion = VERSION;
+ }
+}
+exports.VersionMismatchError = VersionMismatchError;
+
+const LEGACY_SNAPSHOT_HEADER = Buffer.from('// Jest Snapshot v1');
+function isLegacySnapshot(buffer) {
+ return LEGACY_SNAPSHOT_HEADER.equals(buffer.slice(0, LEGACY_SNAPSHOT_HEADER.byteLength));
+}
+
+class LegacyError extends SnapshotError {
+ constructor(snapPath) {
+ super('Legacy snapshot file', snapPath);
+ this.name = 'LegacyError';
+ }
+}
+exports.LegacyError = LegacyError;
+
+function tryRead(file) {
+ try {
+ return fs.readFileSync(file);
+ } catch (err) {
+ if (err.code === 'ENOENT') {
+ return null;
+ }
+
+ throw err;
+ }
+}
+
+function withoutLineEndings(buffer) {
+ let newLength = buffer.byteLength - 1;
+ while (buffer[newLength] === 0x0A || buffer[newLength] === 0x0D) {
+ newLength--;
+ }
+ return buffer.slice(0, newLength);
+}
+
+function formatEntry(label, descriptor) {
+ if (label) {
+ label = `> ${label}\n\n`;
+ }
+ const codeBlock = indentString(concordance.formatDescriptor(descriptor, concordanceOptions), 4);
+ return Buffer.from(label + codeBlock, 'utf8');
+}
+
+function combineEntries(entries) {
+ const buffers = [];
+ let byteLength = 0;
+
+ const sortedKeys = Array.from(entries.keys()).sort();
+ for (const key of sortedKeys) {
+ const keyBuffer = Buffer.from(`\n\n## ${key}\n\n`, 'utf8');
+ buffers.push(keyBuffer);
+ byteLength += keyBuffer.byteLength;
+
+ const formattedEntries = entries.get(key);
+ const last = formattedEntries[formattedEntries.length - 1];
+ for (const entry of formattedEntries) {
+ buffers.push(entry);
+ byteLength += entry.byteLength;
+
+ if (entry !== last) {
+ buffers.push(REPORT_SEPARATOR);
+ byteLength += REPORT_SEPARATOR.byteLength;
+ }
+ }
+ }
+
+ return {buffers, byteLength};
+}
+
+function generateReport(relFile, snapFile, entries) {
+ const combined = combineEntries(entries);
+ const buffers = combined.buffers;
+ let byteLength = combined.byteLength;
+
+ const header = Buffer.from(`# Snapshot report for \`${relFile}\`
+
+The actual snapshot is saved in \`${snapFile}\`.
+
+Generated by [AVA](https://ava.li).`, 'utf8');
+ buffers.unshift(header);
+ byteLength += header.byteLength;
+
+ buffers.push(REPORT_TRAILING_NEWLINE);
+ byteLength += REPORT_TRAILING_NEWLINE.byteLength;
+ return Buffer.concat(buffers, byteLength);
+}
+
+function appendReportEntries(existingReport, entries) {
+ const combined = combineEntries(entries);
+ const buffers = combined.buffers;
+ let byteLength = combined.byteLength;
+
+ const prepend = withoutLineEndings(existingReport);
+ buffers.unshift(prepend);
+ byteLength += prepend.byteLength;
+
+ return Buffer.concat(buffers, byteLength);
+}
+
+function encodeSnapshots(buffersByHash) {
+ const buffers = [];
+ let byteOffset = 0;
+
+ // Entry start and end pointers are relative to the header length. This means
+ // it's possible to append new entries to an existing snapshot file, without
+ // having to rewrite pointers for existing entries.
+ const headerLength = Buffer.alloc(4);
+ buffers.push(headerLength);
+ byteOffset += 4;
+
+ // Allows 65535 hashes (tests or identified snapshots) per file.
+ const numHashes = Buffer.alloc(2);
+ numHashes.writeUInt16LE(buffersByHash.size);
+ buffers.push(numHashes);
+ byteOffset += 2;
+
+ const entries = [];
+ for (const pair of buffersByHash) {
+ const hash = pair[0];
+ const snapshotBuffers = pair[1];
+
+ buffers.push(Buffer.from(hash, 'hex'));
+ byteOffset += MD5_HASH_LENGTH;
+
+ // Allows 65535 snapshots per hash.
+ const numSnapshots = Buffer.alloc(2);
+ numSnapshots.writeUInt16LE(snapshotBuffers.length, 0);
+ buffers.push(numSnapshots);
+ byteOffset += 2;
+
+ for (const value of snapshotBuffers) {
+ // Each pointer is 32 bits, restricting the total, uncompressed buffer to
+ // 4 GiB.
+ const start = Buffer.alloc(4);
+ const end = Buffer.alloc(4);
+ entries.push({start, end, value});
+
+ buffers.push(start, end);
+ byteOffset += 8;
+ }
+ }
+
+ headerLength.writeUInt32LE(byteOffset, 0);
+
+ let bodyOffset = 0;
+ for (const entry of entries) {
+ const start = bodyOffset;
+ const end = bodyOffset + entry.value.byteLength;
+ entry.start.writeUInt32LE(start, 0);
+ entry.end.writeUInt32LE(end, 0);
+ buffers.push(entry.value);
+ bodyOffset = end;
+ }
+ byteOffset += bodyOffset;
+
+ const compressed = zlib.gzipSync(Buffer.concat(buffers, byteOffset));
+ const md5sum = crypto.createHash('md5').update(compressed).digest();
+ return Buffer.concat([
+ READABLE_PREFIX,
+ VERSION_HEADER,
+ md5sum,
+ compressed
+ ], READABLE_PREFIX.byteLength + VERSION_HEADER.byteLength + MD5_HASH_LENGTH + compressed.byteLength);
+}
+
+function decodeSnapshots(buffer, snapPath) {
+ if (isLegacySnapshot(buffer)) {
+ throw new LegacyError(snapPath);
+ }
+
+ // The version starts after the readable prefix, which is ended by a newline
+ // byte (0x0A).
+ const versionOffset = buffer.indexOf(0x0A) + 1;
+ const version = buffer.readUInt16LE(versionOffset);
+ if (version !== VERSION) {
+ throw new VersionMismatchError(snapPath, version);
+ }
+
+ const md5sumOffset = versionOffset + 2;
+ const compressedOffset = md5sumOffset + MD5_HASH_LENGTH;
+ const compressed = buffer.slice(compressedOffset);
+
+ const md5sum = crypto.createHash('md5').update(compressed).digest();
+ const expectedSum = buffer.slice(md5sumOffset, compressedOffset);
+ if (!md5sum.equals(expectedSum)) {
+ throw new ChecksumError(snapPath);
+ }
+
+ const decompressed = zlib.gunzipSync(compressed);
+ let byteOffset = 0;
+
+ const headerLength = decompressed.readUInt32LE(byteOffset);
+ byteOffset += 4;
+
+ const snapshotsByHash = new Map();
+ const numHashes = decompressed.readUInt16LE(byteOffset);
+ byteOffset += 2;
+
+ for (let count = 0; count < numHashes; count++) {
+ const hash = decompressed.toString('hex', byteOffset, byteOffset + MD5_HASH_LENGTH);
+ byteOffset += MD5_HASH_LENGTH;
+
+ const numSnapshots = decompressed.readUInt16LE(byteOffset);
+ byteOffset += 2;
+
+ const snapshotsBuffers = new Array(numSnapshots);
+ for (let index = 0; index < numSnapshots; index++) {
+ const start = decompressed.readUInt32LE(byteOffset) + headerLength;
+ byteOffset += 4;
+ const end = decompressed.readUInt32LE(byteOffset) + headerLength;
+ byteOffset += 4;
+ snapshotsBuffers[index] = decompressed.slice(start, end);
+ }
+
+ // Allow for new entries to be appended to an existing header, which could
+ // lead to the same hash being present multiple times.
+ if (snapshotsByHash.has(hash)) {
+ snapshotsByHash.set(hash, snapshotsByHash.get(hash).concat(snapshotsBuffers));
+ } else {
+ snapshotsByHash.set(hash, snapshotsBuffers);
+ }
+ }
+
+ return snapshotsByHash;
+}
+
+class Manager {
+ constructor(options) {
+ this.appendOnly = options.appendOnly;
+ this.dir = options.dir;
+ this.relFile = options.relFile;
+ this.reportFile = options.reportFile;
+ this.snapFile = options.snapFile;
+ this.snapPath = options.snapPath;
+ this.snapshotsByHash = options.snapshotsByHash;
+
+ this.hasChanges = false;
+ this.reportEntries = new Map();
+ }
+
+ compare(options) {
+ const hash = md5Hex(options.belongsTo);
+ const entries = this.snapshotsByHash.get(hash) || [];
+ if (options.index > entries.length) {
+ throw new RangeError(`Cannot record snapshot ${options.index} for ${JSON.stringify(options.belongsTo)}, exceeds expected index of ${entries.length}`);
+ }
+ if (options.index === entries.length) {
+ this.record(hash, options);
+ return {pass: true};
+ }
+
+ const snapshotBuffer = entries[options.index];
+ const actual = concordance.deserialize(snapshotBuffer, concordanceOptions);
+
+ const expected = concordance.describe(options.expected, concordanceOptions);
+ const pass = concordance.compareDescriptors(actual, expected);
+
+ return {actual, expected, pass};
+ }
+
+ record(hash, options) {
+ const descriptor = concordance.describe(options.expected, concordanceOptions);
+
+ this.hasChanges = true;
+ const snapshot = concordance.serialize(descriptor);
+ if (this.snapshotsByHash.has(hash)) {
+ this.snapshotsByHash.get(hash).push(snapshot);
+ } else {
+ this.snapshotsByHash.set(hash, [snapshot]);
+ }
+
+ const entry = formatEntry(options.label, descriptor);
+ if (this.reportEntries.has(options.belongsTo)) {
+ this.reportEntries.get(options.belongsTo).push(entry);
+ } else {
+ this.reportEntries.set(options.belongsTo, [entry]);
+ }
+ }
+
+ save() {
+ if (!this.hasChanges) {
+ return null;
+ }
+
+ const snapPath = this.snapPath;
+ const buffer = encodeSnapshots(this.snapshotsByHash);
+
+ const reportPath = path.join(this.dir, this.reportFile);
+ const existingReport = this.appendOnly ? tryRead(reportPath) : null;
+ const reportBuffer = existingReport ?
+ appendReportEntries(existingReport, this.reportEntries) :
+ generateReport(this.relFile, this.snapFile, this.reportEntries);
+
+ makeDir.sync(this.dir);
+ const tmpSnapPath = writeFileAtomic.sync(snapPath, buffer);
+ const tmpReportPath = writeFileAtomic.sync(reportPath, reportBuffer);
+
+ return [tmpSnapPath, tmpReportPath, snapPath, reportPath];
+ }
+}
+
+function determineSnapshotDir(projectDir, testDir) {
+ const parts = new Set(path.relative(projectDir, testDir).split(path.sep));
+ if (parts.has('__tests__')) {
+ return path.join(testDir, '__snapshots__');
+ } else if (parts.has('test') || parts.has('tests')) { // Accept tests, even though it's not in the default test patterns
+ return path.join(testDir, 'snapshots');
+ }
+ return testDir;
+}
+
+function load(options) {
+ const dir = determineSnapshotDir(options.projectDir, options.testDir);
+ const reportFile = `${options.name}.md`;
+ const snapFile = `${options.name}.snap`;
+ const snapPath = path.join(dir, snapFile);
+
+ let appendOnly = !options.updating;
+ let snapshotsByHash;
+
+ if (!options.updating) {
+ const buffer = tryRead(snapPath);
+ if (buffer) {
+ snapshotsByHash = decodeSnapshots(buffer, snapPath);
+ } else {
+ appendOnly = false;
+ }
+ }
+
+ return new Manager({
+ appendOnly,
+ dir,
+ relFile: options.relFile,
+ reportFile,
+ snapFile,
+ snapPath,
+ snapshotsByHash: snapshotsByHash || new Map()
+ });
+}
+exports.load = load;
diff --git a/lib/test-collection.js b/lib/test-collection.js
index 5404cb119..91c604e06 100644
--- a/lib/test-collection.js
+++ b/lib/test-collection.js
@@ -11,7 +11,7 @@ class TestCollection extends EventEmitter {
this.bail = options.bail;
this.failWithoutAssertions = options.failWithoutAssertions;
- this.getSnapshotState = options.getSnapshotState;
+ this.compareTestSnapshot = options.compareTestSnapshot;
this.hasExclusive = false;
this.testCount = 0;
@@ -133,7 +133,7 @@ class TestCollection extends EventEmitter {
contextRef,
failWithoutAssertions: false,
fn: hook.fn,
- getSnapshotState: this.getSnapshotState,
+ compareTestSnapshot: this.compareTestSnapshot,
metadata: hook.metadata,
onResult: this._emitTestResult,
title
@@ -150,7 +150,7 @@ class TestCollection extends EventEmitter {
contextRef,
failWithoutAssertions: this.failWithoutAssertions,
fn: test.fn,
- getSnapshotState: this.getSnapshotState,
+ compareTestSnapshot: this.compareTestSnapshot,
metadata: test.metadata,
onResult: this._emitTestResult,
title: test.title
diff --git a/lib/test-worker.js b/lib/test-worker.js
index a70aa977a..0061775f0 100644
--- a/lib/test-worker.js
+++ b/lib/test-worker.js
@@ -17,18 +17,18 @@
}
}
-/* eslint-enable import/order */
-const Bluebird = require('bluebird');
-const currentlyUnhandled = require('currently-unhandled')();
-const isObj = require('is-obj');
const adapter = require('./process-adapter');
const globals = require('./globals');
-const serializeError = require('./serialize-error');
const opts = adapter.opts;
-const testPath = opts.file;
globals.options = opts;
+/* eslint-enable import/order */
+const Bluebird = require('bluebird');
+const currentlyUnhandled = require('currently-unhandled')();
+const isObj = require('is-obj');
+const serializeError = require('./serialize-error');
+
// Bluebird specific
Bluebird.longStackTraces();
@@ -37,13 +37,25 @@ Bluebird.longStackTraces();
adapter.installSourceMapSupport();
adapter.installPrecompilerHook();
-const dependencies = [];
+const testPath = opts.file;
+
+const dependencies = new Set();
adapter.installDependencyTracking(dependencies, testPath);
+const touchedFiles = new Set();
+
// Set when main.js is required (since test files should have `require('ava')`).
let runner = null;
exports.setRunner = newRunner => {
runner = newRunner;
+ runner.on('dependency', file => {
+ dependencies.add(file);
+ });
+ runner.on('touched', files => {
+ for (const file of files) {
+ touchedFiles.add(file);
+ }
+ });
};
require(testPath);
@@ -121,8 +133,12 @@ process.on('ava-teardown', () => {
// Include dependencies in the final teardown message. This ensures the full
// set of dependencies is included no matter how the process exits, unless
- // it flat out crashes.
- adapter.send('teardown', {dependencies});
+ // it flat out crashes. Also include any files that AVA touched during the
+ // test run. This allows the watcher to ignore modifications to those files.
+ adapter.send('teardown', {
+ dependencies: Array.from(dependencies),
+ touchedFiles: Array.from(touchedFiles)
+ });
});
process.on('ava-exit', () => {
diff --git a/lib/test.js b/lib/test.js
index a9b0fb1d9..58be54d32 100644
--- a/lib/test.js
+++ b/lib/test.js
@@ -1,13 +1,19 @@
'use strict';
const isGeneratorFn = require('is-generator-fn');
const co = require('co-with-promise');
+const concordance = require('concordance');
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 formatAssertError = require('./format-assert-error');
const globals = require('./globals');
+const concordanceOptions = require('./concordance-options').default;
+
+function formatErrorValue(label, error) {
+ const formatted = concordance.format(error, concordanceOptions);
+ return {label, formatted};
+}
class SkipApi {
constructor(test) {
@@ -26,8 +32,10 @@ const captureStack = start => {
class ExecutionContext {
constructor(test) {
- this._test = test;
- this.skip = new SkipApi(test);
+ Object.defineProperties(this, {
+ _test: {value: test},
+ skip: {value: new SkipApi(test)}
+ });
}
plan(ct) {
@@ -67,7 +75,6 @@ class ExecutionContext {
this._test.trackThrows(null);
}
}
-Object.defineProperty(ExecutionContext.prototype, 'context', {enumerable: true});
{
const assertions = assert.wrapAssertions({
@@ -98,11 +105,19 @@ class Test {
this.contextRef = options.contextRef;
this.failWithoutAssertions = options.failWithoutAssertions;
this.fn = isGeneratorFn(options.fn) ? co.wrap(options.fn) : options.fn;
- this.getSnapshotState = options.getSnapshotState;
this.metadata = options.metadata;
this.onResult = options.onResult;
this.title = options.title;
+ this.snapshotInvocationCount = 0;
+ this.compareWithSnapshot = assertionOptions => {
+ const belongsTo = assertionOptions.id || this.title;
+ const expected = assertionOptions.expected;
+ const index = assertionOptions.id ? 0 : this.snapshotInvocationCount++;
+ const label = assertionOptions.id ? '' : assertionOptions.message || `Snapshot ${this.snapshotInvocationCount}`;
+ return options.compareTestSnapshot({belongsTo, expected, index, label});
+ };
+
this.assertCount = 0;
this.assertError = undefined;
this.calledEnd = false;
@@ -139,7 +154,7 @@ class Test {
actual: err,
message: 'Callback called with an error',
stack,
- values: [formatAssertError.formatWithLabel('Error:', err)]
+ values: [formatErrorValue('Callback called with an error:', err)]
}));
}
@@ -234,7 +249,7 @@ class Test {
const values = [];
if (err) {
- values.push(formatAssertError.formatWithLabel(`The following error was thrown, possibly before \`t.${pending.assertion}()\` could be called:`, err));
+ values.push(formatErrorValue(`The following error was thrown, possibly before \`t.${pending.assertion}()\` could be called:`, err));
}
this.saveFirstError(new assert.AssertionError({
@@ -297,7 +312,7 @@ class Test {
this.saveFirstError(new assert.AssertionError({
message: 'Error thrown in test',
stack: result.error instanceof Error && result.error.stack,
- values: [formatAssertError.formatWithLabel('Error:', result.error)]
+ values: [formatErrorValue('Error thrown in test:', result.error)]
}));
}
return this.finish();
@@ -361,7 +376,7 @@ class Test {
this.saveFirstError(new assert.AssertionError({
message: 'Rejected promise returned by test',
stack: err instanceof Error && err.stack,
- values: [formatAssertError.formatWithLabel('Rejection reason:', err)]
+ values: [formatErrorValue('Rejected promise returned by test. Reason:', err)]
}));
}
})
diff --git a/lib/watcher.js b/lib/watcher.js
index 3d7094ffb..d07a155a8 100644
--- a/lib/watcher.js
+++ b/lib/watcher.js
@@ -16,18 +16,23 @@ function rethrowAsync(err) {
});
}
+const MIN_DEBOUNCE_DELAY = 10;
+const INITIAL_DEBOUNCE_DELAY = 100;
+
class Debouncer {
constructor(watcher) {
this.watcher = watcher;
this.timer = null;
this.repeat = false;
}
- debounce() {
+ debounce(delay) {
if (this.timer) {
this.again = true;
return;
}
+ delay = delay ? Math.max(delay, MIN_DEBOUNCE_DELAY) : INITIAL_DEBOUNCE_DELAY;
+
const timer = setTimeout(() => {
this.watcher.busy.then(() => {
// Do nothing if debouncing was canceled while waiting for the busy
@@ -39,14 +44,14 @@ class Debouncer {
if (this.again) {
this.timer = null;
this.again = false;
- this.debounce();
+ this.debounce(delay / 2);
} else {
this.watcher.runAfterChanges();
this.timer = null;
this.again = false;
}
});
- }, 10);
+ }, delay);
this.timer = timer;
}
@@ -111,6 +116,7 @@ class Watcher {
}
}
+ this.touchedFiles.clear();
this.busy = api.run(specificFiles || files, {runOnlyExclusive})
.then(runStatus => {
runStatus.previousFailCount = this.sumPreviousFailures(currentVector);
@@ -125,6 +131,9 @@ class Watcher {
this.testDependencies = [];
this.trackTestDependencies(api, sources);
+ this.touchedFiles = new Set();
+ this.trackTouchedFiles(api);
+
this.filesWithExclusiveTests = [];
this.trackExclusivity(api);
@@ -179,6 +188,15 @@ class Watcher {
this.testDependencies.push(new TestDependency(file, sources));
}
}
+ trackTouchedFiles(api) {
+ api.on('test-run', runStatus => {
+ runStatus.on('touchedFiles', files => {
+ for (const file of files) {
+ this.touchedFiles.add(nodePath.relative(process.cwd(), file));
+ }
+ });
+ });
+ }
trackExclusivity(api) {
api.on('stats', stats => {
this.updateExclusivity(stats.file, stats.hasExclusive);
@@ -279,7 +297,14 @@ class Watcher {
const dirtyStates = this.dirtyStates;
this.dirtyStates = {};
- const dirtyPaths = Object.keys(dirtyStates);
+ const dirtyPaths = Object.keys(dirtyStates).filter(path => {
+ if (this.touchedFiles.has(path)) {
+ debug('Ignoring known touched file %s', path);
+ this.touchedFiles.delete(path);
+ return false;
+ }
+ return true;
+ });
const dirtyTests = dirtyPaths.filter(this.avaFiles.isTest);
const dirtySources = diff(dirtyPaths, dirtyTests);
const addedOrChangedTests = dirtyTests.filter(path => dirtyStates[path] !== 'unlink');
@@ -309,7 +334,8 @@ class Watcher {
// Rerun all tests if source files were changed that could not be traced to
// specific tests
if (testsBySource.length !== dirtySources.length) {
- debug('Sources remain that cannot be traced to specific tests. Rerunning all tests');
+ debug('Sources remain that cannot be traced to specific tests: %O', dirtySources);
+ debug('Rerunning all tests');
this.run();
return;
}
diff --git a/media/snapshot-testing.png b/media/snapshot-testing.png
index adea50054..4776e0bb3 100644
Binary files a/media/snapshot-testing.png and b/media/snapshot-testing.png differ
diff --git a/package-lock.json b/package-lock.json
index 833e6a094..11c4272a2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -30,10 +30,15 @@
"resolved": "https://registry.npmjs.org/@ava/babel-preset-transform-test-files/-/babel-preset-transform-test-files-3.0.0.tgz",
"integrity": "sha1-ze0RlqjY2TgaUJJAq5LpGl7Aafc="
},
- "@ava/pretty-format": {
- "version": "1.1.0",
- "resolved": "https://registry.npmjs.org/@ava/pretty-format/-/pretty-format-1.1.0.tgz",
- "integrity": "sha1-0KV9Jeua6rlkO90aAwZCuRwSPig="
+ "@ava/write-file-atomic": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/@ava/write-file-atomic/-/write-file-atomic-2.2.0.tgz",
+ "integrity": "sha512-BTNB3nGbEfJT+69wuqXFr/bQH7Vr7ihx2xGOMNqPgDGhwspoZhiWumDDZNjBy7AScmqS5CELIOGtPVXESyrnDA=="
+ },
+ "@concordance/react": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/@concordance/react/-/react-1.0.0.tgz",
+ "integrity": "sha512-htrsRaQX8Iixlsek8zQU7tE8wcsTQJ5UhZkSPEA8slCDAisKpC/2VgU/ucPn32M5/LjGGXRaUEKvEw1Wiuu4zQ=="
},
"abbrev": {
"version": "1.1.0",
@@ -89,9 +94,9 @@
"integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8="
},
"ansi-styles": {
- "version": "2.2.1",
- "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz",
- "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4="
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.1.0.tgz",
+ "integrity": "sha1-CcIC1ckX7CMYjKpcnLkXnNlUd1A="
},
"anymatch": {
"version": "1.3.0",
@@ -153,6 +158,12 @@
"resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz",
"integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0="
},
+ "asap": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.5.tgz",
+ "integrity": "sha1-UidltQw1EEkOUtfc/ghe+bqWlY8=",
+ "dev": true
+ },
"asn1": {
"version": "0.2.3",
"resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.3.tgz",
@@ -687,6 +698,11 @@
"integrity": "sha1-CqxmL9Ur54lk1VMvaUeE5wEQrPc=",
"dev": true
},
+ "concordance": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/concordance/-/concordance-2.0.0.tgz",
+ "integrity": "sha512-jVxBZbAkFIZE5WHCAL7RpkX+XPl9ZnT8uYjZ9EXPFSquNDgq2iXWFsT2iptVoxvfSL+/5ej8CdHsmE7XYJjCPA=="
+ },
"configstore": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/configstore/-/configstore-3.1.0.tgz",
@@ -754,6 +770,12 @@
"resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz",
"integrity": "sha1-Br56vvlHo/FKMP1hBnHUAbyot7Y="
},
+ "create-react-class": {
+ "version": "15.6.0",
+ "resolved": "https://registry.npmjs.org/create-react-class/-/create-react-class-15.6.0.tgz",
+ "integrity": "sha1-q0SEl8JlZuHilBPogyB9V8/nvtQ=",
+ "dev": true
+ },
"cross-spawn": {
"version": "4.0.2",
"resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-4.0.2.tgz",
@@ -886,12 +908,8 @@
"diff": {
"version": "3.2.0",
"resolved": "https://registry.npmjs.org/diff/-/diff-3.2.0.tgz",
- "integrity": "sha1-yc45Okt8vQsFinJck98pkCeGj/k="
- },
- "diff-match-patch": {
- "version": "1.0.0",
- "resolved": "https://registry.npmjs.org/diff-match-patch/-/diff-match-patch-1.0.0.tgz",
- "integrity": "sha1-HMPIOkkNZ/ldkeOfatHy4Ia2MEg="
+ "integrity": "sha1-yc45Okt8vQsFinJck98pkCeGj/k=",
+ "dev": true
},
"doctrine": {
"version": "2.0.0",
@@ -920,6 +938,12 @@
"resolved": "https://registry.npmjs.org/empower-core/-/empower-core-0.6.2.tgz",
"integrity": "sha1-Wt71ZgiOMfuoC6CjbfR9cJQWkUQ="
},
+ "encoding": {
+ "version": "0.1.12",
+ "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.12.tgz",
+ "integrity": "sha1-U4tm8+5izRq1HsMjgp0flIDHS+s=",
+ "dev": true
+ },
"enhance-visitors": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/enhance-visitors/-/enhance-visitors-1.0.0.tgz",
@@ -1248,12 +1272,31 @@
"resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.0.2.tgz",
"integrity": "sha1-4QgOBljjALBilJkMxw4VAiNf1VA="
},
+ "fast-diff": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.1.1.tgz",
+ "integrity": "sha1-CuoOTmBbaiGJ8Ok21Lf7rxt8/Zs="
+ },
"fast-levenshtein": {
"version": "2.0.6",
"resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
"integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=",
"dev": true
},
+ "fbjs": {
+ "version": "0.8.12",
+ "resolved": "https://registry.npmjs.org/fbjs/-/fbjs-0.8.12.tgz",
+ "integrity": "sha1-ELXZL3bUVXX9Y6IX1OoCvqL47QQ=",
+ "dev": true,
+ "dependencies": {
+ "core-js": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/core-js/-/core-js-1.2.7.tgz",
+ "integrity": "sha1-ZSKUwUZR2yj6k70tX/KYOk8IxjY=",
+ "dev": true
+ }
+ }
+ },
"figures": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz",
@@ -1938,6 +1981,11 @@
"integrity": "sha1-gHa7MF6OajzO7ikgdl8zDRkPNAw=",
"dev": true
},
+ "function-name-support": {
+ "version": "0.2.0",
+ "resolved": "https://registry.npmjs.org/function-name-support/-/function-name-support-0.2.0.tgz",
+ "integrity": "sha1-VdO/qm6v1QWlD5vIH99XVkoLsHE="
+ },
"generate-function": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/generate-function/-/generate-function-2.0.0.tgz",
@@ -2419,57 +2467,28 @@
"resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz",
"integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk="
},
+ "isomorphic-fetch": {
+ "version": "2.2.1",
+ "resolved": "https://registry.npmjs.org/isomorphic-fetch/-/isomorphic-fetch-2.2.1.tgz",
+ "integrity": "sha1-YRrhrPFPXoH3KVB0coGf6XM1WKk=",
+ "dev": true
+ },
"isstream": {
"version": "0.1.2",
"resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz",
"integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo="
},
- "jest-diff": {
- "version": "19.0.0",
- "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-19.0.0.tgz",
- "integrity": "sha1-0VY8/FbItgIymI+8BdTRbtkPBjw="
- },
- "jest-file-exists": {
- "version": "19.0.0",
- "resolved": "https://registry.npmjs.org/jest-file-exists/-/jest-file-exists-19.0.0.tgz",
- "integrity": "sha1-zKLlh6EeyS4kz+qz+KlNZX8/zrg="
- },
- "jest-matcher-utils": {
- "version": "19.0.0",
- "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-19.0.0.tgz",
- "integrity": "sha1-Xs2bY1ZdKwAfYfv37Ex/U3lkVk0="
- },
- "jest-message-util": {
- "version": "19.0.0",
- "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-19.0.0.tgz",
- "integrity": "sha1-cheWuJwOTXYWBvm6jLgoo7YkZBY="
- },
- "jest-mock": {
- "version": "19.0.0",
- "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-19.0.0.tgz",
- "integrity": "sha1-ZwOGQelgerLOCOxKjLg6q7yJnQE="
- },
- "jest-snapshot": {
- "version": "19.0.2",
- "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-19.0.2.tgz",
- "integrity": "sha1-nBshYhT3GHw4v9XHCx76sWsP9Qs="
- },
- "jest-util": {
- "version": "19.0.2",
- "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-19.0.2.tgz",
- "integrity": "sha1-4KAjKiq55rK1Nmi9s1NMK1l37UE="
- },
- "jest-validate": {
- "version": "19.0.2",
- "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-19.0.2.tgz",
- "integrity": "sha1-3FNN9fEnjVtj3zKxQkHU2/ckTAw="
- },
"jodid25519": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/jodid25519/-/jodid25519-1.0.2.tgz",
"integrity": "sha1-BtSRIlUJNBlHfUJWM2BuDpB4KWc=",
"optional": true
},
+ "js-string-escape": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/js-string-escape/-/js-string-escape-1.0.1.tgz",
+ "integrity": "sha1-4mJbrbwNZ8dTPp7cEGjFh65BN+8="
+ },
"js-tokens": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.1.tgz",
@@ -2573,11 +2592,6 @@
"integrity": "sha1-GwuP+ayceIklBYK3C3ExXZ2m2aM=",
"dev": true
},
- "leven": {
- "version": "2.1.0",
- "resolved": "https://registry.npmjs.org/leven/-/leven-2.1.0.tgz",
- "integrity": "sha1-wuep93IJTe6dNCAq6KzORoeHVYA="
- },
"levn": {
"version": "0.3.0",
"resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz",
@@ -2826,6 +2840,11 @@
"integrity": "sha1-z4tP9PKWQGdNbN0CsOO8UjwrvcA=",
"dev": true
},
+ "moment": {
+ "version": "2.18.1",
+ "resolved": "https://registry.npmjs.org/moment/-/moment-2.18.1.tgz",
+ "integrity": "sha1-w2GT3Tzhwu7SrbfIAtu8d6gbHA8="
+ },
"ms": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/ms/-/ms-1.0.0.tgz",
@@ -2857,7 +2876,14 @@
"natural-compare": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
- "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc="
+ "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=",
+ "dev": true
+ },
+ "node-fetch": {
+ "version": "1.7.1",
+ "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-1.7.1.tgz",
+ "integrity": "sha512-j8XsFGCLw79vWXkZtMSmmLaOk9z5SQ9bV/tkbZVCqvgwzrjAGq66igobLofHtF63NvMTp2WjytpsNTGKa+XRIQ==",
+ "dev": true
},
"nopt": {
"version": "1.0.10",
@@ -4085,18 +4111,6 @@
"resolved": "https://registry.npmjs.org/preserve/-/preserve-0.2.0.tgz",
"integrity": "sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks="
},
- "pretty-format": {
- "version": "19.0.0",
- "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-19.0.0.tgz",
- "integrity": "sha1-VlMNMqy5ij+khRxOK503tCBoTIQ=",
- "dependencies": {
- "ansi-styles": {
- "version": "3.0.0",
- "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.0.0.tgz",
- "integrity": "sha1-VATpOlRMT+x/BIJil3vr/jFV4ME="
- }
- }
- },
"pretty-ms": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/pretty-ms/-/pretty-ms-2.1.0.tgz",
@@ -4125,6 +4139,18 @@
"integrity": "sha1-4mDHj2Fhzdmw5WzD4Khd4Xx6V74=",
"dev": true
},
+ "promise": {
+ "version": "7.3.0",
+ "resolved": "https://registry.npmjs.org/promise/-/promise-7.3.0.tgz",
+ "integrity": "sha512-bzAZ0u9Kxa0FYyfISjr9/PK7sCclAzc5rP4UgynMWA2Qv/gpZLKynJmTEXYq2i/giYdjBfRONDhfbsMlGIgvjA==",
+ "dev": true
+ },
+ "prop-types": {
+ "version": "15.5.10",
+ "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.5.10.tgz",
+ "integrity": "sha1-J5ffwxJhguOpXj37suiT3ddFYVQ=",
+ "dev": true
+ },
"proto-props": {
"version": "0.2.1",
"resolved": "https://registry.npmjs.org/proto-props/-/proto-props-0.2.1.tgz",
@@ -4169,6 +4195,18 @@
}
}
},
+ "react": {
+ "version": "15.6.1",
+ "resolved": "https://registry.npmjs.org/react/-/react-15.6.1.tgz",
+ "integrity": "sha1-uqhDTsZ4C96ZfNw4C3nNM7ljk98=",
+ "dev": true
+ },
+ "react-test-renderer": {
+ "version": "15.6.1",
+ "resolved": "https://registry.npmjs.org/react-test-renderer/-/react-test-renderer-15.6.1.tgz",
+ "integrity": "sha1-Am9KW7VVJmH9LMS7zQ1LyKNev34=",
+ "dev": true
+ },
"read-pkg": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-2.0.0.tgz",
@@ -4393,6 +4431,12 @@
"resolved": "https://registry.npmjs.org/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz",
"integrity": "sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E="
},
+ "setimmediate": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz",
+ "integrity": "sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=",
+ "dev": true
+ },
"shebang-command": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz",
@@ -5807,6 +5851,11 @@
"resolved": "https://registry.npmjs.org/trim-newlines/-/trim-newlines-1.0.0.tgz",
"integrity": "sha1-WIeWa7WCpFA6QetST301ARgVphM="
},
+ "trim-off-newlines": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/trim-off-newlines/-/trim-off-newlines-1.0.1.tgz",
+ "integrity": "sha1-n5up2e+odkw4dpi8v+sshI8RrbM="
+ },
"trim-right": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/trim-right/-/trim-right-1.0.1.tgz",
@@ -5859,6 +5908,12 @@
"integrity": "sha1-PTgyGCgjHkNPKHUUlZw3qCtin0I=",
"dev": true
},
+ "ua-parser-js": {
+ "version": "0.7.12",
+ "resolved": "https://registry.npmjs.org/ua-parser-js/-/ua-parser-js-0.7.12.tgz",
+ "integrity": "sha1-BMgamb3V3FImPqKdJMa/jUgYpLs=",
+ "dev": true
+ },
"uid2": {
"version": "0.0.3",
"resolved": "https://registry.npmjs.org/uid2/-/uid2-0.0.3.tgz",
@@ -5926,6 +5981,17 @@
"resolved": "https://registry.npmjs.org/verror/-/verror-1.3.6.tgz",
"integrity": "sha1-z/XfEpRtKX0rqu+qJoniW+AcAFw="
},
+ "well-known-symbols": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/well-known-symbols/-/well-known-symbols-1.0.0.tgz",
+ "integrity": "sha1-c8eK6Bp3Jqj6WY4ogIAcixYiVRg="
+ },
+ "whatwg-fetch": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/whatwg-fetch/-/whatwg-fetch-2.0.3.tgz",
+ "integrity": "sha1-nITsLc9oGH/wC8ZOEnS0QhduHIQ=",
+ "dev": true
+ },
"which": {
"version": "1.2.14",
"resolved": "https://registry.npmjs.org/which/-/which-1.2.14.tgz",
@@ -5966,9 +6032,9 @@
"dev": true
},
"write-file-atomic": {
- "version": "2.1.0",
- "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-2.1.0.tgz",
- "integrity": "sha512-0TZ20a+xcIl4u0+Mj5xDH2yOWdmQiXlKf9Hm+TgDXjTMsEYb+gDrmb8e8UNAzMCitX8NBqG4Z/FUQIyzv/R1JQ=="
+ "version": "1.3.4",
+ "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-1.3.4.tgz",
+ "integrity": "sha1-+Aek8LHZ6ROuekgRLmzDrxmRtF8="
},
"write-json-file": {
"version": "2.2.0",
diff --git a/package.json b/package.json
index 6b6783adc..7e39c3e16 100644
--- a/package.json
+++ b/package.json
@@ -95,8 +95,10 @@
"dependencies": {
"@ava/babel-preset-stage-4": "^1.1.0",
"@ava/babel-preset-transform-test-files": "^3.0.0",
- "@ava/pretty-format": "^1.1.0",
+ "@ava/write-file-atomic": "^2.2.0",
+ "@concordance/react": "^1.0.0",
"ansi-escapes": "^2.0.0",
+ "ansi-styles": "^3.1.0",
"arr-flatten": "^1.0.1",
"array-union": "^1.0.1",
"array-uniq": "^1.0.2",
@@ -116,12 +118,11 @@
"co-with-promise": "^4.6.0",
"code-excerpt": "^2.1.0",
"common-path-prefix": "^1.0.0",
+ "concordance": "^2.0.0",
"convert-source-map": "^1.2.0",
"core-assert": "^0.2.0",
"currently-unhandled": "^0.4.1",
"debug": "^2.2.0",
- "diff": "^3.0.1",
- "diff-match-patch": "^1.0.0",
"dot-prop": "^4.1.0",
"empower-core": "^0.6.1",
"equal-length": "^1.0.0",
@@ -140,14 +141,12 @@
"is-obj": "^1.0.0",
"is-observable": "^0.2.0",
"is-promise": "^2.1.0",
- "jest-diff": "19.0.0",
- "jest-snapshot": "19.0.2",
"js-yaml": "^3.8.2",
"last-line-stream": "^1.0.0",
+ "lodash.clonedeepwith": "^4.5.0",
"lodash.debounce": "^4.0.3",
"lodash.difference": "^4.3.0",
"lodash.flatten": "^4.2.0",
- "lodash.isequal": "^4.5.0",
"loud-rejection": "^1.2.0",
"make-dir": "^1.0.0",
"matcher": "^0.1.1",
@@ -170,6 +169,7 @@
"strip-bom-buf": "^1.0.0",
"supports-color": "^3.2.3",
"time-require": "^0.1.2",
+ "trim-off-newlines": "^1.0.1",
"unique-temp-dir": "^1.0.0",
"update-notifier": "^2.1.0"
},
@@ -188,6 +188,8 @@
"lolex": "^1.4.0",
"nyc": "^10.0.0",
"proxyquire": "^1.7.4",
+ "react": "^15.6.1",
+ "react-test-renderer": "^15.6.1",
"signal-exit": "^3.0.0",
"sinon": "^2.0.0",
"source-map-fixtures": "^2.1.0",
diff --git a/readme.md b/readme.md
index 2e03aa007..06b6fc0f2 100644
--- a/readme.md
+++ b/readme.md
@@ -867,7 +867,7 @@ Should contain the actual test.
Type: `object`
-The execution object of a particular test. Each test implementation receives a different object. Contains the [assertions](#assertions) as well as `.plan(count)` and `.end()` methods. `t.context` can contain shared state from `beforeEach` hooks.
+The execution object of a particular test. Each test implementation receives a different object. Contains the [assertions](#assertions) as well as `.plan(count)` and `.end()` methods. `t.context` can contain shared state from `beforeEach` hooks. `t.title` returns the test's title.
###### `t.plan(count)`
@@ -923,11 +923,7 @@ Assert that `value` is not the same as `expected`. This is based on [`Object.is(
### `.deepEqual(value, expected, [message])`
-Assert that `value` is deeply equal to `expected`. This is based on [Lodash's `isEqual()`](https://lodash.com/docs/4.17.4#isEqual):
-
-> Performs a deep comparison between two values to determine if they are equivalent.
->
-> *Note*: This method supports comparing arrays, array buffers, booleans, date objects, error objects, maps, numbers, `Object` objects, regexes, sets, strings, symbols, and typed arrays. `Object` objects are compared by their own, not inherited, enumerable properties. Functions and DOM nodes are compared by strict equality, i.e. `===`.
+Assert that `value` is deeply equal to `expected`. See [Concordance](https://github.com/concordancejs/concordance) for details. Works with [React elements and `react-test-renderer`](https://github.com/concordancejs/react).
### `.notDeepEqual(value, expected, [message])`
@@ -998,15 +994,14 @@ Assert that `contents` does not match `regex`.
Assert that `error` is falsy.
-### `.snapshot(contents, [message])`
+### `.snapshot(expected, [message])`
+### `.snapshot(expected, [options], [message])`
-Make a snapshot of the stringified `contents`.
+Compares the `expected` value with a previously recorded snapshot. Snapshots are stored for each test, so ensure you give your tests unique titles. Alternatively pass an `options` object to select a specific snapshot, for instance `{id: 'my snapshot'}`.
## Snapshot testing
-Snapshot testing comes as another kind of assertion and uses [jest-snapshot](https://facebook.github.io/jest/blog/2016/07/27/jest-14.html) under the hood.
-
-When used with React, it looks very similar to Jest:
+AVA supports snapshot testing, [as introduced by Jest](https://facebook.github.io/jest/docs/snapshot-testing.html), through its [Assertions](#assertions) interface. You can snapshot any value as well as React elements:
```js
// Your component
@@ -1028,32 +1023,25 @@ test('HelloWorld component', t => {
});
```
-The first time you run this test, a snapshot file will be created in `__snapshots__` folder looking something like this:
+Snapshots are stored alongside your test files. If your tests are in a `test` or `tests` folder the snapshots will be stored in a `snapshots` folder. If your tests are in a `__tests__` folder then they they'll be stored in a `__snapshots__` folder.
-```js
-exports[`HelloWorld component 1`] = `
-
- Hello World...!
-
-`;
-```
+Say you have `~/project/test/main.js` which contains snapshot assertions. AVA will create two files:
-These snapshots should be committed together with your code so that everyone on the team shares current state of the app.
+* `~/project/test/snapshots/main.js.snap`
+* `~/project/test/snapshots/main.js.md`
-Every time you run this test afterwards, it will check if the component render has changed. If it did, it will fail the test.
+The first file contains the actual snapshot and is required for future comparisons. The second file contains your *snapshot report*. It's regenerated when you update your snapshots. If you commit it to source control you can diff it to see the changes to your snapshot.
-
+AVA will show why your snapshot assertion failed:
-Then you will have the choice to check your code - and if the change was intentional, you can use the `--update-snapshots` (or `-u`) flag to update the snapshots into their new version.
+
-That might look like this:
+You can then check your code. If the change was intentional you can use the `--update-snapshots` (or `-u`) flag to update the snapshots:
```console
$ ava --update-snapshots
```
-Note that snapshots can be used for much more than just testing components - you can equally well test any other (data) structure that you can stringify.
-
### Skipping assertions
Any assertion can be skipped using the `skip` modifier. Skipped assertions are still counted, so there is no need to change your planned assertion count.
diff --git a/test/assert.js b/test/assert.js
index 67d8bb7bd..8902ca82b 100644
--- a/test/assert.js
+++ b/test/assert.js
@@ -1,9 +1,15 @@
'use strict';
+require('../lib/globals').options.color = false;
+
const path = require('path');
-const jestSnapshot = require('jest-snapshot');
+const stripAnsi = require('strip-ansi');
+const React = require('react');
+const renderer = require('react-test-renderer');
const test = require('tap').test;
const assert = require('../lib/assert');
-const formatValue = require('../lib/format-assert-error').formatValue;
+const snapshotManager = require('../lib/snapshot-manager');
+const Test = require('../lib/test');
+const HelloMessage = require('./fixture/HelloMessage');
let lastFailure = null;
let lastPassed = false;
@@ -46,7 +52,7 @@ function assertFailure(t, subset) {
t.is(lastFailure.values.length, subset.values.length);
lastFailure.values.forEach((s, i) => {
t.is(s.label, subset.values[i].label);
- t.match(s.formatted, subset.values[i].formatted);
+ t.match(stripAnsi(s.formatted), subset.values[i].formatted);
});
} else {
t.same(lastFailure.values, []);
@@ -230,7 +236,7 @@ test('.is()', t => {
assertion: 'is',
message: '',
values: [
- {label: 'Difference:', formatted: /foobar/}
+ {label: 'Difference:', formatted: /- 'foo'\n\+ 'bar'/}
]
});
@@ -240,8 +246,7 @@ test('.is()', t => {
assertion: 'is',
message: '',
values: [
- {label: 'Actual:', formatted: /foo/},
- {label: 'Must be the same as:', formatted: /42/}
+ {label: 'Difference:', formatted: /- 'foo'\n\+ 42/}
]
});
@@ -251,8 +256,7 @@ test('.is()', t => {
assertion: 'is',
message: 'my message',
values: [
- {label: 'Actual:', formatted: /foo/},
- {label: 'Must be the same as:', formatted: /42/}
+ {label: 'Difference:', formatted: /- 'foo'\n\+ 42/}
]
});
@@ -262,8 +266,7 @@ test('.is()', t => {
assertion: 'is',
message: 'my message',
values: [
- {label: 'Actual:', formatted: /0/},
- {label: 'Must be the same as:', formatted: /-0/}
+ {label: 'Difference:', formatted: /- 0\n\+ -0/}
]
});
@@ -273,8 +276,7 @@ test('.is()', t => {
assertion: 'is',
message: 'my message',
values: [
- {label: 'Actual:', formatted: /-0/},
- {label: 'Must be the same as:', formatted: /0/}
+ {label: 'Difference:', formatted: /- -0\n\+ 0/}
]
});
@@ -505,6 +507,12 @@ test('.deepEqual()', t => {
);
});
+ passes(t, () => {
+ assertions.deepEqual(
+ renderer.create(React.createElement(HelloMessage, {name: 'Sindre'})).toJSON(),
+ React.createElement('div', null, 'Hello ', React.createElement('mark', null, 'Sindre')));
+ });
+
// Regression test end here
passes(t, () => {
@@ -538,7 +546,7 @@ test('.deepEqual()', t => {
}, {
assertion: 'deepEqual',
message: '',
- values: [{label: 'Difference:', formatted: /foobar/}]
+ values: [{label: 'Difference:', formatted: /- 'foo'\n\+ 'bar'/}]
});
failsWith(t, () => {
@@ -546,10 +554,7 @@ test('.deepEqual()', t => {
}, {
assertion: 'deepEqual',
message: '',
- values: [
- {label: 'Actual:', formatted: /foo/},
- {label: 'Must be deeply equal to:', formatted: /42/}
- ]
+ values: [{label: 'Difference:', formatted: /- 'foo'\n\+ 42/}]
});
failsWith(t, () => {
@@ -557,10 +562,7 @@ test('.deepEqual()', t => {
}, {
assertion: 'deepEqual',
message: 'my message',
- values: [
- {label: 'Actual:', formatted: /foo/},
- {label: 'Must be deeply equal to:', formatted: /42/}
- ]
+ values: [{label: 'Difference:', formatted: /- 'foo'\n\+ 42/}]
});
t.end();
@@ -580,7 +582,7 @@ test('.notDeepEqual()', t => {
}, {
assertion: 'notDeepEqual',
message: '',
- values: [{label: 'Value is deeply equal:', formatted: formatValue({a: 'a'})}]
+ values: [{label: 'Value is deeply equal:', formatted: /.*\{.*\n.*a: 'a'/}]
});
failsWith(t, () => {
@@ -588,7 +590,7 @@ test('.notDeepEqual()', t => {
}, {
assertion: 'notDeepEqual',
message: 'my message',
- values: [{label: 'Value is deeply equal:', formatted: formatValue(['a', 'b'])}]
+ values: [{label: 'Value is deeply equal:', formatted: /.*\[.*\n.*'a',\n.*'b',/}]
});
t.end();
@@ -667,7 +669,7 @@ test('promise .throws() fails when promise is resolved', t => {
return eventuallyFailsWith(t, assertions.throws(Promise.resolve('foo')), {
assertion: 'throws',
message: 'Expected promise to be rejected, but it was resolved instead',
- values: [{label: 'Resolved with:', formatted: formatValue('foo')}]
+ values: [{label: 'Resolved with:', formatted: /'foo'/}]
});
});
@@ -734,45 +736,116 @@ test('.snapshot()', t => {
// "$(npm bin)"/tap --no-cov -R spec test/assert.js
//
// Ignore errors and make sure not to run tests with the `-b` (bail) option.
- const update = false;
-
- const state = jestSnapshot.initializeSnapshotState(__filename, update, path.join(__dirname, 'fixture', 'assert.snap'));
- const executionContext = {
- _test: {
- getSnapshotState() {
- return state;
- }
- },
- title: ''
+ const updating = false;
+
+ const projectDir = path.join(__dirname, 'fixture');
+ const manager = snapshotManager.load({
+ projectDir,
+ testDir: projectDir,
+ name: 'assert.js',
+ relFile: 'test/assert.js',
+ updating
+ });
+ const setup = title => {
+ const fauxTest = new Test({
+ title,
+ compareTestSnapshot: options => manager.compare(options)
+ });
+ const executionContext = {
+ _test: fauxTest
+ };
+ return executionContext;
};
passes(t, () => {
- executionContext.title = 'passes';
+ const executionContext = setup('passes');
assertions.snapshot.call(executionContext, {foo: 'bar'});
- });
+ assertions.snapshot.call(executionContext, {foo: 'bar'}, {id: 'fixed id'}, 'message not included in snapshot report');
+ assertions.snapshot.call(executionContext, React.createElement(HelloMessage, {name: 'Sindre'}));
+ assertions.snapshot.call(executionContext, renderer.create(React.createElement(HelloMessage, {name: 'Sindre'})).toJSON());
+ });
+
+ {
+ const executionContext = setup('fails');
+ if (updating) {
+ assertions.snapshot.call(executionContext, {foo: 'bar'});
+ } else {
+ failsWith(t, () => {
+ assertions.snapshot.call(executionContext, {foo: 'not bar'});
+ }, {
+ assertion: 'snapshot',
+ message: 'Did not match snapshot',
+ values: [{label: 'Difference:', formatted: ' {\n- foo: \'not bar\',\n+ foo: \'bar\',\n }'}]
+ });
+ }
+ }
failsWith(t, () => {
- executionContext.title = 'fails';
- assertions.snapshot.call(executionContext, {foo: update ? 'bar' : 'not bar'});
+ const executionContext = setup('fails (fixed id)');
+ assertions.snapshot.call(executionContext, {foo: 'not bar'}, {id: 'fixed id'}, 'different message, also not included in snapshot report');
}, {
assertion: 'snapshot',
- message: 'Did not match snapshot',
- values: [{label: 'Difference:', formatted: 'Object {\n- "foo": "bar",\n+ "foo": "not bar",\n }'}]
- });
+ message: 'different message, also not included in snapshot report',
+ values: [{label: 'Difference:', formatted: ' {\n- foo: \'not bar\',\n+ foo: \'bar\',\n }'}]
+ });
+
+ {
+ const executionContext = setup('fails');
+ if (updating) {
+ assertions.snapshot.call(executionContext, {foo: 'bar'}, 'my message');
+ } else {
+ failsWith(t, () => {
+ assertions.snapshot.call(executionContext, {foo: 'not bar'}, 'my message');
+ }, {
+ assertion: 'snapshot',
+ message: 'my message',
+ values: [{label: 'Difference:', formatted: ' {\n- foo: \'not bar\',\n+ foo: \'bar\',\n }'}]
+ });
+ }
+ }
- failsWith(t, () => {
- executionContext.title = 'fails';
- assertions.snapshot.call(executionContext, {foo: update ? 'bar' : 'not bar'}, 'my message');
- }, {
- assertion: 'snapshot',
- message: 'my message',
- values: [{label: 'Difference:', formatted: 'Object {\n- "foo": "bar",\n+ "foo": "not bar",\n }'}]
- });
+ {
+ const executionContext = setup('rendered comparison');
+ if (updating) {
+ assertions.snapshot.call(executionContext, renderer.create(React.createElement(HelloMessage, {name: 'Sindre'})).toJSON());
+ } else {
+ passes(t, () => {
+ assertions.snapshot.call(executionContext, React.createElement('div', null, 'Hello ', React.createElement('mark', null, 'Sindre')));
+ });
+ }
+ }
- if (update) {
- state.save(true);
+ {
+ const executionContext = setup('rendered comparison');
+ if (updating) {
+ assertions.snapshot.call(executionContext, renderer.create(React.createElement(HelloMessage, {name: 'Sindre'})).toJSON());
+ } else {
+ failsWith(t, () => {
+ assertions.snapshot.call(executionContext, renderer.create(React.createElement(HelloMessage, {name: 'Vadim'})).toJSON());
+ }, {
+ assertion: 'snapshot',
+ message: 'Did not match snapshot',
+ values: [{label: 'Difference:', formatted: ' \n Hello \n \n- Vadim\n+ Sindre\n \n
'}]
+ });
+ }
+ }
+
+ {
+ const executionContext = setup('element comparison');
+ if (updating) {
+ assertions.snapshot.call(executionContext, React.createElement(HelloMessage, {name: 'Sindre'}));
+ } else {
+ failsWith(t, () => {
+ assertions.snapshot.call(executionContext, React.createElement(HelloMessage, {name: 'Vadim'}));
+ }, {
+ assertion: 'snapshot',
+ message: 'Did not match snapshot',
+ values: [{label: 'Difference:', formatted: ' '}]
+ });
+ }
}
+ manager.save();
t.end();
});
@@ -954,7 +1027,7 @@ test('.regex() fails if passed a bad value', t => {
}, {
assertion: 'regex',
message: '`t.regex()` must be called with a regular expression',
- values: [{label: 'Called with:', formatted: /Object/}]
+ values: [{label: 'Called with:', formatted: /\{\}/}]
});
t.end();
@@ -1004,7 +1077,7 @@ test('.notRegex() fails if passed a bad value', t => {
}, {
assertion: 'notRegex',
message: '`t.notRegex()` must be called with a regular expression',
- values: [{label: 'Called with:', formatted: /Object/}]
+ values: [{label: 'Called with:', formatted: /\{\}/}]
});
t.end();
diff --git a/test/cli.js b/test/cli.js
index f762ba455..165cb4c29 100644
--- a/test/cli.js
+++ b/test/cli.js
@@ -307,6 +307,60 @@ test('watcher reruns test files when source dependencies change', t => {
});
});
+test('watcher does not rerun test files when they write snapshot files', t => {
+ let killed = false;
+
+ const child = execCli(['--verbose', '--watch', '--update-snapshots', 'test.js'], {dirname: 'fixture/snapshots'}, err => {
+ t.ok(killed);
+ t.ifError(err);
+ t.end();
+ });
+
+ let buffer = '';
+ let passedFirst = false;
+ child.stderr.on('data', str => {
+ buffer += str;
+ if (/2 tests passed/.test(buffer) && !passedFirst) {
+ buffer = '';
+ passedFirst = true;
+ setTimeout(() => {
+ child.kill();
+ killed = true;
+ }, 500);
+ } else if (passedFirst && !killed) {
+ t.is(buffer.replace(/\s/g, ''), '');
+ }
+ });
+});
+
+test('watcher reruns test files when snapshot dependencies change', t => {
+ let killed = false;
+
+ const child = execCli(['--verbose', '--watch', '--update-snapshots', 'test.js'], {dirname: 'fixture/snapshots'}, err => {
+ t.ok(killed);
+ t.ifError(err);
+ t.end();
+ });
+
+ let buffer = '';
+ let passedFirst = false;
+ child.stderr.on('data', str => {
+ buffer += str;
+ if (/2 tests passed/.test(buffer)) {
+ buffer = '';
+ if (passedFirst) {
+ child.kill();
+ killed = true;
+ } else {
+ passedFirst = true;
+ setTimeout(() => {
+ touch.sync(path.join(__dirname, 'fixture/snapshots/test.js.snap'));
+ }, 500);
+ }
+ }
+ });
+});
+
test('`"tap": true` config is ignored when --watch is given', t => {
let killed = false;
@@ -502,25 +556,127 @@ test('promise tests fail if event loop empties before they\'re resolved', t => {
});
});
-test('snapshots work', t => {
- try {
- fs.unlinkSync(path.join(__dirname, 'fixture', 'snapshots', '__snapshots__', 'test.snap'));
- } catch (err) {
- if (err.code !== 'ENOENT') {
- throw err;
+for (const obj of [
+ {type: 'colocated', rel: '', dir: ''},
+ {type: '__tests__', rel: '__tests__-dir', dir: '__tests__/__snapshots__'},
+ {type: 'test', rel: 'test-dir', dir: 'test/snapshots'},
+ {type: 'tests', rel: 'tests-dir', dir: 'tests/snapshots'}
+]) {
+ test(`snapshots work (${obj.type})`, t => {
+ const snapPath = path.join(__dirname, 'fixture', 'snapshots', obj.rel, obj.dir, 'test.js.snap');
+ try {
+ fs.unlinkSync(snapPath);
+ } catch (err) {
+ if (err.code !== 'ENOENT') {
+ throw err;
+ }
}
- }
- // Test should pass, and a snapshot gets written
- execCli(['--update-snapshots', 'test.js'], {dirname: 'fixture/snapshots'}, err => {
- t.ifError(err);
-
- // Test should pass, and the snapshot gets used
- execCli(['test.js'], {dirname: 'fixture/snapshots'}, err => {
+ const dirname = path.join('fixture/snapshots', obj.rel);
+ // Test should pass, and a snapshot gets written
+ execCli(['--update-snapshots'], {dirname}, err => {
t.ifError(err);
- t.end();
+ t.true(fs.existsSync(snapPath));
+
+ // Test should pass, and the snapshot gets used
+ execCli([], {dirname}, err => {
+ t.ifError(err);
+ t.end();
+ });
});
});
+}
+
+test('appends to existing snapshots', t => {
+ const cliPath = require.resolve('../cli.js');
+ const avaPath = require.resolve('../');
+
+ const cwd = uniqueTempDir({create: true});
+ fs.writeFileSync(path.join(cwd, 'package.json'), '{}');
+
+ const initial = `import test from ${JSON.stringify(avaPath)}
+test('one', t => {
+ t.snapshot({one: true})
+})`;
+ fs.writeFileSync(path.join(cwd, 'test.js'), initial);
+
+ const run = () => execa(process.execPath, [cliPath, '--verbose', '--no-color'], {cwd, reject: false});
+ return run().then(result => {
+ t.match(result.stderr, /1 test passed/);
+
+ fs.writeFileSync(path.join(cwd, 'test.js'), `${initial}
+test('two', t => {
+ t.snapshot({two: true})
+})`);
+ return run();
+ }).then(result => {
+ t.match(result.stderr, /2 tests passed/);
+
+ fs.writeFileSync(path.join(cwd, 'test.js'), `${initial}
+test('two', t => {
+ t.snapshot({two: false})
+})`);
+
+ return run();
+ }).then(result => {
+ t.match(result.stderr, /1 test failed/);
+ });
+});
+
+test('outdated snapshot version is reported to the console', t => {
+ const snapPath = path.join(__dirname, 'fixture', 'snapshots', 'test.js.snap');
+ fs.writeFileSync(snapPath, Buffer.from([0x0A, 0x00, 0x00]));
+
+ execCli(['test.js'], {dirname: 'fixture/snapshots'}, (err, stdout, stderr) => {
+ t.ok(err);
+ t.match(stderr, /The snapshot file is v0, but only v1 is supported\./);
+ t.match(stderr, /File path:/);
+ t.match(stderr, snapPath);
+ t.match(stderr, /Please run AVA again with the .*--update-snapshots.* flag to upgrade\./);
+ t.end();
+ });
+});
+
+test('newer snapshot version is reported to the console', t => {
+ const snapPath = path.join(__dirname, 'fixture', 'snapshots', 'test.js.snap');
+ fs.writeFileSync(snapPath, Buffer.from([0x0A, 0xFF, 0xFF]));
+
+ execCli(['test.js'], {dirname: 'fixture/snapshots'}, (err, stdout, stderr) => {
+ t.ok(err);
+ t.match(stderr, /The snapshot file is v65535, but only v1 is supported\./);
+ t.match(stderr, /File path:/);
+ t.match(stderr, snapPath);
+ t.match(stderr, /You should upgrade AVA\./);
+ t.end();
+ });
+});
+
+test('snapshot corruption is reported to the console', t => {
+ const snapPath = path.join(__dirname, 'fixture', 'snapshots', 'test.js.snap');
+ fs.writeFileSync(snapPath, Buffer.from([0x0A, 0x01, 0x00]));
+
+ execCli(['test.js'], {dirname: 'fixture/snapshots'}, (err, stdout, stderr) => {
+ t.ok(err);
+ t.match(stderr, /The snapshot file is corrupted\./);
+ t.match(stderr, /File path:/);
+ t.match(stderr, snapPath);
+ t.match(stderr, /Please run AVA again with the .*--update-snapshots.* flag to recreate it\./);
+ t.end();
+ });
+});
+
+test('legacy snapshot files are reported to the console', t => {
+ const snapPath = path.join(__dirname, 'fixture', 'snapshots', 'test.js.snap');
+ fs.writeFileSync(snapPath, Buffer.from('// Jest Snapshot v1, https://goo.gl/fbAQLP\n'));
+
+ execCli(['test.js'], {dirname: 'fixture/snapshots'}, (err, stdout, stderr) => {
+ t.ok(err);
+ t.match(stderr, /The snapshot file was created with AVA 0\.19\. It's not supported by this AVA version\./);
+ t.match(stderr, /File path:/);
+ t.match(stderr, snapPath);
+ t.match(stderr, /Please run AVA again with the .*--update-snapshots.* flag to upgrade\./);
+ t.end();
+ });
});
test('--no-color disables formatting colors', t => {
diff --git a/test/fixture/HelloMessage.js b/test/fixture/HelloMessage.js
new file mode 100644
index 000000000..58ffbe34a
--- /dev/null
+++ b/test/fixture/HelloMessage.js
@@ -0,0 +1,25 @@
+'use strict';
+
+const React = require('react');
+
+class NameHighlight extends React.Component {
+ render() {
+ return React.createElement(
+ 'mark',
+ null,
+ this.props.name
+ );
+ }
+}
+
+class HelloMessage extends React.Component {
+ render() {
+ return React.createElement(
+ 'div',
+ null,
+ 'Hello ',
+ React.createElement(NameHighlight, {name: this.props.name})
+ );
+ }
+}
+module.exports = HelloMessage;
diff --git a/test/fixture/assert.js.md b/test/fixture/assert.js.md
new file mode 100644
index 000000000..effe453d7
--- /dev/null
+++ b/test/fixture/assert.js.md
@@ -0,0 +1,61 @@
+# Snapshot report for `test/assert.js`
+
+The actual snapshot is saved in `assert.js.snap`.
+
+Generated by [AVA](https://ava.li).
+
+## element comparison
+
+> Snapshot 1
+
+
+
+## fails
+
+> Snapshot 1
+
+ {
+ foo: 'bar',
+ }
+
+## fixed id
+
+ {
+ foo: 'bar',
+ }
+
+## passes
+
+> Snapshot 1
+
+ {
+ foo: 'bar',
+ }
+
+> Snapshot 2
+
+
+
+> Snapshot 3
+
+
+ Hello
+
+ Sindre
+
+
+
+## rendered comparison
+
+> Snapshot 1
+
+
+ Hello
+
+ Sindre
+
+
diff --git a/test/fixture/assert.js.snap b/test/fixture/assert.js.snap
new file mode 100644
index 000000000..a3f69553d
Binary files /dev/null and b/test/fixture/assert.js.snap differ
diff --git a/test/fixture/assert.snap b/test/fixture/assert.snap
deleted file mode 100644
index 5420a5126..000000000
--- a/test/fixture/assert.snap
+++ /dev/null
@@ -1,19 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`fails 1`] = `
-Object {
- "foo": "bar",
-}
-`;
-
-exports[`fails 2`] = `
-Object {
- "foo": "bar",
-}
-`;
-
-exports[`passes 1`] = `
-Object {
- "foo": "bar",
-}
-`;
diff --git a/test/fixture/formatting.js b/test/fixture/formatting.js
new file mode 100644
index 000000000..910d92902
--- /dev/null
+++ b/test/fixture/formatting.js
@@ -0,0 +1,334 @@
+import React from 'react';
+import renderer from 'react-test-renderer';
+import HelloMessage from './HelloMessage'
+import test from '../../';
+
+// Older AVA versions that do not use Concordance don't handle globals very
+// well. Use this so formatting output can be contrasted between versions.
+const formatGlobals = !!require(process.env.AVA_PATH + '/package.json').dependencies.concordance
+
+test('date formatted', t => {
+ const date = new Date('1969-07-20T20:17:40.000Z');
+ t.true(date);
+});
+test('invalid date formatted', t => {
+ const date = new Date('🙀');
+ t.true(date);
+});
+test('date formatted, subclass', t => {
+ class Foo extends Date {}
+ const date = new Foo('1969-07-20T20:17:40.000Z');
+ t.true(date);
+});
+test('date diff', t => {
+ t.deepEqual(new Date('1969-07-20T20:17:40.000Z'), new Date());
+});
+test('date diff, extra properties', t => {
+ t.deepEqual(new Date('1969-07-20T20:17:40.000Z'), Object.assign(new Date('1969-07-20T20:17:40.000Z'), {
+ foo: 'bar'
+ }));
+});
+
+test('error formatted', t => {
+ const err = new Error('Houston, we have a problem');
+ t.true(err);
+});
+test('error formatted, constructor does not match name', t => {
+ const err = Object.assign(new Error('Houston, we have a problem'), {name: 'FamousWords'});
+ t.true(err);
+});
+test('error formatted, constructor does not match name, and string tag does not match constructor', t => {
+ class Custom extends Error {
+ constructor(message) {
+ super(message);
+ this.name = 'FamousWords';
+ }
+ }
+ const err = new Custom('Houston, we have a problem');
+ t.true(err);
+});
+test('error formatted, no name or constructor', t => {
+ class Custom extends Error {
+ constructor(message) {
+ super(message);
+ this.name = '';
+ }
+ }
+ const err = new Custom('Houston, we have a problem');
+ Object.defineProperty(err, 'constructor', {});
+ t.true(err);
+});
+test('error diff, message', t => {
+ t.deepEqual(new Error('Houston, we have a problem'), new Error('One small step'));
+});
+test('error diff, constructor', t => {
+ t.deepEqual(new Error('Houston, we have a problem'), new RangeError('One small step'));
+});
+test('error diff, extra properties', t => {
+ t.deepEqual(new Error('Houston, we have a problem'), Object.assign(new Error('Houston, we have a problem'), {
+ date: new Date('1969-07-20T20:17:40.000Z')
+ }));
+});
+test('error thrown in test', t => {
+ throw Object.assign(new Error('Houston, we have a problem'), {
+ date: new Date('1969-07-20T20:17:40.000Z')
+ });
+});
+test.cb('callback test ended with error', t => {
+ t.end(Object.assign(new Error('Houston, we have a problem'), {
+ date: new Date('1969-07-20T20:17:40.000Z')
+ }));
+});
+test('error thrown in test due to improper throws', t => {
+ const improper = () => {
+ throw Object.assign(new Error('Houston, we have a problem'), {
+ date: new Date('1969-07-20T20:17:40.000Z')
+ });
+ };
+ t.throws(improper());
+});
+test('test returned rejected promise', t => {
+ return Promise.reject(Object.assign(new Error('Houston, we have a problem'), {
+ date: new Date('1969-07-20T20:17:40.000Z')
+ }));
+});
+
+test('array of strings formatted', t => {
+ const arr = ['foo'];
+ t.true(arr);
+});
+test('array of strings diff', t => {
+ t.deepEqual(['foo'], ['bar']);
+});
+
+test('string formatted', t => {
+ t.true('foo');
+});
+test('string diff', t => {
+ t.is('foo', 'bar');
+});
+test('string diff, with overlap', t => {
+ t.is('foobar', 'bar');
+});
+test('multiline string diff, with overlap at start', t => {
+ t.is('foo\nbar', 'foo\nbaz');
+});
+test('multiline string diff, with overlap at end', t => {
+ t.is('bar\nbaz', 'foo\nbaz');
+});
+
+test('map formatted', t => {
+ const map = new Map([['foo', 'bar']]);
+ t.true(map);
+});
+test('map diff', t => {
+ t.deepEqual(new Map([['foo', 'bar']]), new Map([['baz', 'qux']]));
+});
+test('map diff, extra properties', t => {
+ t.deepEqual(new Map([['foo', 'bar']]), Object.assign(new Map([['foo', 'bar']]), {baz: 'qux'}));
+});
+
+test('function formatted', t => {
+ const fn = function foo() {};
+ t.true(fn);
+});
+test('function diff', t => {
+ function foo() {}
+ function bar() {}
+ t.deepEqual(foo, bar);
+});
+test('function diff, extra properties', t => {
+ function foo() {}
+ function bar() {}
+ t.deepEqual(foo, Object.assign(bar, {baz: 'qux'}));
+});
+test('anonymous function', t => {
+ t.true(() => {});
+});
+test('generator function', t => {
+ t.true(function * foo() {});
+});
+
+test('arguments formatted', t => {
+ const args = (function () {
+ return arguments;
+ })('foo');
+ t.true(args);
+});
+test('arguments diff', t => {
+ const foo = (function () {
+ return arguments;
+ })('foo');
+ const bar = (function () {
+ return arguments;
+ })('bar');
+ t.deepEqual(foo, bar);
+});
+test('arguments diff with normal array', t => {
+ const foo = (function () {
+ return arguments;
+ })('foo');
+ t.deepEqual(foo, ['bar']);
+});
+
+if (formatGlobals) {
+ test('global formatted', t => {
+ t.true(global);
+ });
+ test('global diff', t => {
+ t.deepEqual(global, {});
+ });
+}
+
+test('object formatted', t => {
+ const obj = {
+ foo: 'bar'
+ };
+ t.true(obj);
+});
+test('object diff', t => {
+ t.deepEqual({
+ foo: 'bar'
+ }, {
+ baz: 'qux'
+ });
+});
+test('object formatted, custom class', t => {
+ class Foo {}
+ const obj = new Foo();
+ t.true(obj);
+});
+test('object formatted, no constructor', t => {
+ class Foo {}
+ const obj = new Foo();
+ Object.defineProperty(obj, 'constructor', {});
+ t.true(obj);
+});
+test('object formatted, non-Object string tag that does not match constructor', t => {
+ class Foo extends Array {}
+ const obj = new Foo();
+ t.true(obj);
+});
+
+test('promise formatted', t => {
+ const promise = Promise.resolve();
+ t.true(promise);
+});
+test('promise diff', t => {
+ t.deepEqual(Promise.resolve(), Promise.resolve());
+});
+test('promise diff, extra properties', t => {
+ t.deepEqual(Promise.resolve(), Object.assign(Promise.resolve(), {foo: 'bar'}));
+});
+
+test('regexp formatted', t => {
+ const regexp = /foo/gi;
+ t.true(regexp);
+});
+test('regexp diff', t => {
+ t.deepEqual(/foo/gi, /bar/gi);
+});
+test('regexp diff, extra properties', t => {
+ t.deepEqual(/foo/gi, Object.assign(/foo/gi, {baz: 'qux'}));
+});
+
+test('set formatted', t => {
+ const set = new Set([{foo: 'bar'}]);
+ t.true(set);
+});
+test('set diff, string values', t => {
+ t.deepEqual(new Set(['foo']), new Set(['bar']));
+});
+test('set diff, object values', t => {
+ t.deepEqual(new Set([{foo: 'bar'}]), new Set([{bar: 'baz'}]));
+});
+test('set diff, distinct values', t => {
+ t.deepEqual(new Set([{foo: 'bar'}]), new Set([null]));
+});
+test('set diff, extra properties', t => {
+ t.deepEqual(new Set([{foo: 'bar'}]), Object.assign(new Set([{foo: 'bar'}]), {baz: 'qux'}));
+});
+
+test('buffer formatted', t => {
+ const buffer = Buffer.from('decafba'.repeat(12), 'hex');
+ t.true(buffer);
+});
+test('buffer diff', t => {
+ t.deepEqual(Buffer.from('decafba'.repeat(12), 'hex'), Buffer.from('baddecaf', 'hex'));
+});
+test('buffer diff, extra properties', t => {
+ t.deepEqual(Buffer.from('decafba'.repeat(12), 'hex'), Object.assign(Buffer.from('decafba'.repeat(12), 'hex'), {foo: 'bar'}));
+});
+
+test('primitives', t => {
+ const primitives = [
+ true,
+ false,
+ null,
+ 0,
+ -0,
+ 42,
+ Infinity,
+ -Infinity,
+ NaN,
+ 'foo',
+ 'foo\nbar',
+ Symbol.iterator,
+ Symbol.for('foo'),
+ Symbol('bar'),
+ undefined
+ ];
+ t.true(primitives);
+});
+
+test('circular references', t => {
+ const obj = {};
+ obj.circular = obj;
+ t.true(obj);
+});
+
+test('react element, formatted', t => {
+ const element = React.createElement(HelloMessage, {name: 'Sindre'})
+ t.true(element)
+})
+test('react element, complex attributes, formatted', t => {
+ const element = React.createElement('div', {
+ multiline: 'Hello\nworld',
+ object: {foo: ['bar']}
+ })
+ t.true(element)
+})
+test('react element, opaque children, formatted', t => {
+ const element = React.createElement('Foo', null, new Set(['foo']), true)
+ t.true(element)
+})
+test('react element, diff', t => {
+ const element = React.createElement(HelloMessage, {name: 'Sindre'})
+ const other = React.createElement(HelloMessage, {name: 'Vadim'})
+ t.deepEqual(element, other)
+})
+
+test('deep structure, formatted', t => {
+ const deep = {
+ foo: {
+ bar: {
+ baz: {
+ qux: 'quux'
+ }
+ }
+ }
+ }
+ t.true(deep)
+})
+test('deep structure, diff', t => {
+ const deep = {
+ foo: {
+ bar: {
+ baz: {
+ qux: 'quux'
+ }
+ }
+ }
+ }
+ t.deepEqual(deep, Object.assign({corge: 'grault'}, deep))
+})
diff --git a/test/fixture/snapshots/.gitignore b/test/fixture/snapshots/.gitignore
index b05c2dfa7..c8bddd146 100644
--- a/test/fixture/snapshots/.gitignore
+++ b/test/fixture/snapshots/.gitignore
@@ -1 +1,4 @@
+*.snap
+*.md
+snapshots
__snapshots__
diff --git a/test/fixture/snapshots/__tests__-dir/__tests__/test.js b/test/fixture/snapshots/__tests__-dir/__tests__/test.js
new file mode 100644
index 000000000..b1ba91e85
--- /dev/null
+++ b/test/fixture/snapshots/__tests__-dir/__tests__/test.js
@@ -0,0 +1,11 @@
+import test from '../../../../..';
+
+test('test title', t => {
+ t.snapshot({foo: 'bar'});
+
+ t.snapshot({answer: 42});
+});
+
+test('another test', t => {
+ t.snapshot(new Map());
+});
diff --git a/test/fixture/snapshots/__tests__-dir/package.json b/test/fixture/snapshots/__tests__-dir/package.json
new file mode 100644
index 000000000..0967ef424
--- /dev/null
+++ b/test/fixture/snapshots/__tests__-dir/package.json
@@ -0,0 +1 @@
+{}
diff --git a/test/fixture/snapshots/package.json b/test/fixture/snapshots/package.json
new file mode 100644
index 000000000..0967ef424
--- /dev/null
+++ b/test/fixture/snapshots/package.json
@@ -0,0 +1 @@
+{}
diff --git a/test/fixture/snapshots/test-dir/package.json b/test/fixture/snapshots/test-dir/package.json
new file mode 100644
index 000000000..0967ef424
--- /dev/null
+++ b/test/fixture/snapshots/test-dir/package.json
@@ -0,0 +1 @@
+{}
diff --git a/test/fixture/snapshots/test-dir/test/test.js b/test/fixture/snapshots/test-dir/test/test.js
new file mode 100644
index 000000000..b1ba91e85
--- /dev/null
+++ b/test/fixture/snapshots/test-dir/test/test.js
@@ -0,0 +1,11 @@
+import test from '../../../../..';
+
+test('test title', t => {
+ t.snapshot({foo: 'bar'});
+
+ t.snapshot({answer: 42});
+});
+
+test('another test', t => {
+ t.snapshot(new Map());
+});
diff --git a/test/fixture/snapshots/test.js b/test/fixture/snapshots/test.js
index 70e1b67db..f72258b0f 100644
--- a/test/fixture/snapshots/test.js
+++ b/test/fixture/snapshots/test.js
@@ -1,5 +1,11 @@
import test from '../../..';
-test('snapshot', t => {
+test('test title', t => {
t.snapshot({foo: 'bar'});
+
+ t.snapshot({answer: 42});
+});
+
+test('another test', t => {
+ t.snapshot(new Map());
});
diff --git a/test/fixture/snapshots/tests-dir/package.json b/test/fixture/snapshots/tests-dir/package.json
new file mode 100644
index 000000000..07510b0f5
--- /dev/null
+++ b/test/fixture/snapshots/tests-dir/package.json
@@ -0,0 +1,5 @@
+{
+ "ava": {
+ "files": "tests"
+ }
+}
diff --git a/test/fixture/snapshots/tests-dir/tests/test.js b/test/fixture/snapshots/tests-dir/tests/test.js
new file mode 100644
index 000000000..b1ba91e85
--- /dev/null
+++ b/test/fixture/snapshots/tests-dir/tests/test.js
@@ -0,0 +1,11 @@
+import test from '../../../../..';
+
+test('test title', t => {
+ t.snapshot({foo: 'bar'});
+
+ t.snapshot({answer: 42});
+});
+
+test('another test', t => {
+ t.snapshot(new Map());
+});
diff --git a/test/format-assert-error.js b/test/format-assert-error.js
deleted file mode 100644
index e860ba4ce..000000000
--- a/test/format-assert-error.js
+++ /dev/null
@@ -1,155 +0,0 @@
-'use strict';
-const indentString = require('indent-string');
-const chalk = require('chalk');
-const test = require('tap').test;
-const format = require('../lib/format-assert-error');
-
-chalk.enabled = true;
-
-test('diff objects', t => {
- const actual = format.formatValue({a: 1}).split('\n');
- const expected = format.formatValue({a: 2}).split('\n');
-
- t.same(format.formatDiff({a: 1}, {a: 2}), {
- label: 'Difference:',
- formatted: [
- ' ' + actual[0],
- `${chalk.red('-')} ${actual[1]}`,
- `${chalk.green('+')} ${expected[1]}`,
- ' ' + actual[2]
- ].join('\n')
- });
- t.end();
-});
-
-test('diff arrays', t => {
- const actual = format.formatValue([1]).split('\n');
- const expected = format.formatValue([2]).split('\n');
-
- t.same(format.formatDiff([1], [2]), {
- label: 'Difference:',
- formatted: [
- ' ' + actual[0],
- `${chalk.red('-')} ${actual[1]}`,
- `${chalk.green('+')} ${expected[1]}`,
- ' ' + actual[2]
- ].join('\n')
- });
- t.end();
-});
-
-test('diff strings', t => {
- t.same(format.formatDiff('abc', 'abd'), {
- label: 'Difference:',
- formatted: `${chalk.red('"ab')}${chalk.bgRed.black('c')}${chalk.bgGreen.black('d')}${chalk.red('"')}`
- });
- t.end();
-});
-
-test('does not diff different types', t => {
- t.is(format.formatDiff([], {}), null);
- t.end();
-});
-
-test('formats with a given label', t => {
- t.same(format.formatWithLabel('foo', {foo: 'bar'}), {
- label: 'foo',
- formatted: format.formatValue({foo: 'bar'})
- });
- t.end();
-});
-
-test('print multiple values', t => {
- const err = {
- statements: [],
- values: [
- {
- label: 'Actual:',
- formatted: format.formatValue([1, 2, 3])
- },
- {
- label: 'Expected:',
- formatted: format.formatValue({a: 1, b: 2, c: 3})
- }
- ]
- };
-
- t.is(format.formatSerializedError(err), [
- 'Actual:\n',
- `${indentString(err.values[0].formatted, 2)}\n`,
- 'Expected:\n',
- `${indentString(err.values[1].formatted, 2)}\n`
- ].join('\n'));
- t.end();
-});
-
-test('print single value', t => {
- const err = {
- statements: [],
- values: [
- {
- label: 'Actual:',
- formatted: format.formatValue([1, 2, 3])
- }
- ]
- };
-
- t.is(format.formatSerializedError(err), [
- 'Actual:\n',
- `${indentString(err.values[0].formatted, 2)}\n`
- ].join('\n'));
- t.end();
-});
-
-test('print multiple statements', t => {
- const err = {
- statements: [
- ['actual.a[0]', format.formatValue(1)],
- ['actual.a', format.formatValue([1])],
- ['actual', format.formatValue({a: [1]})]
- ],
- values: []
- };
-
- t.is(format.formatSerializedError(err), [
- `actual.a[0]\n${chalk.grey('=>')} ${format.formatValue(1)}`,
- `actual.a\n${chalk.grey('=>')} ${format.formatValue([1])}`,
- `actual\n${chalk.grey('=>')} ${format.formatValue({a: [1]})}`
- ].join('\n\n') + '\n');
- t.end();
-});
-
-test('print single statement', t => {
- const err = {
- statements: [
- ['actual.a[0]', format.formatValue(1)]
- ],
- values: []
- };
-
- t.is(format.formatSerializedError(err), [
- `actual.a[0]\n${chalk.grey('=>')} ${format.formatValue(1)}`
- ].join('\n\n') + '\n');
- t.end();
-});
-
-test('print statements after values', t => {
- const err = {
- statements: [
- ['actual.a[0]', format.formatValue(1)]
- ],
- values: [
- {
- label: 'Actual:',
- formatted: format.formatValue([1, 2, 3])
- }
- ]
- };
-
- t.is(format.formatSerializedError(err), [
- 'Actual:',
- `${indentString(err.values[0].formatted, 2)}`,
- `actual.a[0]\n${chalk.grey('=>')} ${format.formatValue(1)}`
- ].join('\n\n') + '\n');
- t.end();
-});
diff --git a/test/helper/compare-line-output.js b/test/helper/compare-line-output.js
index c2ca362af..d3cddc254 100644
--- a/test/helper/compare-line-output.js
+++ b/test/helper/compare-line-output.js
@@ -1,5 +1,5 @@
'use strict';
-const SKIP_UNTIL_EMPTY_LINE = {};
+const SKIP_UNTIL_EMPTY_LINE = Symbol('SKIP_UNTIL_EMPTY_LINE');
function compareLineOutput(t, actual, lineExpectations) {
const actualLines = actual.split('\n');
@@ -22,6 +22,8 @@ function compareLineOutput(t, actual, lineExpectations) {
t.match(line, expected, `line ${lineIndex} ≪${line}≫ matches ${expected}`);
}
}
+
+ t.is(lineIndex, actualLines.length, `Compared ${lineIndex} of ${actualLines.length} lines`);
}
module.exports = compareLineOutput;
diff --git a/test/promise.js b/test/promise.js
index ac96ebe05..87611e1a7 100644
--- a/test/promise.js
+++ b/test/promise.js
@@ -1,7 +1,8 @@
'use strict';
+require('../lib/globals').options.color = false;
+
const Promise = require('bluebird');
const test = require('tap').test;
-const formatValue = require('../lib/format-assert-error').formatValue;
const Test = require('../lib/test');
function ava(fn, onResult) {
@@ -358,7 +359,9 @@ test('reject', t => {
t.is(passed, false);
t.is(result.reason.name, 'AssertionError');
t.is(result.reason.message, 'Rejected promise returned by test');
- t.same(result.reason.values, [{label: 'Rejection reason:', formatted: formatValue(new Error('unicorn'))}]);
+ t.is(result.reason.values.length, 1);
+ t.is(result.reason.values[0].label, 'Rejected promise returned by test. Reason:');
+ t.match(result.reason.values[0].formatted, /.*Error.*\n.*message: 'unicorn'/);
t.end();
});
});
@@ -374,7 +377,9 @@ test('reject with non-Error', t => {
t.is(passed, false);
t.is(result.reason.name, 'AssertionError');
t.is(result.reason.message, 'Rejected promise returned by test');
- t.same(result.reason.values, [{label: 'Rejection reason:', formatted: formatValue('failure')}]);
+ t.is(result.reason.values.length, 1);
+ t.is(result.reason.values[0].label, 'Rejected promise returned by test. Reason:');
+ t.match(result.reason.values[0].formatted, /failure/);
t.end();
});
});
diff --git a/test/reporters/format-serialized-error.js b/test/reporters/format-serialized-error.js
new file mode 100644
index 000000000..bb971c11f
--- /dev/null
+++ b/test/reporters/format-serialized-error.js
@@ -0,0 +1,130 @@
+'use strict';
+const chalk = require('chalk');
+const concordance = require('concordance');
+const test = require('tap').test;
+const formatSerializedError = require('../../lib/reporters/format-serialized-error');
+
+test('indicates message should not be printed if it is empty', t => {
+ const err = {
+ message: '',
+ statements: [],
+ values: [{label: '', formatted: ''}]
+ };
+ t.false(formatSerializedError(err).printMessage);
+ t.end();
+});
+
+test('indicates message should not be printed if the first value label starts with the message', t => {
+ const err = {
+ message: 'foo',
+ statements: [],
+ values: [{label: 'foobar', formatted: ''}]
+ };
+ t.false(formatSerializedError(err).printMessage);
+ t.end();
+});
+
+test('indicates message should be printed if not empty and the first value label does not start with the message', t => {
+ const err = {
+ message: 'foo',
+ statements: [],
+ values: [{label: 'barfoo', formatted: ''}]
+ };
+ t.true(formatSerializedError(err).printMessage);
+ t.end();
+});
+
+test('print multiple values', t => {
+ const err = {
+ statements: [],
+ values: [
+ {
+ label: 'Actual:',
+ formatted: concordance.format([1, 2, 3])
+ },
+ {
+ label: 'Expected:',
+ formatted: concordance.format({a: 1, b: 2, c: 3})
+ }
+ ]
+ };
+
+ t.is(formatSerializedError(err).formatted, [
+ 'Actual:\n',
+ `${err.values[0].formatted}\n`,
+ 'Expected:\n',
+ err.values[1].formatted
+ ].join('\n'));
+ t.end();
+});
+
+test('print single value', t => {
+ const err = {
+ statements: [],
+ values: [
+ {
+ label: 'Actual:',
+ formatted: concordance.format([1, 2, 3])
+ }
+ ]
+ };
+
+ t.is(formatSerializedError(err).formatted, [
+ 'Actual:\n',
+ err.values[0].formatted
+ ].join('\n'));
+ t.end();
+});
+
+test('print multiple statements', t => {
+ const err = {
+ statements: [
+ ['actual.a[0]', concordance.format(1)],
+ ['actual.a', concordance.format([1])],
+ ['actual', concordance.format({a: [1]})]
+ ],
+ values: []
+ };
+
+ t.is(formatSerializedError(err).formatted, [
+ `actual.a[0]\n${chalk.grey('=>')} ${concordance.format(1)}`,
+ `actual.a\n${chalk.grey('=>')} ${concordance.format([1])}`,
+ `actual\n${chalk.grey('=>')} ${concordance.format({a: [1]})}`
+ ].join('\n\n'));
+ t.end();
+});
+
+test('print single statement', t => {
+ const err = {
+ statements: [
+ ['actual.a[0]', concordance.format(1)]
+ ],
+ values: []
+ };
+
+ t.is(formatSerializedError(err).formatted, [
+ `actual.a[0]\n${chalk.grey('=>')} ${concordance.format(1)}`
+ ].join('\n\n'));
+ t.end();
+});
+
+test('print statements after values', t => {
+ const err = {
+ statements: [
+ ['actual.a[0]', concordance.format(1)]
+ ],
+ values: [
+ {
+ label: 'Actual:',
+ formatted: concordance.format([1, 2, 3])
+ }
+ ]
+ };
+
+ t.is(formatSerializedError(err).formatted, [
+ 'Actual:',
+ `${err.values[0].formatted}`,
+ `actual.a[0]\n${chalk.grey('=>')} ${concordance.format(1)}`
+ ].join('\n\n'));
+ t.end();
+});
diff --git a/test/reporters/mini.js b/test/reporters/mini.js
index 96c237adf..0a4f2acfe 100644
--- a/test/reporters/mini.js
+++ b/test/reporters/mini.js
@@ -12,7 +12,6 @@ const MiniReporter = require('../../lib/reporters/mini');
const beautifyStack = require('../../lib/beautify-stack');
const colors = require('../../lib/colors');
const compareLineOutput = require('../helper/compare-line-output');
-const formatSerializedError = require('../../lib/format-assert-error').formatSerializedError;
const codeExcerpt = require('../../lib/code-excerpt');
chalk.enabled = true;
@@ -213,10 +212,7 @@ test('results with passing tests', t => {
reporter.failCount = 0;
const actualOutput = reporter.finish({});
- const expectedOutput = [
- '\n ' + chalk.green('1 passed'),
- '\n'
- ].join('\n');
+ const expectedOutput = `\n ${chalk.green('1 passed')}\n`;
t.is(actualOutput, expectedOutput);
t.end();
@@ -237,11 +233,11 @@ test('results with passing known failure tests', t => {
const actualOutput = reporter.finish(runStatus);
const expectedOutput = [
'\n ' + chalk.green('1 passed'),
- ' ' + chalk.red('1 known failure'),
- '',
- ' ' + chalk.bold.white('known failure'),
+ '\n ' + chalk.red('1 known failure'),
+ '\n',
+ '\n ' + chalk.bold.white('known failure'),
'\n'
- ].join('\n');
+ ].join('');
t.is(actualOutput, expectedOutput);
t.end();
@@ -254,10 +250,7 @@ test('results with skipped tests', t => {
reporter.failCount = 0;
const actualOutput = reporter.finish({});
- const expectedOutput = [
- '\n ' + chalk.yellow('1 skipped'),
- '\n'
- ].join('\n');
+ const expectedOutput = `\n ${chalk.yellow('1 skipped')}\n`;
t.is(actualOutput, expectedOutput);
t.end();
@@ -270,10 +263,7 @@ test('results with todo tests', t => {
reporter.failCount = 0;
const actualOutput = reporter.finish({});
- const expectedOutput = [
- '\n ' + chalk.blue('1 todo'),
- '\n'
- ].join('\n');
+ const expectedOutput = `\n ${chalk.blue('1 todo')}\n`;
t.is(actualOutput, expectedOutput);
t.end();
@@ -321,7 +311,8 @@ test('results with passing tests and rejections', t => {
compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
'',
' ' + chalk.bold.white('Unhandled Rejection'),
- ' ' + colors.stack('stack line with trailing whitespace')
+ ' ' + colors.stack('stack line with trailing whitespace'),
+ ''
]);
t.end();
});
@@ -353,7 +344,8 @@ test('results with passing tests and exceptions', t => {
/test\/reporters\/mini\.js/,
compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
'',
- ' ' + chalk.red(cross + ' A futuristic test runner')
+ ' ' + chalk.red(cross + ' A futuristic test runner'),
+ ''
]);
t.end();
});
@@ -366,8 +358,8 @@ test('results with errors', t => {
err1.avaAssertionError = true;
err1.statements = [];
err1.values = [
- {label: 'actual:', formatted: JSON.stringify('abc')},
- {label: 'expected:', formatted: JSON.stringify('abd')}
+ {label: 'actual:', formatted: JSON.stringify('abc') + '\n'},
+ {label: 'expected:', formatted: JSON.stringify('abd') + '\n'}
];
const err2 = new Error('failure two');
@@ -377,8 +369,18 @@ test('results with errors', t => {
err2.avaAssertionError = true;
err2.statements = [];
err2.values = [
- {label: 'actual:', formatted: JSON.stringify([1])},
- {label: 'expected:', formatted: JSON.stringify([2])}
+ {label: 'actual:', formatted: JSON.stringify([1]) + '\n'},
+ {label: 'expected:', formatted: JSON.stringify([2]) + '\n'}
+ ];
+
+ const err3 = new Error('failure three');
+ err3.stack = 'error message\nTest.fn (test.js:1:1)\n';
+ const err3Path = tempWrite.sync('c();');
+ err3.source = source(err3Path);
+ err3.avaAssertionError = true;
+ err3.statements = [];
+ err3.values = [
+ {label: 'failure three:', formatted: JSON.stringify([1]) + '\n'}
];
const reporter = miniReporter();
@@ -391,6 +393,9 @@ test('results with errors', t => {
}, {
title: 'failed two',
error: err2
+ }, {
+ title: 'failed three',
+ error: err3
}]
};
@@ -406,9 +411,15 @@ test('results with errors', t => {
'',
/failure one/,
'',
- indentString(formatSerializedError(err1), 2).split('\n'),
- stackLineRegex,
- compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
+ ' actual:',
+ '',
+ ' "abc"',
+ '',
+ ' expected:',
+ '',
+ ' "abd"',
+ '',
+ stackLineRegex, compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
'',
'',
'',
@@ -419,7 +430,25 @@ test('results with errors', t => {
'',
/failure two/,
'',
- indentString(formatSerializedError(err2), 2).split('\n')
+ ' actual:',
+ '',
+ ' [1]',
+ '',
+ ' expected:',
+ '',
+ ' [2]',
+ '',
+ '',
+ '',
+ ' ' + chalk.bold.white('failed three'),
+ ' ' + chalk.grey(`${err3.source.file}:${err3.source.line}`),
+ '',
+ indentString(codeExcerpt(err3.source), 2).split('\n'),
+ '',
+ ' failure three:',
+ '',
+ ' [1]',
+ ''
]));
t.end();
});
@@ -459,7 +488,6 @@ test('results with errors and disabled code excerpts', t => {
};
const output = reporter.finish(runStatus);
-
compareLineOutput(t, output, flatten([
'',
' ' + chalk.red('1 failed'),
@@ -468,9 +496,15 @@ test('results with errors and disabled code excerpts', t => {
'',
/failure one/,
'',
- indentString(formatSerializedError(err1), 2).split('\n'),
- stackLineRegex,
- compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
+ ' actual:',
+ '',
+ ' "abc"',
+ '',
+ ' expected:',
+ '',
+ ' "abd"',
+ '',
+ stackLineRegex, compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
'',
'',
'',
@@ -481,7 +515,14 @@ test('results with errors and disabled code excerpts', t => {
'',
/failure two/,
'',
- indentString(formatSerializedError(err2), 2).split('\n')
+ ' actual:',
+ '',
+ ' [1]',
+ '',
+ ' expected:',
+ '',
+ ' [2]',
+ ''
]));
t.end();
});
@@ -523,7 +564,6 @@ test('results with errors and broken code excerpts', t => {
};
const output = reporter.finish(runStatus);
-
compareLineOutput(t, output, flatten([
'',
' ' + chalk.red('1 failed'),
@@ -533,9 +573,15 @@ test('results with errors and broken code excerpts', t => {
'',
/failure one/,
'',
- indentString(formatSerializedError(err1), 2).split('\n'),
- stackLineRegex,
- compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
+ ' actual:',
+ '',
+ ' "abc"',
+ '',
+ ' expected:',
+ '',
+ ' "abd"',
+ '',
+ stackLineRegex, compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
'',
'',
'',
@@ -546,7 +592,14 @@ test('results with errors and broken code excerpts', t => {
'',
/failure two/,
'',
- indentString(formatSerializedError(err2), 2).split('\n')
+ ' actual:',
+ '',
+ ' [1]',
+ '',
+ ' expected:',
+ '',
+ ' [2]',
+ ''
]));
t.end();
});
@@ -574,7 +627,8 @@ test('results with unhandled errors', t => {
'',
/failure one/,
'',
- stackLineRegex
+ stackLineRegex, compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
+ ''
]);
t.end();
});
@@ -590,8 +644,8 @@ test('results when fail-fast is enabled', t => {
const output = reporter.finish(runStatus);
compareLineOutput(t, output, [
'',
- '',
- ' ' + colors.information('`--fail-fast` is on. At least 1 test was skipped.')
+ ' ' + colors.information('`--fail-fast` is on. At least 1 test was skipped.'),
+ ''
]);
t.end();
});
@@ -607,8 +661,8 @@ test('results when fail-fast is enabled with multiple skipped tests', t => {
const output = reporter.finish(runStatus);
compareLineOutput(t, output, [
'',
- '',
- ' ' + colors.information('`--fail-fast` is on. At least 2 tests were skipped.')
+ ' ' + colors.information('`--fail-fast` is on. At least 2 tests were skipped.'),
+ ''
]);
t.end();
});
@@ -651,7 +705,8 @@ test('results with 1 previous failure', t => {
compareLineOutput(t, output, [
'',
' ' + colors.todo('1 todo'),
- ' ' + colors.error('1 previous failure in test files that were not rerun')
+ ' ' + colors.error('1 previous failure in test files that were not rerun'),
+ ''
]);
t.end();
});
@@ -668,7 +723,8 @@ test('results with 2 previous failures', t => {
compareLineOutput(t, output, [
'',
' ' + colors.todo('1 todo'),
- ' ' + colors.error('2 previous failures in test files that were not rerun')
+ ' ' + colors.error('2 previous failures in test files that were not rerun'),
+ ''
]);
t.end();
});
@@ -701,10 +757,7 @@ test('results with watching enabled', t => {
reporter.failCount = 0;
const actualOutput = reporter.finish({});
- const expectedOutput = [
- '\n ' + chalk.green('1 passed') + time,
- '\n'
- ].join('\n');
+ const expectedOutput = `\n ${chalk.green('1 passed') + time}\n`;
t.is(actualOutput, expectedOutput);
t.end();
@@ -739,10 +792,7 @@ test('silently handles errors without body', t => {
errors: [{}, {}]
};
const actualOutput = reporter.finish(runStatus);
- const expectedOutput = [
- '\n ' + colors.error('1 failed'),
- '\n'
- ].join('\n');
+ const expectedOutput = `\n ${colors.error('1 failed')}\n`;
t.is(actualOutput, expectedOutput);
t.end();
});
@@ -756,10 +806,7 @@ test('does not handle errors with body in rejections', t => {
}]
};
const actualOutput = reporter.finish(runStatus);
- const expectedOutput = [
- '\n ' + colors.error('1 rejection'),
- '\n'
- ].join('\n');
+ const expectedOutput = `\n ${colors.error('1 rejection')}\n`;
t.is(actualOutput, expectedOutput);
t.end();
});
@@ -776,10 +823,11 @@ test('returns description based on error itself if no stack available', t => {
const actualOutput = reporter.finish(runStatus);
const expectedOutput = [
'\n ' + colors.error('1 exception'),
+ '\n',
'\n ' + colors.title('Uncaught Exception'),
- ' ' + colors.stack('Threw non-error: ' + JSON.stringify({error: err1})),
- '\n\n'
- ].join('\n');
+ '\n ' + colors.stack('Threw non-error: ' + JSON.stringify({error: err1})),
+ '\n'
+ ].join('');
t.is(actualOutput, expectedOutput);
t.end();
});
@@ -794,10 +842,11 @@ test('shows "non-error" hint for invalid throws', t => {
const actualOutput = reporter.finish(runStatus);
const expectedOutput = [
'\n ' + colors.error('1 exception'),
+ '\n',
'\n ' + colors.title('Uncaught Exception'),
- ' ' + colors.stack('Threw non-error: function fooFn() {}'),
- '\n\n'
- ].join('\n');
+ '\n ' + colors.stack('Threw non-error: function fooFn() {}'),
+ '\n'
+ ].join('');
t.is(actualOutput, expectedOutput);
t.end();
});
@@ -840,12 +889,9 @@ test('results when hasExclusive is enabled, but there is one remaining tests', t
};
const actualOutput = reporter.finish(runStatus);
- const expectedOutput = [
- '',
- '',
- ' ' + colors.information('The .only() modifier is used in some tests. 1 test was not run'),
- '\n'
- ].join('\n');
+ const expectedOutput = '\n' +
+ ' ' + colors.information('The .only() modifier is used in some tests. 1 test was not run') +
+ '\n';
t.is(actualOutput, expectedOutput);
t.end();
});
@@ -861,12 +907,9 @@ test('results when hasExclusive is enabled, but there are multiple remaining tes
};
const actualOutput = reporter.finish(runStatus);
- const expectedOutput = [
- '',
- '',
- ' ' + colors.information('The .only() modifier is used in some tests. 2 tests were not run'),
- '\n'
- ].join('\n');
+ const expectedOutput = '\n' +
+ ' ' + colors.information('The .only() modifier is used in some tests. 2 tests were not run') +
+ '\n';
t.is(actualOutput, expectedOutput);
t.end();
});
@@ -885,12 +928,9 @@ test('result when no-color flag is set', t => {
};
const output = reporter.finish(runStatus);
- const expectedOutput = [
- '',
- '',
- ' The .only() modifier is used in some tests. 2 tests were not run',
- '\n'
- ].join('\n');
+ const expectedOutput = '\n' +
+ ' The .only() modifier is used in some tests. 2 tests were not run' +
+ '\n';
t.is(output, expectedOutput);
t.end();
});
diff --git a/test/reporters/verbose.js b/test/reporters/verbose.js
index 7bda0ed50..8cc71fd87 100644
--- a/test/reporters/verbose.js
+++ b/test/reporters/verbose.js
@@ -11,7 +11,6 @@ const beautifyStack = require('../../lib/beautify-stack');
const colors = require('../../lib/colors');
const VerboseReporter = require('../../lib/reporters/verbose');
const compareLineOutput = require('../helper/compare-line-output');
-const formatSerializedError = require('../../lib/format-assert-error').formatSerializedError;
const codeExcerpt = require('../../lib/code-excerpt');
chalk.enabled = true;
@@ -377,7 +376,7 @@ test('results with errors', t => {
error1.statements = [];
error1.values = [
{label: 'actual:', formatted: JSON.stringify('abc')},
- {lael: 'expected:', formatted: JSON.stringify('abd')}
+ {label: 'expected:', formatted: JSON.stringify('abd')}
];
const error2 = new Error('error two message');
@@ -388,7 +387,17 @@ test('results with errors', t => {
error2.statements = [];
error2.values = [
{label: 'actual:', formatted: JSON.stringify([1])},
- {lael: 'expected:', formatted: JSON.stringify([2])}
+ {label: 'expected:', formatted: JSON.stringify([2])}
+ ];
+
+ const error3 = new Error('error three message');
+ error3.stack = 'error message\nTest.fn (test.js:1:1)\n';
+ const err3Path = tempWrite.sync('b()');
+ error3.source = source(err3Path);
+ error3.avaAssertionError = true;
+ error3.statements = [];
+ error3.values = [
+ {label: 'error three message:', formatted: JSON.stringify([1])}
];
const reporter = createReporter({color: true});
@@ -400,6 +409,9 @@ test('results with errors', t => {
}, {
title: 'fail two',
error: error2
+ }, {
+ title: 'fail three',
+ error: error3
}];
const output = reporter.finish(runStatus);
@@ -414,9 +426,15 @@ test('results with errors', t => {
'',
/error one message/,
'',
- indentString(formatSerializedError(error1), 2).split('\n'),
- stackLineRegex,
- compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
+ ' actual:',
+ '',
+ ' "abc"',
+ '',
+ ' expected:',
+ '',
+ ' "abd"',
+ '',
+ stackLineRegex, compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
'',
'',
'',
@@ -427,7 +445,25 @@ test('results with errors', t => {
'',
/error two message/,
'',
- indentString(formatSerializedError(error2), 2).split('\n')
+ ' actual:',
+ '',
+ ' [1]',
+ '',
+ ' expected:',
+ '',
+ ' [2]',
+ '',
+ '',
+ '',
+ ' ' + chalk.bold.white('fail three'),
+ ' ' + chalk.grey(`${error3.source.file}:${error3.source.line}`),
+ '',
+ indentString(codeExcerpt(error3.source), 2).split('\n'),
+ '',
+ ' error three message:',
+ '',
+ ' [1]',
+ ''
]));
t.end();
});
@@ -439,7 +475,7 @@ test('results with errors and disabled code excerpts', t => {
error1.statements = [];
error1.values = [
{label: 'actual:', formatted: JSON.stringify('abc')},
- {lael: 'expected:', formatted: JSON.stringify('abd')}
+ {label: 'expected:', formatted: JSON.stringify('abd')}
];
const error2 = new Error('error two message');
@@ -450,7 +486,7 @@ test('results with errors and disabled code excerpts', t => {
error2.statements = [];
error2.values = [
{label: 'actual:', formatted: JSON.stringify([1])},
- {lael: 'expected:', formatted: JSON.stringify([2])}
+ {label: 'expected:', formatted: JSON.stringify([2])}
];
const reporter = createReporter({color: true});
@@ -473,9 +509,15 @@ test('results with errors and disabled code excerpts', t => {
'',
/error one message/,
'',
- indentString(formatSerializedError(error1), 2).split('\n'),
- stackLineRegex,
- compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
+ ' actual:',
+ '',
+ ' "abc"',
+ '',
+ ' expected:',
+ '',
+ ' "abd"',
+ '',
+ stackLineRegex, compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
'',
'',
'',
@@ -486,7 +528,14 @@ test('results with errors and disabled code excerpts', t => {
'',
/error two message/,
'',
- indentString(formatSerializedError(error2), 2).split('\n')
+ ' actual:',
+ '',
+ ' [1]',
+ '',
+ ' expected:',
+ '',
+ ' [2]',
+ ''
]));
t.end();
});
@@ -500,7 +549,7 @@ test('results with errors and disabled code excerpts', t => {
error1.statements = [];
error1.values = [
{label: 'actual:', formatted: JSON.stringify('abc')},
- {lael: 'expected:', formatted: JSON.stringify('abd')}
+ {label: 'expected:', formatted: JSON.stringify('abd')}
];
const error2 = new Error('error two message');
@@ -511,7 +560,7 @@ test('results with errors and disabled code excerpts', t => {
error2.statements = [];
error2.values = [
{label: 'actual:', formatted: JSON.stringify([1])},
- {lael: 'expected:', formatted: JSON.stringify([2])}
+ {label: 'expected:', formatted: JSON.stringify([2])}
];
const reporter = createReporter({color: true});
@@ -535,9 +584,15 @@ test('results with errors and disabled code excerpts', t => {
'',
/error one message/,
'',
- indentString(formatSerializedError(error1), 2).split('\n'),
- stackLineRegex,
- compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
+ ' actual:',
+ '',
+ ' "abc"',
+ '',
+ ' expected:',
+ '',
+ ' "abd"',
+ '',
+ stackLineRegex, compareLineOutput.SKIP_UNTIL_EMPTY_LINE,
'',
'',
'',
@@ -548,7 +603,14 @@ test('results with errors and disabled code excerpts', t => {
'',
/error two message/,
'',
- indentString(formatSerializedError(error2), 2).split('\n')
+ ' actual:',
+ '',
+ ' [1]',
+ '',
+ ' expected:',
+ '',
+ ' [2]',
+ ''
]));
t.end();
});
@@ -565,13 +627,11 @@ test('results when fail-fast is enabled', t => {
const output = reporter.finish(runStatus);
const expectedOutput = [
- '',
- ' ' + chalk.red('1 test failed') + time,
- '',
- '',
- ' ' + colors.information('`--fail-fast` is on. At least 1 test was skipped.'),
- ''
- ].join('\n');
+ '\n ' + chalk.red('1 test failed') + time,
+ '\n',
+ '\n ' + colors.information('`--fail-fast` is on. At least 1 test was skipped.'),
+ '\n'
+ ].join('');
t.is(output, expectedOutput);
t.end();
@@ -589,13 +649,11 @@ test('results when fail-fast is enabled with multiple skipped tests', t => {
const output = reporter.finish(runStatus);
const expectedOutput = [
- '',
- ' ' + chalk.red('1 test failed') + time,
- '',
- '',
- ' ' + colors.information('`--fail-fast` is on. At least 2 tests were skipped.'),
- ''
- ].join('\n');
+ '\n ' + chalk.red('1 test failed') + time,
+ '\n',
+ '\n ' + colors.information('`--fail-fast` is on. At least 2 tests were skipped.'),
+ '\n'
+ ].join('');
t.is(output, expectedOutput);
t.end();
@@ -654,7 +712,8 @@ test('results with 1 previous failure', t => {
'',
' ' + colors.pass('1 test passed') + time,
' ' + colors.error('1 uncaught exception'),
- ' ' + colors.error('1 previous failure in test files that were not rerun')
+ ' ' + colors.error('1 previous failure in test files that were not rerun'),
+ ''
]);
t.end();
});
@@ -672,7 +731,8 @@ test('results with 2 previous failures', t => {
'',
' ' + colors.pass('1 test passed') + time,
' ' + colors.error('1 uncaught exception'),
- ' ' + colors.error('2 previous failures in test files that were not rerun')
+ ' ' + colors.error('2 previous failures in test files that were not rerun'),
+ ''
]);
t.end();
});
@@ -736,13 +796,11 @@ test('results when hasExclusive is enabled, but there is one remaining tests', t
const output = reporter.finish(runStatus);
const expectedOutput = [
- '',
- ' ' + chalk.green('1 test passed') + time,
- '',
- '',
- ' ' + colors.information('The .only() modifier is used in some tests. 1 test was not run'),
- ''
- ].join('\n');
+ '\n ' + chalk.green('1 test passed') + time,
+ '\n',
+ '\n ' + colors.information('The .only() modifier is used in some tests. 1 test was not run'),
+ '\n'
+ ].join('');
t.is(output, expectedOutput);
t.end();
@@ -759,13 +817,11 @@ test('results when hasExclusive is enabled, but there are multiple remaining tes
const output = reporter.finish(runStatus);
const expectedOutput = [
- '',
- ' ' + chalk.green('1 test passed') + time,
- '',
- '',
- ' ' + colors.information('The .only() modifier is used in some tests. 2 tests were not run'),
- ''
- ].join('\n');
+ '\n ' + chalk.green('1 test passed') + time,
+ '\n',
+ '\n ' + colors.information('The .only() modifier is used in some tests. 2 tests were not run'),
+ '\n'
+ ].join('');
t.is(output, expectedOutput);
t.end();
@@ -782,13 +838,11 @@ test('result when no-color flag is set', t => {
const output = reporter.finish(runStatus);
const expectedOutput = [
- '',
- ' 1 test passed [17:19:12]',
- '',
- '',
- ' The .only() modifier is used in some tests. 2 tests were not run',
- ''
- ].join('\n');
+ '\n 1 test passed [17:19:12]',
+ '\n',
+ '\n The .only() modifier is used in some tests. 2 tests were not run',
+ '\n'
+ ].join('');
t.is(output, expectedOutput);
t.end();
diff --git a/test/runner.js b/test/runner.js
index 50ce2e7a3..bc876c23a 100644
--- a/test/runner.js
+++ b/test/runner.js
@@ -745,7 +745,6 @@ test('macros: Customize test names attaching a `title` function', t => {
];
function macroFn(avaT) {
- t.is(avaT.title, expectedTitles.shift());
t.deepEqual(slice.call(arguments, 1), expectedArgs.shift());
avaT.pass();
}
@@ -754,6 +753,10 @@ test('macros: Customize test names attaching a `title` function', t => {
const runner = new Runner();
+ runner.on('test', props => {
+ t.is(props.title, expectedTitles.shift());
+ });
+
runner.chain.test(macroFn, 'A');
runner.chain.test('supplied', macroFn, 'B');
runner.chain.test(macroFn, 'C');
@@ -770,7 +773,6 @@ test('match applies to macros', t => {
t.plan(3);
function macroFn(avaT) {
- t.is(avaT.title, 'foobar');
avaT.pass();
}
@@ -780,6 +782,10 @@ test('match applies to macros', t => {
match: ['foobar']
});
+ runner.on('test', props => {
+ t.is(props.title, 'foobar');
+ });
+
runner.chain.test(macroFn, 'foo');
runner.chain.test(macroFn, 'bar');
@@ -842,7 +848,6 @@ test('match applies to arrays of macros', t => {
fooMacro.title = (title, firstArg) => `${firstArg}foo`;
function barMacro(avaT) {
- t.is(avaT.title, 'foobar');
avaT.pass();
}
barMacro.title = (title, firstArg) => `${firstArg}bar`;
@@ -857,6 +862,10 @@ test('match applies to arrays of macros', t => {
match: ['foobar']
});
+ runner.on('test', props => {
+ t.is(props.title, 'foobar');
+ });
+
runner.chain.test([fooMacro, barMacro, bazMacro], 'foo');
runner.chain.test([fooMacro, barMacro, bazMacro], 'bar');
diff --git a/test/test-collection.js b/test/test-collection.js
index 69384b37a..d1f649815 100644
--- a/test/test-collection.js
+++ b/test/test-collection.js
@@ -239,68 +239,6 @@ test('adding a bunch of different types', t => {
t.end();
});
-test('foo', t => {
- const collection = new TestCollection({});
- const log = [];
-
- function logger(a) {
- log.push(a.title);
- a.pass();
- }
-
- function add(title, opts) {
- collection.add({
- title,
- metadata: metadata(opts),
- fn: logger
- });
- }
-
- add('after1', {type: 'after'});
- add('after.always', {
- type: 'after',
- always: true
- });
- add('beforeEach1', {type: 'beforeEach'});
- add('before1', {type: 'before'});
- add('beforeEach2', {type: 'beforeEach'});
- add('afterEach1', {type: 'afterEach'});
- add('afterEach.always', {
- type: 'afterEach',
- always: true
- });
- add('test1', {});
- add('afterEach2', {type: 'afterEach'});
- add('test2', {});
- add('after2', {type: 'after'});
- add('before2', {type: 'before'});
-
- const passed = collection.build().run();
- t.is(passed, true);
-
- t.strictDeepEqual(log, [
- 'before1',
- 'before2',
- 'beforeEach1 for test1',
- 'beforeEach2 for test1',
- 'test1',
- 'afterEach1 for test1',
- 'afterEach2 for test1',
- 'afterEach.always for test1',
- 'beforeEach1 for test2',
- 'beforeEach2 for test2',
- 'test2',
- 'afterEach1 for test2',
- 'afterEach2 for test2',
- 'afterEach.always for test2',
- 'after1',
- 'after2',
- 'after.always'
- ]);
-
- t.end();
-});
-
test('foo', t => {
const collection = new TestCollection({});
const log = [];
diff --git a/test/test.js b/test/test.js
index 0e976de5e..2c7fa4adf 100644
--- a/test/test.js
+++ b/test/test.js
@@ -1,7 +1,8 @@
'use strict';
+require('../lib/globals').options.color = false;
+
const test = require('tap').test;
const delay = require('delay');
-const formatValue = require('../lib/format-assert-error').formatValue;
const Test = require('../lib/test');
const failingTestHint = 'Test was expected to fail, but succeeded, you should stop marking the test as failing';
@@ -145,7 +146,9 @@ test('wrap non-assertion errors', t => {
t.is(passed, false);
t.is(result.reason.message, 'Error thrown in test');
t.is(result.reason.name, 'AssertionError');
- t.same(result.reason.values, [{label: 'Error:', formatted: formatValue(err)}]);
+ t.is(result.reason.values.length, 1);
+ t.is(result.reason.values[0].label, 'Error thrown in test:');
+ t.match(result.reason.values[0].formatted, /Error/);
t.end();
});
@@ -171,7 +174,9 @@ test('end can be used as callback with error', t => {
t.is(passed, false);
t.is(result.reason.message, 'Callback called with an error');
t.is(result.reason.name, 'AssertionError');
- t.same(result.reason.values, [{label: 'Error:', formatted: formatValue(err)}]);
+ t.is(result.reason.values.length, 1);
+ t.is(result.reason.values[0].label, 'Callback called with an error:');
+ t.match(result.reason.values[0].formatted, /.*Error.*\n.*message: 'failed'/);
t.end();
});
@@ -188,10 +193,25 @@ test('end can be used as callback with a non-error as its error argument', t =>
t.ok(result.reason);
t.is(result.reason.message, 'Callback called with an error');
t.is(result.reason.name, 'AssertionError');
- t.same(result.reason.values, [{label: 'Error:', formatted: formatValue(nonError)}]);
+ t.is(result.reason.values.length, 1);
+ t.is(result.reason.values[0].label, 'Callback called with an error:');
+ t.match(result.reason.values[0].formatted, /.*\{.*\n.*foo: 'bar'/);
t.end();
});
+test('title returns the test title', t => {
+ t.plan(1);
+ new Test({
+ fn(a) {
+ t.is(a.title, 'foo');
+ a.pass();
+ },
+ metadata: {type: 'test', callback: false},
+ onResult: noop,
+ title: 'foo'
+ }).run();
+});
+
test('handle non-assertion errors even when planned', t => {
const err = new Error('bar');
let result;
@@ -376,10 +396,9 @@ test('fails with the first assertError', t => {
t.is(passed, false);
t.is(result.reason.name, 'AssertionError');
- t.same(result.reason.values, [
- {label: 'Actual:', formatted: formatValue(1)},
- {label: 'Must be the same as:', formatted: formatValue(2)}
- ]);
+ t.is(result.reason.values.length, 1);
+ t.is(result.reason.values[0].label, 'Difference:');
+ t.match(result.reason.values[0].formatted, /- 1\n\+ 2/);
t.end();
});
@@ -409,7 +428,9 @@ test('fails with thrown falsy value', t => {
t.is(passed, false);
t.is(result.reason.message, 'Error thrown in test');
t.is(result.reason.name, 'AssertionError');
- t.same(result.reason.values, [{label: 'Error:', formatted: formatValue(0)}]);
+ t.is(result.reason.values.length, 1);
+ t.is(result.reason.values[0].label, 'Error thrown in test:');
+ t.match(result.reason.values[0].formatted, /0/);
t.end();
});
@@ -425,7 +446,9 @@ test('fails with thrown non-error object', t => {
t.is(passed, false);
t.is(result.reason.message, 'Error thrown in test');
t.is(result.reason.name, 'AssertionError');
- t.same(result.reason.values, [{label: 'Error:', formatted: formatValue(obj)}]);
+ t.is(result.reason.values.length, 1);
+ t.is(result.reason.values[0].label, 'Error thrown in test:');
+ t.match(result.reason.values[0].formatted, /.*\{.*\n.*foo: 'bar'/);
t.end();
});
diff --git a/test/watcher.js b/test/watcher.js
index 0f47cef2b..a5cc2bba7 100644
--- a/test/watcher.js
+++ b/test/watcher.js
@@ -161,7 +161,7 @@ group('chokidar', (beforeEach, test, group) => {
t.ok(chokidar.watch.calledOnce);
t.strictDeepEqual(chokidar.watch.firstCall.args, [
- ['package.json', '**/*.js'].concat(files),
+ ['package.json', '**/*.js', '**/*.snap'].concat(files),
{
ignored: defaultIgnore.map(dir => `${dir}/**/*`),
ignoreInitial: true
@@ -388,7 +388,7 @@ group('chokidar', (beforeEach, test, group) => {
});
});
- test('debounces by 10ms', t => {
+ test('debounces by 100ms', t => {
t.plan(1);
api.run.returns(Promise.resolve(runStatus));
start();
@@ -396,12 +396,12 @@ group('chokidar', (beforeEach, test, group) => {
change();
const before = clock.now;
return debounce().then(() => {
- t.is(clock.now - before, 10);
+ t.is(clock.now - before, 100);
});
});
test('debounces again if changes occur in the interval', t => {
- t.plan(2);
+ t.plan(4);
api.run.returns(Promise.resolve(runStatus));
start();
@@ -409,12 +409,23 @@ group('chokidar', (beforeEach, test, group) => {
change();
const before = clock.now;
- return debounce(2).then(() => {
- t.is(clock.now - before, 2 * 10);
+ return debounce().then(() => {
+ change();
+ return debounce();
+ }).then(() => {
+ t.is(clock.now - before, 150);
+ change();
+ return debounce();
+ }).then(() => {
+ t.is(clock.now - before, 175);
change();
return debounce();
}).then(() => {
- t.is(clock.now - before, 3 * 10);
+ t.is(clock.now - before, 187);
+ change();
+ return debounce();
+ }).then(() => {
+ t.is(clock.now - before, 197);
});
});
@@ -739,7 +750,7 @@ group('chokidar', (beforeEach, test, group) => {
// No new runs yet
t.ok(api.run.calledTwice);
// Though the clock has advanced
- t.is(clock.now - before, 10);
+ t.is(clock.now - before, 100);
before = clock.now;
const previous = done;
@@ -1095,13 +1106,14 @@ group('chokidar', (beforeEach, test, group) => {
});
test('logs a debug message when sources remain without dependent tests', t => {
- t.plan(2);
+ t.plan(3);
seed();
change('cannot-be-mapped.js');
return debounce().then(() => {
- t.ok(debug.calledTwice);
- t.strictDeepEqual(debug.secondCall.args, ['ava:watcher', 'Sources remain that cannot be traced to specific tests. Rerunning all tests']);
+ t.ok(debug.calledThrice);
+ t.strictDeepEqual(debug.secondCall.args, ['ava:watcher', 'Sources remain that cannot be traced to specific tests: %O', ['cannot-be-mapped.js']]);
+ t.strictDeepEqual(debug.thirdCall.args, ['ava:watcher', 'Rerunning all tests']);
});
});
});