ava 3.15.0 → 4.0.0

package/lib/assert.js

@@ -1,23 +1,23 @@
-'use strict';
-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');
+import concordance from 'concordance';
+import isError from 'is-error';
+import isPromise from 'is-promise';
+
+import concordanceOptions from './concordance-options.js';
+import {CIRCULAR_SELECTOR, isLikeSelector, selectComparable} from './like-selector.js';
+import {SnapshotError, VersionMismatchError} from './snapshot-manager.js';
 
 function formatDescriptorDiff(actualDescriptor, expectedDescriptor, options) {
 	options = {...options, ...concordanceOptions};
 	return {
 		label: 'Difference:',
-		formatted: concordance.diffDescriptors(actualDescriptor, expectedDescriptor, options)
+		formatted: concordance.diffDescriptors(actualDescriptor, expectedDescriptor, options),
 	};
 }
 
 function formatDescriptorWithLabel(label, descriptor) {
 	return {
 		label,
-		formatted: concordance.formatDescriptor(descriptor, concordanceOptions)
+		formatted: concordance.formatDescriptor(descriptor, concordanceOptions),
 	};
 }
 
@@ -25,17 +25,13 @@ function formatWithLabel(label, value) {
 	return formatDescriptorWithLabel(label, concordance.describe(value, concordanceOptions));
 }
 
-function formatPowerAssertValue(value) {
-	return concordance.format(value, concordanceOptions);
-}
-
 const hasOwnProperty = (object, prop) => Object.prototype.hasOwnProperty.call(object, prop);
 const noop = () => {};
 const notImplemented = () => {
 	throw new Error('not implemented');
 };
 
