ava 4.0.0-alpha.1 → 4.0.1

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,12 +61,10 @@ 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 = Number.POSITIVE_INFINITY;
@@ -93,30 +79,30 @@ function validateExpectations(assertion, expectations, numberArgs) { // eslint-d
 			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) { // eslint-d
 			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) { // eslint-d
 			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) { // eslint-d
 			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) { // eslint-d
 					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,57 +238,33 @@ 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);
-				return false;
-			},
-			onSuccess: () => {
-				pass();
-				return true;
-			},
-			bindReceiver: false,
-			patterns: [pattern]
-		});
-
-		const checkMessage = (assertion, message, powerAssert = false) => {
+		const checkMessage = (assertion, message) => {
 			const result = checkAssertionMessage(assertion, message);
 			if (result === true) {
 				return true;
 			}
 
-			if (powerAssert) {
-				throw result;
-			}
-
 			fail(result);
 			return false;
 		};
@@ -319,7 +281,7 @@ class Assertions {
 
 			fail(new AssertionError({
 				assertion: 'fail',
-				message: message || 'Test failed via `t.fail()`'
+				message: message || 'Test failed via `t.fail()`',
 			}));
 
 			return false;
@@ -344,14 +306,14 @@ class Assertions {
 					assertion: 'is',
 					message,
 					raw: {actual, expected},
-					values: [formatDescriptorWithLabel('Values are deeply equal to each other, but they are not the same:', actualDescriptor)]
+					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)]
+					values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)],
 				}));
 			}
 
@@ -368,7 +330,7 @@ class Assertions {
 					assertion: 'not',
 					message,
 					raw: {actual, expected},
-					values: [formatWithLabel('Value is the same as:', actual)]
+					values: [formatWithLabel('Value is the same as:', actual)],
 				}));
 				return false;
 			}
@@ -394,7 +356,7 @@ class Assertions {
 				assertion: 'deepEqual',
 				message,
 				raw: {actual, expected},
-				values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)]
+				values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)],
 			}));
 			return false;
 		});
@@ -411,7 +373,7 @@ class Assertions {
 					assertion: 'notDeepEqual',
 					message,
 					raw: {actual, expected},
-					values: [formatDescriptorWithLabel('Value is deeply equal:', actualDescriptor)]
+					values: [formatDescriptorWithLabel('Value is deeply equal:', actualDescriptor)],
 				}));
 				return false;
 			}
@@ -430,7 +392,7 @@ 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 false;
 			}
@@ -444,7 +406,7 @@ 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 false;
 				}
@@ -463,7 +425,7 @@ class Assertions {
 			fail(new AssertionError({
 				assertion: 'like',
 				message,
-				values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)]
+				values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)],
 			}));
 
 			return false;
@@ -484,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;
 			}
@@ -506,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;
 				}
@@ -518,7 +480,7 @@ class Assertions {
 				fail(new AssertionError({
 					assertion: 'throws',
 					message,
-					values: [formatWithLabel('Function returned:', retval)]
+					values: [formatWithLabel('Function returned:', retval)],
 				}));
 				return;
 			}
@@ -529,7 +491,7 @@ class Assertions {
 					actual,
 					expectations,
 					message,
-					prefix: 'Function threw'
+					prefix: 'Function threw',
 				});
 				pass();
 				return actual;
@@ -538,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)) {
@@ -550,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({
@@ -580,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)) {
@@ -607,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)) {
@@ -619,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) => {
@@ -634,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;
 			}
@@ -646,7 +610,7 @@ class Assertions {
 					assertion: 'notThrows',
 					message,
 					actualStack: error.stack,
-					values: [formatWithLabel('Function threw:', error)]
+					values: [formatWithLabel('Function threw:', error)],
 				}));
 				return;
 			}
@@ -664,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)) {
@@ -698,7 +666,7 @@ class Assertions {
 					assertion: 'notThrowsAsync',
 					message,
 					actualStack: error.stack,
-					values: [formatWithLabel('Function threw:', error)]
+					values: [formatWithLabel('Function threw:', error)],
 				}));
 				return Promise.resolve();
 			}
