.github/workflows/ci.yml

@@ -15,7 +15,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node-version: [^10.18.0, ^12.14.0, ^13.5.0, ^14.0.0]
+        node-version: [^10.18.0, ^12.14.0, ^14.0.0]
         os: [ubuntu-latest, windows-latest]
     steps:
       - uses: actions/checkout@v1
@@ -41,7 +41,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ts-version: [~3.7.5, ~3.8]
+        ts-version: [~3.7.5, ~3.8, ~3.9]
     steps:
       - uses: actions/checkout@v1
         with:

docs/02-execution-context.md

@@ -40,12 +40,36 @@ Plan how many assertion there are in the test. The test will fail if the actual
 
 ## `t.teardown(fn)`
 
-Registers the `fn` function to be run after the test has finished. You can register multiple functions and they'll run in order. You can use asynchronous functions: only one will run at a time.
+Registers the `fn` function to be run after the test has finished. You can register multiple functions and they'll run in order<sup>†</sup>. You can use asynchronous functions: only one will run at a time.
 
 You cannot perform assertions using the `t` object or register additional functions from inside `fn`.
 
 You cannot use `t.teardown()` in hooks either.
 
+<sup>†</sup> In the next major release we'll change this so teardown functions run in reverse order. The last registered function will be called first. You can opt in to this behavior now by enabling the `reverseTeardowns` experiment.
+
+**`package.json`**:
+
+```json
+{
+	"ava": {
+		"nonSemVerExperiments": {
+			"reverseTeardowns": true
+		}
+	}
+}
+```
+
+**`ava.config.js`**:
+
+```js
+export default {
+	nonSemVerExperiments: {
+		reverseTeardowns: true
+	}
+}
+```
+
 ## `t.timeout(ms)`
 
 Set a timeout for the test, in milliseconds. The test will fail if this timeout is exceeded. The timeout is reset each time an assertion is made.

docs/03-assertions.md

@@ -207,6 +207,55 @@ Assert that `value` is deeply equal to `expected`. See [Concordance](https://git
 
 Assert that `value` is not deeply equal to `expected`. The inverse of `.deepEqual()`.
 
+### `.like(value, selector, message?)`
+
+Assert that `value` is like `selector`. This is a variant of `.deepEqual()`, however `selector` does not need to have the same enumerable properties as `value` does.
+
+Instead AVA derives a *comparable* object from `value`, based on the deeply-nested properties of `selector`. This object is then compared to `selector` using `.deepEqual()`.
+
+Any values in `selector` that are not regular objects should be deeply equal to the corresponding values in `value`.
+
+This is an experimental assertion for the time being. You need to enable it:
+
+**`package.json`**:
+
+```json
+{
+	"ava": {
+		"nonSemVerExperiments": {
+			"likeAssertion": true
+		}
+	}
+}
+```
+
+**`ava.config.js`**:
+
+```js
+export default {
+	nonSemVerExperiments: {
+		likeAssertion: true
+	}
+}
+```
+
+In the following example, the `map` property of `value` must be deeply equal to that of `selector`. However `nested.qux` is ignored, because it's not in `selector`.
+
+```js
+t.like({
+	map: new Map([['foo', 'bar']]),
+	nested: {
+		baz: 'thud',
+		qux: 'quux'
+	}
+}, {
+	map: new Map([['foo', 'bar']]),
+	nested: {
+		baz: 'thud',
+	}
+})
+```
+
 ### `.throws(fn, expectation?, message?)`
 
 Assert that an error is thrown. `fn` must be a function which should throw. The thrown value *must* be an error. It is returned so you can run more assertions against it.

docs/recipes/endpoint-testing.md

@@ -17,21 +17,20 @@ const app = require('../app');
 
 test.before(async t => {
 	t.context.server = http.createServer(app);
-	t.context.baseUrl = await listen(t.context.server);
+	t.context.prefixUrl = await listen(t.context.server);
 });
 
 test.after.always(t => {
 	t.context.server.close();
 });
 
 test.serial('get /user', async t => {
-	const res = await got('/user', { baseUrl: t.context.baseUrl, json: true });
-	t.is(res.body.email, 'ava@rocks.com');
+	const {email} = await got('user', {prefixUrl: t.context.prefixUrl}).json();
+	t.is(email, 'ava@rocks.com');
 });
 ```
 
 Other libraries you may find useful: 
 
 - [`supertest`](https://github.com/visionmedia/supertest)
 - [`get-port`](https://github.com/sindresorhus/get-port)
-

docs/recipes/puppeteer.md

@@ -15,7 +15,7 @@ The first step is setting up a helper to configure the environment:
 ```js
 const puppeteer = require('puppeteer');
 
-export default async function withPage(t, run) {
+module.exports = async (t, run) => {
 	const browser = await puppeteer.launch();
 	const page = await browser.newPage();
 	try {

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, unknown>, message?: string): void;
+
+	/** Skip this assertion. */
+	skip(value: any, selector: any, message?: string): void;
+}
+
 export interface FailAssertion {
 	/** Fail the test. */
 	(message?: string): void;
@@ -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;
 

lib/assert.js

@@ -3,6 +3,7 @@ const concordance = require('concordance');
 const isError = require('is-error');
 const isPromise = require('is-promise');
 const concordanceOptions = require('./concordance-options').default;
+const {CIRCULAR_SELECTOR, isLikeSelector, selectComparable} = require('./like-selector');
 const snapshotManager = require('./snapshot-manager');
 
 function formatDescriptorDiff(actualDescriptor, expectedDescriptor, options) {
@@ -241,7 +242,8 @@ class Assertions {
 		fail = notImplemented,
 		skip = notImplemented,
 		compareWithSnapshot = notImplemented,
-		powerAssert
+		powerAssert,
+		experiments = {}
 	} = {}) {
 		const withSkip = assertionFn => {
 			assertionFn.skip = skip;
@@ -386,6 +388,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

lib/cli.js

@@ -259,8 +259,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');
@@ -391,19 +390,13 @@ 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
 		});
 	}
 

lib/code-excerpt.js

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

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;

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(['likeAssertion', 'reverseTeardowns']);
 
 // *Very* rudimentary support for loading ava.config.js files containing an `export default` statement.
 const evaluateJsConfig = configFile => {