-class AssertionError extends Error {
+export class AssertionError extends Error {
 	constructor(options) {
 		super(options.message || '');
 		this.name = 'AssertionError';
@@ -52,19 +48,11 @@ class AssertionError extends Error {
 		// use the values for custom diff views
 		this.raw = options.raw;
 
-		// Reserved for power-assert statements
-		this.statements = [];
-
-		if (options.savedError) {
-			this.savedError = options.savedError;
-		} else {
-			this.savedError = getErrorWithLongStackTrace();
-		}
+		this.savedError = options.savedError ? options.savedError : getErrorWithLongStackTrace();
 	}
 }
-exports.AssertionError = AssertionError;
 
-function checkAssertionMessage(assertion, message) {
+export function checkAssertionMessage(assertion, message) {
 	if (typeof message === 'undefined' || typeof message === 'string') {
 		return true;
 	}
@@ -73,50 +61,48 @@ function checkAssertionMessage(assertion, message) {
 		assertion,
 		improperUsage: true,
 		message: 'The assertion message must be a string',
-		values: [formatWithLabel('Called with:', message)]
+		values: [formatWithLabel('Called with:', message)],
 	});
 }
 
-exports.checkAssertionMessage = checkAssertionMessage;
-
 function getErrorWithLongStackTrace() {
 	const limitBefore = Error.stackTraceLimit;
-	Error.stackTraceLimit = Infinity;
-	const err = new Error();
+	Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+	const error = new Error(); // eslint-disable-line unicorn/error-message
 	Error.stackTraceLimit = limitBefore;
-	return err;
+	return error;
 }
 
-function validateExpectations(assertion, expectations, numberArgs, experiments) { // eslint-disable-line complexity
+function validateExpectations(assertion, expectations, numberArgs) { // eslint-disable-line complexity
 	if (numberArgs === 1 || expectations === null || expectations === undefined) {
-		if (experiments.disableNullExpectations && expectations === null) {
+		if (expectations === null) {
 			throw new AssertionError({
 				assertion,
 				message: `The second argument to \`t.${assertion}()\` must be an expectation object or \`undefined\``,
-				values: [formatWithLabel('Called with:', expectations)]
+				values: [formatWithLabel('Called with:', expectations)],
 			});
 		}
 
 		expectations = {};
 	} else if (
-		typeof expectations === 'function' ||
-		typeof expectations === 'string' ||
-		expectations instanceof RegExp ||
-		typeof expectations !== 'object' ||
-		Array.isArray(expectations) ||
-		Object.keys(expectations).length === 0
+		typeof expectations === 'function'
+		|| typeof expectations === 'string'
+		|| expectations instanceof RegExp
+		|| typeof expectations !== 'object'
+		|| Array.isArray(expectations)
+		|| Object.keys(expectations).length === 0
 	) {
 		throw new AssertionError({
 			assertion,
 			message: `The second argument to \`t.${assertion}()\` must be an expectation object, \`null\` or \`undefined\``,
-			values: [formatWithLabel('Called with:', expectations)]
+			values: [formatWithLabel('Called with:', expectations)],
 		});
 	} else {
 		if (hasOwnProperty(expectations, 'instanceOf') && typeof expectations.instanceOf !== 'function') {
 			throw new AssertionError({
 				assertion,
 				message: `The \`instanceOf\` property of the second argument to \`t.${assertion}()\` must be a function`,
-				values: [formatWithLabel('Called with:', expectations)]
+				values: [formatWithLabel('Called with:', expectations)],
 			});
 		}
 
@@ -124,7 +110,7 @@ function validateExpectations(assertion, expectations, numberArgs, experiments)
 			throw new AssertionError({
 				assertion,
 				message: `The \`message\` property of the second argument to \`t.${assertion}()\` must be a string or regular expression`,
-				values: [formatWithLabel('Called with:', expectations)]
+				values: [formatWithLabel('Called with:', expectations)],
 			});
 		}
 
@@ -132,7 +118,7 @@ function validateExpectations(assertion, expectations, numberArgs, experiments)
 			throw new AssertionError({
 				assertion,
 				message: `The \`name\` property of the second argument to \`t.${assertion}()\` must be a string`,
-				values: [formatWithLabel('Called with:', expectations)]
+				values: [formatWithLabel('Called with:', expectations)],
 			});
 		}
 
@@ -140,7 +126,7 @@ function validateExpectations(assertion, expectations, numberArgs, experiments)
 			throw new AssertionError({
 				assertion,
 				message: `The \`code\` property of the second argument to \`t.${assertion}()\` must be a string or number`,
-				values: [formatWithLabel('Called with:', expectations)]
+				values: [formatWithLabel('Called with:', expectations)],
 			});
 		}
 
@@ -156,7 +142,7 @@ function validateExpectations(assertion, expectations, numberArgs, experiments)
 					throw new AssertionError({
 						assertion,
 						message: `The second argument to \`t.${assertion}()\` contains unexpected properties`,
-						values: [formatWithLabel('Called with:', expectations)]
+						values: [formatWithLabel('Called with:', expectations)],
 					});
 			}
 		}
@@ -173,7 +159,7 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 			assertion,
 			message,
 			savedError,
-			values: [formatWithLabel(`${prefix} exception that is not an error:`, actual)]
+			values: [formatWithLabel(`${prefix} exception that is not an error:`, actual)],
 		});
 	}
 
@@ -187,8 +173,8 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 			actualStack,
 			values: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
-				formatWithLabel('Expected to be strictly equal to:', expectations.is)
-			]
+				formatWithLabel('Expected to be strictly equal to:', expectations.is),
+			],
 		});
 	}
 
@@ -200,8 +186,8 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 			actualStack,
 			values: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
-				formatWithLabel('Expected instance of:', expectations.instanceOf)
-			]
+				formatWithLabel('Expected instance of:', expectations.instanceOf),
+			],
 		});
 	}
 
@@ -213,8 +199,8 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 			actualStack,
 			values: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
-				formatWithLabel('Expected name to equal:', expectations.name)
-			]
+				formatWithLabel('Expected name to equal:', expectations.name),
+			],
 		});
 	}
 
@@ -226,8 +212,8 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 			actualStack,
 			values: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
-				formatWithLabel('Expected message to equal:', expectations.message)
-			]
+				formatWithLabel('Expected message to equal:', expectations.message),
+			],
 		});
 	}
 
@@ -239,8 +225,8 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 			actualStack,
 			values: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
