ava 3.8.1 → 3.10.1

package/index.d.ts

@@ -45,6 +45,9 @@ export interface Assertions {
 	/** Assert that `actual` is [deeply equal](https://github.com/concordancejs/concordance#comparison-details) to `expected`. */
 	deepEqual: DeepEqualAssertion;
 
+	/** Assert that `actual` is like `expected`. */
+	like: LikeAssertion;
+
 	/** Fail the test. */
 	fail: FailAssertion;
 
@@ -125,6 +128,14 @@ export interface DeepEqualAssertion {
 	skip(actual: any, expected: any, message?: string): void;
 }
 
+export interface LikeAssertion {
+	/** Assert that `value` is like `selector`. */
+	(value: any, selector: Record<string, any>, message?: string): void;
+
+	/** Skip this assertion. */
+	skip(value: any, selector: any, message?: string): void;
+}
+
 export interface FailAssertion {
 	/** Fail the test. */
 	(message?: string): void;
@@ -342,7 +353,7 @@ export interface TimeoutFn {
 	 * Set a timeout for the test, in milliseconds. The test will fail if the timeout is exceeded.
 	 * The timeout is reset each time an assertion is made.
 	 */
-	(ms: number): void;
+	(ms: number, message?: string): void;
 }
 
 export interface TeardownFn {
@@ -422,7 +433,7 @@ export interface CbExecutionContext<Context = unknown> extends ExecutionContext<
 	end(error?: any): void;
 }
 
-export type ImplementationResult = PromiseLike<void> | Subscribable | void;
+export type ImplementationResult = PromiseLike<void> | Subscribable | void; // eslint-disable-line @typescript-eslint/no-invalid-void-type
 export type Implementation<Context = unknown> = (t: ExecutionContext<Context>) => ImplementationResult;
 export type CbImplementation<Context = unknown> = (t: CbExecutionContext<Context>) => ImplementationResult;
 

package/lib/assert.js

@@ -3,11 +3,11 @@ const concordance = require('concordance');
 const isError = require('is-error');
 const isPromise = require('is-promise');
 const concordanceOptions = require('./concordance-options').default;
-const concordanceDiffOptions = require('./concordance-options').diff;
+const {CIRCULAR_SELECTOR, isLikeSelector, selectComparable} = require('./like-selector');
 const snapshotManager = require('./snapshot-manager');
 
 function formatDescriptorDiff(actualDescriptor, expectedDescriptor, options) {
-	options = {...options, ...concordanceDiffOptions};
+	options = {...options, ...concordanceOptions};
 	return {
 		label: 'Difference:',
 		formatted: concordance.diffDescriptors(actualDescriptor, expectedDescriptor, options)
@@ -64,6 +64,21 @@ class AssertionError extends Error {
 }
 exports.AssertionError = AssertionError;
 
+function checkAssertionMessage(assertion, message) {
+	if (typeof message === 'undefined' || typeof message === 'string') {
+		return true;
+	}
+
+	return new AssertionError({
+		assertion,
+		improperUsage: true,
+		message: 'The assertion message must be a string',
+		values: [formatWithLabel('Called with:', message)]
+	});
+}
+
+exports.checkAssertionMessage = checkAssertionMessage;
+
 function getErrorWithLongStackTrace() {
 	const limitBefore = Error.stackTraceLimit;
 	Error.stackTraceLimit = Infinity;
@@ -242,7 +257,9 @@ class Assertions {
 		fail = notImplemented,
 		skip = notImplemented,
 		compareWithSnapshot = notImplemented,
-		powerAssert
+		powerAssert,
+		experiments = {},
+		disableSnapshots = false
 	} = {}) {
 		const withSkip = assertionFn => {
 			assertionFn.skip = skip;
@@ -267,22 +284,16 @@ class Assertions {
 		});
 
 		const checkMessage = (assertion, message, powerAssert = false) => {
-			if (typeof message === 'undefined' || typeof message === 'string') {
-				return true;
+			const result = checkAssertionMessage(assertion, message);
+			if (result === true) {
+				return this.true;
 			}
 
-			const error = new AssertionError({
-				assertion,
-				improperUsage: true,
-				message: 'The assertion message must be a string',
-				values: [formatWithLabel('Called with:', message)]
-			});
-
 			if (powerAssert) {
-				throw error;
+				throw result;
 			}
 
-			fail(error);
+			fail(result);
 			return false;
 		};
 
@@ -387,6 +398,61 @@ class Assertions {
 			}
 		});
 
+		this.like = withSkip((actual, selector, message) => {
+			if (!experiments.likeAssertion) {
+				fail(new AssertionError({
+					assertion: 'like',
+					improperUsage: true,
+					message: 'You must enable the `likeAssertion` experiment in order to use `t.like()`'
+				}));
+				return;
+			}
+
+			if (!checkMessage('like', message)) {
+				return;
+			}
+
+			if (!isLikeSelector(selector)) {
+				fail(new AssertionError({
+					assertion: 'like',
+					improperUsage: true,
+					message: '`t.like()` selector must be a non-empty object',
+					values: [formatWithLabel('Called with:', selector)]
+				}));
+				return;
+			}
+
+			let comparable;
+			try {
+				comparable = selectComparable(actual, selector);
+			} catch (error) {
+				if (error === CIRCULAR_SELECTOR) {
+					fail(new AssertionError({
+						assertion: 'like',
+						improperUsage: true,
+						message: '`t.like()` selector must not contain circular references',
+						values: [formatWithLabel('Called with:', selector)]
+					}));
+					return;
+				}
+
+				throw error;
+			}
+
+			const result = concordance.compare(comparable, selector, concordanceOptions);
+			if (result.pass) {
+				pass();
+			} else {
+				const actualDescriptor = result.actual || concordance.describe(comparable, concordanceOptions);
+				const expectedDescriptor = result.expected || concordance.describe(selector, concordanceOptions);
+				fail(new AssertionError({
+					assertion: 'like',
+					message,
+					values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)]
+				}));
+			}
+		});
+
 		this.throws = withSkip((...args) => {
 			// Since arrow functions do not support 'arguments', we are using rest
 			// operator, so we can determine the total number of arguments passed
@@ -634,6 +700,15 @@ class Assertions {
 		});
 
 		this.snapshot = withSkip((expected, ...rest) => {
+			if (disableSnapshots && experiments.disableSnapshotsInHooks) {
+				fail(new AssertionError({
+					assertion: 'snapshot',
+					message: '`t.snapshot()` can only be used in tests',
+					improperUsage: true
+				}));
+				return;
+			}
+
 			let message;
 			let snapshotOptions;
 			if (rest.length > 1) {

package/lib/cli.js

@@ -182,6 +182,10 @@ exports.run = async () => { // eslint-disable-line complexity
 	const chalkOptions = {level: combined.color === false ? 0 : require('chalk').level};
 	const chalk = require('./chalk').set(chalkOptions);
 
+	if (combined.updateSnapshots && combined.match) {
+		exit('Snapshots cannot be updated when matching specific tests.');
+	}
+
 	if (confError) {
 		if (confError.parent) {
 			exit(`${confError.message}\n\n${chalk.gray((confError.parent && confError.parent.stack) || confError.parent)}`);
@@ -259,8 +263,7 @@ exports.run = async () => { // eslint-disable-line complexity
 
 	const ciParallelVars = require('ci-parallel-vars');
 	const Api = require('./api');
-	const VerboseReporter = require('./reporters/verbose');
-	const MiniReporter = require('./reporters/mini');
+	const DefaultReporter = require('./reporters/default');
 	const TapReporter = require('./reporters/tap');
 	const Watcher = require('./watcher');
 	const normalizeExtensions = require('./extensions');
@@ -357,6 +360,9 @@ exports.run = async () => { // eslint-disable-line complexity
 			pattern: normalizePattern(path.relative(projectDir, path.resolve(process.cwd(), pattern))),
 			...rest
 		}));
+	if (combined.updateSnapshots && filter.some(condition => condition.lineNumbers !== null)) {
+		exit('Snapshots cannot be updated when selecting specific tests by their line number.');
+	}
 
 	const api = new Api({
 		cacheEnabled: combined.cache !== false,
@@ -391,25 +397,32 @@ exports.run = async () => { // eslint-disable-line complexity
 			reportStream: process.stdout,
 			stdStream: process.stderr
 		});
-	} else if (debug !== null || combined.verbose || isCi || !process.stdout.isTTY) {
-		reporter = new VerboseReporter({
-			projectDir,
-			reportStream: process.stdout,
-			stdStream: process.stderr,
-			watching: combined.watch
-		});
 	} else {
-		reporter = new MiniReporter({
+		reporter = new DefaultReporter({
 			projectDir,
 			reportStream: process.stdout,
 			stdStream: process.stderr,
-			watching: combined.watch
+			watching: combined.watch,
+			verbose: debug !== null || combined.verbose || isCi || !process.stdout.isTTY
 		});
 	}
 
 	api.on('run', plan => {
 		reporter.startRun(plan);
 
+		if (process.env.AVA_EMIT_RUN_STATUS_OVER_IPC === 'I\'ll find a payphone baby / Take some time to talk to you') {
+			if (process.versions.node >= '12.16.0') {
+				plan.status.on('stateChange', evt => {
+					process.send(evt);
+				});
+			} else {
+				const v8 = require('v8');
+				plan.status.on('stateChange', evt => {
+					process.send([...v8.serialize(evt)]);
+				});
+			}
+		}
+
 		plan.status.on('stateChange', evt => {
 			if (evt.type === 'interrupt') {
 				reporter.endRun();

package/lib/code-excerpt.js

@@ -19,7 +19,7 @@ module.exports = (source, options = {}) => {
 	let contents;
 	try {
 		contents = fs.readFileSync(file, 'utf8');
-	} catch (_) {
+	} catch {
 		return null;
 	}
 

package/lib/concordance-options.js

@@ -135,5 +135,4 @@ exports.default = {
 	theme
 };
 
-exports.diff = {maxDepth: 1, plugins, theme};
 exports.snapshotManager = {plugins, theme: plainTheme};

package/lib/like-selector.js

@@ -0,0 +1,37 @@
+'use strict';
+function isLikeSelector(selector) {
+	return selector !== null &&
+		typeof selector === 'object' &&
+		Reflect.getPrototypeOf(selector) === Object.prototype &&
+		Reflect.ownKeys(selector).length > 0;
+}
+
+exports.isLikeSelector = isLikeSelector;
+
+const CIRCULAR_SELECTOR = new Error('Encountered a circular selector');
+exports.CIRCULAR_SELECTOR = CIRCULAR_SELECTOR;
+
+function selectComparable(lhs, selector, circular = new Set()) {
+	if (circular.has(selector)) {
+		throw CIRCULAR_SELECTOR;
+	}
+
+	circular.add(selector);
+
+	if (lhs === null || typeof lhs !== 'object') {
+		return lhs;
+	}
+
+	const comparable = {};
+	for (const [key, rhs] of Object.entries(selector)) {
+		if (isLikeSelector(rhs)) {
+			comparable[key] = selectComparable(Reflect.get(lhs, key), rhs, circular);
+		} else {
+			comparable[key] = Reflect.get(lhs, key);
+		}
+	}
+
+	return comparable;
+}
+
+exports.selectComparable = selectComparable;

package/lib/line-numbers.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const micromatch = require('micromatch');
+const picomatch = require('picomatch');
 const flatten = require('lodash/flatten');
 
 const NUMBER_REGEX = /^\d+$/;
@@ -56,7 +56,7 @@ exports.splitPatternAndLineNumbers = splitPatternAndLineNumbers;
 function getApplicableLineNumbers(normalizedFilePath, filter) {
 	return sortNumbersAscending(distinctArray(flatten(
 		filter
-			.filter(({pattern, lineNumbers}) => lineNumbers && micromatch.isMatch(normalizedFilePath, pattern))
+			.filter(({pattern, lineNumbers}) => lineNumbers && picomatch.isMatch(normalizedFilePath, pattern))
 			.map(({lineNumbers}) => lineNumbers)
 	)));
 }

package/lib/load-config.js

@@ -7,7 +7,7 @@ const pkgConf = require('pkg-conf');
 
 const NO_SUCH_FILE = Symbol('no ava.config.js file');
 const MISSING_DEFAULT_EXPORT = Symbol('missing default export');
-const EXPERIMENTS = new Set();
+const EXPERIMENTS = new Set(['disableSnapshotsInHooks', 'likeAssertion', 'reverseTeardowns']);
 
 // *Very* rudimentary support for loading ava.config.js files containing an `export default` statement.
 const evaluateJsConfig = configFile => {