@@ -707,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();
 			}
@@ -720,7 +688,7 @@ class Assertions {
 				fail(new AssertionError({
 					assertion: 'snapshot',
 					message: '`t.snapshot()` can only be used in tests',
-					improperUsage: true
+					improperUsage: true,
 				}));
 				return false;
 			}
@@ -730,7 +698,7 @@ class Assertions {
 					assertion: 'snapshot',
 					message: 'AVA 4 no longer supports snapshot IDs',
 					improperUsage: true,
-					values: [formatWithLabel('Called with id:', message.id)]
+					values: [formatWithLabel('Called with id:', message.id)],
 				}));
 				return false;
 			}
@@ -744,7 +712,7 @@ class Assertions {
 					assertion: 'snapshot',
 					improperUsage: true,
 					message: 'The snapshot assertion message must be a non-empty string',
-					values: [formatWithLabel('Called with:', message)]
+					values: [formatWithLabel('Called with:', message)],
 				}));
 				return false;
 			}
@@ -753,12 +721,12 @@ class Assertions {
 			try {
 				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;
 				}
@@ -766,7 +734,7 @@ class Assertions {
 				fail(new AssertionError({
 					assertion: 'snapshot',
 					message: message || 'Could not compare snapshot',
-					improperUsage
+					improperUsage,
 				}));
 				return false;
 			}
@@ -780,13 +748,13 @@ class Assertions {
 				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',
 				}));
 			}
 
@@ -807,7 +775,7 @@ class Assertions {
 				assertion: 'truthy',
 				message,
 				operator: '!!',
-				values: [formatWithLabel('Value is not truthy:', actual)]
+				values: [formatWithLabel('Value is not truthy:', actual)],
 			}));
 			return false;
 		});
@@ -822,7 +790,7 @@ class Assertions {
 					assertion: 'falsy',
 					message,
 					operator: '!',
-					values: [formatWithLabel('Value is not falsy:', actual)]
+					values: [formatWithLabel('Value is not falsy:', actual)],
 				}));
 				return false;
 			}
@@ -844,7 +812,7 @@ class Assertions {
 			fail(new AssertionError({
 				assertion: 'true',
 				message,
-				values: [formatWithLabel('Value is not `true`:', actual)]
+				values: [formatWithLabel('Value is not `true`:', actual)],
 			}));
 			return false;
 		});
@@ -862,7 +830,7 @@ class Assertions {
 			fail(new AssertionError({
 				assertion: 'false',
 				message,
-				values: [formatWithLabel('Value is not `false`:', actual)]
+				values: [formatWithLabel('Value is not `false`:', actual)],
 			}));
 			return false;
 		});
@@ -877,7 +845,7 @@ 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 false;
 			}
@@ -887,7 +855,7 @@ 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 false;
 			}
@@ -898,8 +866,8 @@ class Assertions {
 					message,
 					values: [
 						formatWithLabel('Value must match expression:', string),
-						formatWithLabel('Regular expression:', regex)
-					]
+						formatWithLabel('Regular expression:', regex),
+					],
 				}));
 				return false;
 			}
@@ -918,7 +886,7 @@ 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 false;
 			}
@@ -928,7 +896,7 @@ 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 false;
 			}
@@ -939,8 +907,8 @@ class Assertions {
 					message,
 					values: [
 						formatWithLabel('Value must not match expression:', string),
-						formatWithLabel('Regular expression:', regex)
-					]
+						formatWithLabel('Regular expression:', regex),
+					],
 				}));
 				return false;
 			}
@@ -949,42 +917,23 @@ class Assertions {
 			return true;
 		});
 
-		if (powerAssert === undefined) {
-			this.assert = withSkip((actual, message) => {
-				if (!checkMessage('assert', message)) {
-					return false;
-				}
+		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 false;
-				}
+			if (!actual) {
+				fail(new AssertionError({
+					assertion: 'assert',
+					message,
+					operator: '!!',
+					values: [formatWithLabel('Value is not truthy:', actual)],
+				}));
+				return false;
+			}
 
-				pass();
-				return true;
-			});
-		} 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;