-				formatWithLabel('Expected message to match:', expectations.message)
-			]
+				formatWithLabel('Expected message to match:', expectations.message),
+			],
 		});
 	}
 
@@ -252,53 +238,31 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 			actualStack,
 			values: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
-				formatWithLabel('Expected code to equal:', expectations.code)
-			]
+				formatWithLabel('Expected code to equal:', expectations.code),
+			],
 		});
 	}
 }
 
-class Assertions {
+export class Assertions {
 	constructor({
 		pass = notImplemented,
 		pending = notImplemented,
 		fail = notImplemented,
 		skip = notImplemented,
 		compareWithSnapshot = notImplemented,
-		powerAssert,
 		experiments = {},
-		disableSnapshots = false
+		disableSnapshots = false,
 	} = {}) {
 		const withSkip = assertionFn => {
 			assertionFn.skip = skip;
 			return assertionFn;
 		};
 
-		// When adding new enhanced functions with new patterns, don't forget to
-		// enable the pattern in the power-assert compilation step in @ava/babel.
-		const withPowerAssert = (pattern, assertionFn) => powerAssert.empower(assertionFn, {
-			onError: event => {
-				if (event.powerAssertContext) {
-					event.error.statements = powerAssert.format(event.powerAssertContext, formatPowerAssertValue);
-				}
-
-				fail(event.error);
-			},
-			onSuccess: () => {
-				pass();
-			},
-			bindReceiver: false,
-			patterns: [pattern]
-		});
-
-		const checkMessage = (assertion, message, powerAssert = false) => {
+		const checkMessage = (assertion, message) => {
 			const result = checkAssertionMessage(assertion, message);
 			if (result === true) {
-				return this.true;
-			}
-
-			if (powerAssert) {
-				throw result;
+				return true;
 			}
 
 			fail(result);
@@ -307,52 +271,58 @@ class Assertions {
 
 		this.pass = withSkip(() => {
 			pass();
+			return true;
 		});
 
 		this.fail = withSkip(message => {
 			if (!checkMessage('fail', message)) {
-				return;
+				return false;
 			}
 
 			fail(new AssertionError({
 				assertion: 'fail',
-				message: message || 'Test failed via `t.fail()`'
+				message: message || 'Test failed via `t.fail()`',
 			}));
+
+			return false;
 		});
 
 		this.is = withSkip((actual, expected, message) => {
 			if (!checkMessage('is', message)) {
-				return;
+				return false;
 			}
 
 			if (Object.is(actual, expected)) {
 				pass();
-			} else {
-				const result = concordance.compare(actual, expected, concordanceOptions);
-				const actualDescriptor = result.actual || concordance.describe(actual, concordanceOptions);
-				const expectedDescriptor = result.expected || concordance.describe(expected, concordanceOptions);
+				return true;
+			}
 
-				if (result.pass) {
-					fail(new AssertionError({
-						assertion: 'is',
-						message,
-						raw: {actual, expected},
-						values: [formatDescriptorWithLabel('Values are deeply equal to each other, but they are not the same:', actualDescriptor)]
-					}));
-				} else {
-					fail(new AssertionError({
-						assertion: 'is',
-						message,
-						raw: {actual, expected},
-						values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)]
-					}));
-				}
+			const result = concordance.compare(actual, expected, concordanceOptions);
+			const actualDescriptor = result.actual || concordance.describe(actual, concordanceOptions);
+			const expectedDescriptor = result.expected || concordance.describe(expected, concordanceOptions);
+
+			if (result.pass) {
+				fail(new AssertionError({
+					assertion: 'is',
+					message,
+					raw: {actual, expected},
+					values: [formatDescriptorWithLabel('Values are deeply equal to each other, but they are not the same:', actualDescriptor)],
+				}));
+			} else {
+				fail(new AssertionError({
+					assertion: 'is',
+					message,
+					raw: {actual, expected},
+					values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)],
+				}));
 			}
+
+			return false;
 		});
 
 		this.not = withSkip((actual, expected, message) => {
 			if (!checkMessage('not', message)) {
-				return;
+				return false;
 			}
 
 			if (Object.is(actual, expected)) {
@@ -360,36 +330,40 @@ class Assertions {
 					assertion: 'not',
 					message,
 					raw: {actual, expected},
-					values: [formatWithLabel('Value is the same as:', actual)]
+					values: [formatWithLabel('Value is the same as:', actual)],
 				}));
-			} else {
-				pass();
+				return false;
 			}
+
+			pass();
+			return true;
 		});
 
 		this.deepEqual = withSkip((actual, expected, message) => {
 			if (!checkMessage('deepEqual', message)) {
-				return;
+				return false;
 			}
 
 			const result = concordance.compare(actual, expected, concordanceOptions);
 			if (result.pass) {
 				pass();
-			} else {
-				const actualDescriptor = result.actual || concordance.describe(actual, concordanceOptions);
-				const expectedDescriptor = result.expected || concordance.describe(expected, concordanceOptions);
-				fail(new AssertionError({
-					assertion: 'deepEqual',
-					message,
-					raw: {actual, expected},
-					values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)]
-				}));
+				return true;
 			}
+
+			const actualDescriptor = result.actual || concordance.describe(actual, concordanceOptions);
+			const expectedDescriptor = result.expected || concordance.describe(expected, concordanceOptions);
+			fail(new AssertionError({
+				assertion: 'deepEqual',
+				message,
+				raw: {actual, expected},
+				values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)],
+			}));
+			return false;
 		});
 
 		this.notDeepEqual = withSkip((actual, expected, message) => {
 			if (!checkMessage('notDeepEqual', message)) {
-				return;
+				return false;
 			}
 
 			const result = concordance.compare(actual, expected, concordanceOptions);
@@ -399,16 +373,18 @@ class Assertions {
 					assertion: 'notDeepEqual',
 					message,
 					raw: {actual, expected},
-					values: [formatDescriptorWithLabel('Value is deeply equal:', actualDescriptor)]
+					values: [formatDescriptorWithLabel('Value is deeply equal:', actualDescriptor)],
 				}));
-			} else {
-				pass();
+				return false;
 			}
+
+			pass();
+			return true;
 		});
 
 		this.like = withSkip((actual, selector, message) => {
 			if (!checkMessage('like', message)) {
-				return;
+				return false;
 			}
 
 			if (!isLikeSelector(selector)) {
@@ -416,9 +392,9 @@ class Assertions {
 					assertion: 'like',
 					improperUsage: true,
 					message: '`t.like()` selector must be a non-empty object',
-					values: [formatWithLabel('Called with:', selector)]
+					values: [formatWithLabel('Called with:', selector)],
 				}));
-				return;
+				return false;
 			}
 
 			let comparable;
@@ -430,9 +406,9 @@ class Assertions {
 						assertion: 'like',
 						improperUsage: true,
 						message: '`t.like()` selector must not contain circular references',
-						values: [formatWithLabel('Called with:', selector)]
+						values: [formatWithLabel('Called with:', selector)],
 					}));
-					return;
+					return false;
 				}
 
 				throw error;
@@ -441,15 +417,18 @@ class Assertions {
 			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)]
-				}));
+				return true;
 			}
+
+			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)],
+			}));
+
+			return false;
 		});
 
 		this.throws = withSkip((...args) => {
@@ -467,7 +446,7 @@ class Assertions {
 					assertion: 'throws',
 					improperUsage: true,
 					message: '`t.throws()` must be called with a function',
-					values: [formatWithLabel('Called with:', fn)]
+					values: [formatWithLabel('Called with:', fn)],
 				}));
 				return;
 			}
@@ -489,7 +468,7 @@ class Assertions {
 					fail(new AssertionError({
 						assertion: 'throws',
 						message,
-						values: [formatWithLabel('Function returned a promise. Use `t.throwsAsync()` instead:', retval)]
+						values: [formatWithLabel('Function returned a promise. Use `t.throwsAsync()` instead:', retval)],
 					}));
 					return;
 				}
@@ -501,7 +480,7 @@ class Assertions {
 				fail(new AssertionError({
 					assertion: 'throws',
 					message,
-					values: [formatWithLabel('Function returned:', retval)]
+					values: [formatWithLabel('Function returned:', retval)],
 				}));
 				return;
 			}
@@ -512,7 +491,7 @@ class Assertions {
 					actual,
 					expectations,
 					message,
-					prefix: 'Function threw'
+					prefix: 'Function threw',
 				});
 				pass();
 				return actual;
@@ -521,11 +500,11 @@ class Assertions {
 			}
 		});
 
-		this.throwsAsync = withSkip((...args) => {
+		this.throwsAsync = withSkip(async (...args) => {
 			let [thrower, expectations, message] = args;
 
 			if (!checkMessage('throwsAsync', message)) {
-				return Promise.resolve();
+				return;
 			}
 
 			if (typeof thrower !== 'function' && !isPromise(thrower)) {
@@ -533,28 +512,28 @@ class Assertions {
 					assertion: 'throwsAsync',
 					improperUsage: true,
 					message: '`t.throwsAsync()` must be called with a function or promise',
-					values: [formatWithLabel('Called with:', thrower)]
+					values: [formatWithLabel('Called with:', thrower)],
 				}));
-				return Promise.resolve();
+				return;
 			}
 
 			try {
 				expectations = validateExpectations('throwsAsync', expectations, args.length, experiments);
 			} catch (error) {
 				fail(error);
-				return Promise.resolve();
+				return;
 			}
 
-			const handlePromise = (promise, wasReturned) => {
+			const handlePromise = async (promise, wasReturned) => {
 				// Create an error object to record the stack before it gets lost in the promise chain.
 				const savedError = getErrorWithLongStackTrace();
 				// Handle "promise like" objects by casting to a real Promise.
-				const intermediate = Promise.resolve(promise).then(value => { // eslint-disable-line promise/prefer-await-to-then
+				const intermediate = Promise.resolve(promise).then(value => {
 					throw new AssertionError({
 						assertion: 'throwsAsync',
 						message,
 						savedError,
-						values: [formatWithLabel(`${wasReturned ? 'Returned promise' : 'Promise'} resolved with:`, value)]
+						values: [formatWithLabel(`${wasReturned ? 'Returned promise' : 'Promise'} resolved with:`, value)],
 					});
 				}, error => {
 					assertExpectations({
@@ -563,14 +542,17 @@ class Assertions {
 						expectations,
 						message,
 						prefix: `${wasReturned ? 'Returned promise' : 'Promise'} rejected with`,
-						savedError
+						savedError,
 					});
 					return error;
 				});
 
 				pending(intermediate);
-				// Don't reject the returned promise, even if the assertion fails.
-				return intermediate.catch(noop);
+				try {
+					return await intermediate;
+				} catch {
+					// Don't reject the returned promise, even if the assertion fails.
+				}
 			};
 
 			if (isPromise(thrower)) {
@@ -590,9 +572,9 @@ class Assertions {
 					assertion: 'throwsAsync',
 					message,
 					actualStack: actual.stack,
-					values: [formatWithLabel('Function threw synchronously. Use `t.throws()` instead:', actual)]
+					values: [formatWithLabel('Function threw synchronously. Use `t.throws()` instead:', actual)],
 				}));
-				return Promise.resolve();
+				return;
 			}
 
 			if (isPromise(retval)) {
@@ -602,9 +584,8 @@ class Assertions {
 			fail(new AssertionError({
 				assertion: 'throwsAsync',
 				message,
-				values: [formatWithLabel('Function returned:', retval)]
+				values: [formatWithLabel('Function returned:', retval)],
 			}));
-			return Promise.resolve();
 		});
 
 		this.notThrows = withSkip((fn, message) => {
@@ -617,7 +598,7 @@ class Assertions {
 					assertion: 'notThrows',
 					improperUsage: true,
 					message: '`t.notThrows()` must be called with a function',
-					values: [formatWithLabel('Called with:', fn)]
+					values: [formatWithLabel('Called with:', fn)],
 				}));
 				return;
 			}
@@ -629,7 +610,7 @@ class Assertions {
 					assertion: 'notThrows',
 					message,
 					actualStack: error.stack,
-					values: [formatWithLabel('Function threw:', error)]
+					values: [formatWithLabel('Function threw:', error)],
 				}));
 				return;
 			}
@@ -647,26 +628,30 @@ class Assertions {
 					assertion: 'notThrowsAsync',
 					improperUsage: true,
 					message: '`t.notThrowsAsync()` must be called with a function or promise',
-					values: [formatWithLabel('Called with:', nonThrower)]
+					values: [formatWithLabel('Called with:', nonThrower)],
 				}));
 				return Promise.resolve();
 			}
 
-			const handlePromise = (promise, wasReturned) => {
+			const handlePromise = async (promise, wasReturned) => {
 				// Create an error object to record the stack before it gets lost in the promise chain.
 				const savedError = getErrorWithLongStackTrace();
 				// Handle "promise like" objects by casting to a real Promise.
-				const intermediate = Promise.resolve(promise).then(noop, error => { // eslint-disable-line promise/prefer-await-to-then
+				const intermediate = Promise.resolve(promise).then(noop, error => {
 					throw new AssertionError({
 						assertion: 'notThrowsAsync',
 						message,
 						savedError,
-						values: [formatWithLabel(`${wasReturned ? 'Returned promise' : 'Promise'} rejected with:`, error)]
+						values: [formatWithLabel(`${wasReturned ? 'Returned promise' : 'Promise'} rejected with:`, error)],
 					});
 				});
 				pending(intermediate);
-				// Don't reject the returned promise, even if the assertion fails.
-				return intermediate.catch(noop);
+
+				try {
+					return await intermediate;
+				} catch {
+					// Don't reject the returned promise, even if the assertion fails.
+				}
 			};
 
 			if (isPromise(nonThrower)) {
@@ -681,7 +666,7 @@ class Assertions {
 					assertion: 'notThrowsAsync',
 					message,
 					actualStack: error.stack,
-					values: [formatWithLabel('Function threw:', error)]
+					values: [formatWithLabel('Function threw:', error)],
 				}));
 				return Promise.resolve();
 			}
@@ -690,7 +675,7 @@ class Assertions {
 				fail(new AssertionError({
 					assertion: 'notThrowsAsync',
 					message,
-					values: [formatWithLabel('Function did not return a promise. Use `t.notThrows()` instead:', retval)]
+					values: [formatWithLabel('Function did not return a promise. Use `t.notThrows()` instead:', retval)],
 				}));
 				return Promise.resolve();
 			}
@@ -698,47 +683,50 @@ class Assertions {
 			return handlePromise(retval, true);
 		});
 
-		this.snapshot = withSkip((expected, ...rest) => {
-			if (disableSnapshots && experiments.disableSnapshotsInHooks) {
+		this.snapshot = withSkip((expected, message) => {
+			if (disableSnapshots) {
 				fail(new AssertionError({
 					assertion: 'snapshot',
 					message: '`t.snapshot()` can only be used in tests',
-					improperUsage: true
+					improperUsage: true,
 				}));
-				return;
+				return false;
 			}
 
-			let message;
-			let snapshotOptions;
-			if (rest.length > 1) {
-				[snapshotOptions, message] = rest;
-			} else {
-				const [optionsOrMessage] = rest;
-				if (typeof optionsOrMessage === 'object') {
-					snapshotOptions = optionsOrMessage;
-				} else {
-					message = optionsOrMessage;
-				}
+			if (message && message.id !== undefined) {
+				fail(new AssertionError({
+					assertion: 'snapshot',
+					message: 'AVA 4 no longer supports snapshot IDs',
+					improperUsage: true,
+					values: [formatWithLabel('Called with id:', message.id)],
+				}));
+				return false;
 			}
 
 			if (!checkMessage('snapshot', message)) {
-				return;
+				return false;
+			}
+
+			if (message === '') {
+				fail(new AssertionError({
+					assertion: 'snapshot',
+					improperUsage: true,
+					message: 'The snapshot assertion message must be a non-empty string',
+					values: [formatWithLabel('Called with:', message)],
+				}));
+				return false;
 			}
 
 			let result;
 			try {
-				result = compareWithSnapshot({
-					expected,
-					id: snapshotOptions ? snapshotOptions.id : undefined,
-					message
-				});
+				result = compareWithSnapshot({expected, message});
 			} catch (error) {
-				if (!(error instanceof snapshotManager.SnapshotError)) {
+				if (!(error instanceof SnapshotError)) {
 					throw error;
 				}
 
 				const improperUsage = {name: error.name, snapPath: error.snapPath};
-				if (error instanceof snapshotManager.VersionMismatchError) {
+				if (error instanceof VersionMismatchError) {
 					improperUsage.snapVersion = error.snapVersion;
 					improperUsage.expectedVersion = error.expectedVersion;
 				}
@@ -746,48 +734,55 @@ class Assertions {
 				fail(new AssertionError({
 					assertion: 'snapshot',
 					message: message || 'Could not compare snapshot',
-					improperUsage
+					improperUsage,
 				}));
-				return;
+				return false;
 			}
 
 			if (result.pass) {
 				pass();
-			} else if (result.actual) {
+				return true;
+			}
+
+			if (result.actual) {
 				fail(new AssertionError({
 					assertion: 'snapshot',
 					message: message || 'Did not match snapshot',
-					values: [formatDescriptorDiff(result.actual, result.expected, {invert: true})]
+					values: [formatDescriptorDiff(result.actual, result.expected, {invert: true})],
 				}));
 			} else {
 				// This can only occur in CI environments.
 				fail(new AssertionError({
 					assertion: 'snapshot',
-					message: message || 'No snapshot available — new snapshots are not created in CI environments'
+					message: message || 'No snapshot available — new snapshots are not created in CI environments',
 				}));
 			}
+
+			return false;
 		});
 
 		this.truthy = withSkip((actual, message) => {
 			if (!checkMessage('truthy', message)) {
-				return;
+				return false;
 			}
 
 			if (actual) {
 				pass();
-			} else {
-				fail(new AssertionError({
-					assertion: 'truthy',
-					message,
-					operator: '!!',
-					values: [formatWithLabel('Value is not truthy:', actual)]
-				}));
+				return true;
 			}
+
+			fail(new AssertionError({
+				assertion: 'truthy',
+				message,
+				operator: '!!',
+				values: [formatWithLabel('Value is not truthy:', actual)],
+			}));
+			return false;
 		});
 
 		this.falsy = withSkip((actual, message) => {
 			if (!checkMessage('falsy', message)) {
-				return;
+				return false;
 			}
 
 			if (actual) {
@@ -795,48 +790,54 @@ class Assertions {
 					assertion: 'falsy',
 					message,
 					operator: '!',
-					values: [formatWithLabel('Value is not falsy:', actual)]
+					values: [formatWithLabel('Value is not falsy:', actual)],
 				}));
-			} else {
-				pass();
+				return false;
 			}
+
+			pass();
+			return true;
 		});
 
 		this.true = withSkip((actual, message) => {
 			if (!checkMessage('true', message)) {
-				return;
+				return false;
 			}
 
 			if (actual === true) {
 				pass();
-			} else {
-				fail(new AssertionError({
-					assertion: 'true',
-					message,
-					values: [formatWithLabel('Value is not `true`:', actual)]
-				}));
+				return true;
 			}
+
+			fail(new AssertionError({
+				assertion: 'true',
+				message,
+				values: [formatWithLabel('Value is not `true`:', actual)],
+			}));
+			return false;
 		});
 
 		this.false = withSkip((actual, message) => {
 			if (!checkMessage('false', message)) {
-				return;
+				return false;
 			}
 
 			if (actual === false) {
 				pass();
-			} else {
-				fail(new AssertionError({
-					assertion: 'false',
-					message,
-					values: [formatWithLabel('Value is not `false`:', actual)]
-				}));
+				return true;
 			}
+
+			fail(new AssertionError({
+				assertion: 'false',
+				message,
+				values: [formatWithLabel('Value is not `false`:', actual)],
+			}));
+			return false;
 		});
 
 		this.regex = withSkip((string, regex, message) => {
 			if (!checkMessage('regex', message)) {
-				return;
+				return false;
 			}
 
 			if (typeof string !== 'string') {
@@ -844,9 +845,9 @@ class Assertions {
 					assertion: 'regex',
 					improperUsage: true,
 					message: '`t.regex()` must be called with a string',
-					values: [formatWithLabel('Called with:', string)]
+					values: [formatWithLabel('Called with:', string)],
 				}));
-				return;
+				return false;
 			}
 
 			if (!(regex instanceof RegExp)) {
@@ -854,9 +855,9 @@ class Assertions {
 					assertion: 'regex',
 					improperUsage: true,
 					message: '`t.regex()` must be called with a regular expression',
-					values: [formatWithLabel('Called with:', regex)]
+					values: [formatWithLabel('Called with:', regex)],
 				}));
-				return;
+				return false;
 			}
 
 			if (!regex.test(string)) {
@@ -865,18 +866,19 @@ class Assertions {
 					message,
 					values: [
 						formatWithLabel('Value must match expression:', string),
-						formatWithLabel('Regular expression:', regex)
-					]
+						formatWithLabel('Regular expression:', regex),
+					],
 				}));
-				return;
+				return false;
 			}
 
 			pass();
+			return true;
 		});
 
 		this.notRegex = withSkip((string, regex, message) => {
 			if (!checkMessage('notRegex', message)) {
-				return;
+				return false;
 			}
 
 			if (typeof string !== 'string') {
@@ -884,9 +886,9 @@ class Assertions {
 					assertion: 'notRegex',
 					improperUsage: true,
 					message: '`t.notRegex()` must be called with a string',
-					values: [formatWithLabel('Called with:', string)]
+					values: [formatWithLabel('Called with:', string)],
 				}));
-				return;
+				return false;
 			}
 
 			if (!(regex instanceof RegExp)) {
@@ -894,9 +896,9 @@ class Assertions {
 					assertion: 'notRegex',
 					improperUsage: true,
 					message: '`t.notRegex()` must be called with a regular expression',
-					values: [formatWithLabel('Called with:', regex)]
+					values: [formatWithLabel('Called with:', regex)],
 				}));
-				return;
+				return false;
 			}
 
 			if (regex.test(string)) {
@@ -905,50 +907,33 @@ class Assertions {
 					message,
 					values: [
 						formatWithLabel('Value must not match expression:', string),
-						formatWithLabel('Regular expression:', regex)
-					]
+						formatWithLabel('Regular expression:', regex),
+					],
 				}));
-				return;
+				return false;
 			}
 
 			pass();
+			return true;
 		});
 
-		if (powerAssert === undefined) {
-			this.assert = withSkip((actual, message) => {
-				if (!checkMessage('assert', message)) {
-					return;
-				}
+		this.assert = withSkip((actual, message) => {
+			if (!checkMessage('assert', message)) {
+				return false;
+			}
 
-				if (!actual) {
-					fail(new AssertionError({
-						assertion: 'assert',
-						message,
-						operator: '!!',
-						values: [formatWithLabel('Value is not truthy:', actual)]
-					}));
-					return;
-				}
+			if (!actual) {
+				fail(new AssertionError({
+					assertion: 'assert',
+					message,
+					operator: '!!',
+					values: [formatWithLabel('Value is not truthy:', actual)],
+				}));
+				return false;
+			}
 
-				pass();
-			});
-		} else {
-			this.assert = withSkip(withPowerAssert(
-				'assert(value, [message])',
-				(actual, message) => {
-					checkMessage('assert', message, true);
-
-					if (!actual) {
-						throw new AssertionError({
-							assertion: 'assert',
-							message,
-							operator: '!!',
-							values: [formatWithLabel('Value is not truthy:', actual)]
-						});
-					}
-				})
-			);
-		}
+			pass();
+			return true;
+		});
 	}
 }
-exports.Assertions = Assertions;