ava 5.3.1 → 6.0.1

package/lib/serialize-error.js

@@ -1,10 +1,8 @@
 import path from 'node:path';
-import process from 'node:process';
-import {fileURLToPath, pathToFileURL} from 'node:url';
+import {pathToFileURL} from 'node:url';
+import {isNativeError} from 'node:util/types';
 
-import cleanYamlObject from 'clean-yaml-object';
 import concordance from 'concordance';
-import isError from 'is-error';
 import StackUtils from 'stack-utils';
 
 import {AssertionError} from './assert.js';
@@ -14,10 +12,6 @@ function isAvaAssertionError(source) {
 	return source instanceof AssertionError;
 }
 
-function filter(propertyName, isRoot) {
-	return !isRoot || (propertyName !== 'message' && propertyName !== 'name' && propertyName !== 'stack');
-}
-
 function normalizeFile(file, ...base) {
 	return file.startsWith('file://') ? file : pathToFileURL(path.resolve(...base, file)).toString();
 }
@@ -45,126 +39,60 @@ function extractSource(stack, testFile) {
 	return null;
 }
 
-function buildSource(source) {
-	if (!source) {
-		return null;
+const workerErrors = new WeakSet();
+export function tagWorkerError(error) {
+	// Track worker errors, which aren't native due to https://github.com/nodejs/node/issues/48716.
+	// Still include the check for isNativeError() in case the issue is fixed in the future.
+	if (isNativeError(error) || error instanceof Error) {
+		workerErrors.add(error);
 	}
 
-	// Assume the CWD is the project directory. This holds since this function
-	// is only called in test workers, which are created with their working
-	// directory set to the project directory.
-	const projectDir = process.cwd();
-
-	const file = normalizeFile(source.file.trim(), projectDir);
-	const rel = path.relative(projectDir, fileURLToPath(file));
-
-	const [segment] = rel.split(path.sep);
-	const isWithinProject = segment !== '..' && (process.platform !== 'win32' || !segment.includes(':'));
-	const isDependency = isWithinProject && path.dirname(rel).split(path.sep).includes('node_modules');
-
-	return {
-		isDependency,
-		isWithinProject,
-		file,
-		line: source.line,
-	};
+	return error;
 }
 
-function trySerializeError(error, shouldBeautifyStack, testFile) {
-	const stack = error.savedError ? error.savedError.stack : error.stack;
+const isWorkerError = error => workerErrors.has(error);
 
-	const retval = {
-		avaAssertionError: isAvaAssertionError(error),
-		nonErrorObject: false,
-		source: extractSource(stack, testFile),
-		stack,
-		shouldBeautifyStack,
-	};
-
-	if (error.actualStack) {
-		retval.stack = error.actualStack;
+export default function serializeError(error, {testFile = null} = {}) {
+	if (!isNativeError(error) && !isWorkerError(error)) {
+		return {
+			type: 'unknown',
+			originalError: error, // Note that the main process receives a structured clone.
+			formattedError: concordance.formatDescriptor(concordance.describe(error, concordanceOptions), concordanceOptions),
+		};
 	}
 
-	if (retval.avaAssertionError) {
-		retval.improperUsage = error.improperUsage;
-		retval.message = error.message;
-		retval.name = error.name;
-		retval.values = error.values;
-
-		if (error.fixedSource) {
-			const source = buildSource(error.fixedSource);
-			if (source) {
-				retval.source = source;
-			}
-		}
-
-		if (error.assertion) {
-			retval.assertion = error.assertion;
-		}
-
-		if (error.operator) {
-			retval.operator = error.operator;
-		}
-	} else {
-		retval.object = cleanYamlObject(error, filter); // Cleanly copy non-standard properties
-		if (typeof error.message === 'string') {
-			retval.message = error.message;
-		}
+	const {message, name, stack} = error;
+	const base = {
+		message,
+		name,
+		originalError: error, // Note that the main process receives a structured clone.
+		stack,
+	};
 
-		if (typeof error.name === 'string') {
-			retval.name = error.name;
+	if (!isAvaAssertionError(error)) {
+		if (name === 'AggregateError') {
+			return {
+				...base,
+				type: 'aggregate',
+				errors: error.errors.map(error => serializeError(error, {testFile})),
+			};
 		}
-	}
 
-	if (typeof error.stack === 'string') {
-		const lines = error.stack.split('\n');
-		if (error.name === 'SyntaxError' && !lines[0].startsWith('SyntaxError')) {
-			retval.summary = '';
-			for (const line of lines) {
-				retval.summary += line + '\n';
-				if (line.startsWith('SyntaxError')) {
-					break;
-				}
-			}
-
-			retval.summary = retval.summary.trim();
-		} else {
-			retval.summary = '';
-			for (let index = 0; index < lines.length; index++) {
-				if (lines[index].startsWith('    at')) {
-					break;
-				}
-
-				const next = index + 1;
-				const end = next === lines.length || lines[next].startsWith('    at');
-				retval.summary += end ? lines[index] : lines[index] + '\n';
-			}
-		}
-	}
-
-	return retval;
-}
-
-export default function serializeError(origin, shouldBeautifyStack, error, testFile) {
-	if (!isError(error)) {
 		return {
-			avaAssertionError: false,
-			nonErrorObject: true,
-			formatted: concordance.formatDescriptor(concordance.describe(error, concordanceOptions), concordanceOptions),
+			...base,
+			type: 'native',
+			source: extractSource(error.stack, testFile),
 		};
 	}
 
-	try {
-		return trySerializeError(error, shouldBeautifyStack, testFile);
-	} catch {
-		const replacement = new Error(`${origin}: Could not serialize error`);
-		return {
-			avaAssertionError: false,
-			nonErrorObject: false,
-			name: replacement.name,
-			message: replacement.message,
-			stack: replacement.stack,
-			summary: replacement.message,
-		};
-	}
+	return {
+		...base,
+		type: 'ava',
+		assertion: error.assertion,
+		improperUsage: error.improperUsage,
+		formattedCause: error.cause ? concordance.formatDescriptor(concordance.describe(error.cause, concordanceOptions), concordanceOptions) : null,
+		formattedDetails: error.formattedDetails,
+		source: extractSource(error.assertionStack, testFile),
+		stack: isNativeError(error.cause) ? error.cause.stack : error.assertionStack,
+	};
 }

package/lib/slash.cjs

@@ -30,7 +30,7 @@ function slash(path) {
 		return path;
 	}
 
-	return path.replace(/\\/g, '/');
+	return path.replaceAll('\\', '/');
 }
 
 module.exports = slash;

package/lib/snapshot-manager.js

@@ -9,7 +9,7 @@ import zlib from 'node:zlib';
 import cbor from 'cbor';
 import concordance from 'concordance';
 import indentString from 'indent-string';
-import mem from 'mem';
+import memoize from 'memoize';
 import writeFileAtomic from 'write-file-atomic';
 
 import {snapshotManager as concordanceOptions} from './concordance-options.js';
@@ -104,7 +104,7 @@ function combineEntries({blocks}) {
 	const combined = new BufferBuilder();
 
 	for (const {title, snapshots} of blocks) {
-		const last = snapshots[snapshots.length - 1];
+		const last = snapshots.at(-1);
 		combined.write(`\n\n## ${title}\n\n`);
 
 		for (const [index, snapshot] of snapshots.entries()) {
@@ -198,7 +198,7 @@ async function encodeSnapshots(snapshotData) {
 	], READABLE_PREFIX.byteLength + VERSION_HEADER.byteLength + SHA_256_HASH_LENGTH + compressed.byteLength);
 }
 
-function decodeSnapshots(buffer, snapPath) {
+export function extractCompressedSnapshot(buffer, snapPath) {
 	if (isLegacySnapshot(buffer)) {
 		throw new LegacyError(snapPath);
 	}
@@ -220,6 +220,12 @@ function decodeSnapshots(buffer, snapPath) {
 	const compressedOffset = sha256sumOffset + SHA_256_HASH_LENGTH;
 	const compressed = buffer.slice(compressedOffset);
 
+	return {version, compressed, sha256sumOffset, compressedOffset};
+}
+
+function decodeSnapshots(buffer, snapPath) {
+	const {compressed, sha256sumOffset, compressedOffset} = extractCompressedSnapshot(buffer, snapPath);
+
 	const sha256sum = crypto.createHash('sha256').update(compressed).digest();
 	const expectedSum = buffer.slice(sha256sumOffset, compressedOffset);
 	if (!sha256sum.equals(expectedSum)) {
@@ -259,8 +265,8 @@ class Manager {
 
 		const block = this.newBlocksByTitle.get(options.belongsTo);
 
-		const snapshot = block && block.snapshots[options.index];
-		const data = snapshot && snapshot.data;
+		const snapshot = block?.snapshots[options.index];
+		const data = snapshot?.data;
 
 		if (!data) {
 			if (!this.recordNewSnapshots) {
@@ -332,7 +338,7 @@ class Manager {
 
 	skipSnapshot({belongsTo, index, deferRecording}) {
 		const oldBlock = this.oldBlocksByTitle.get(belongsTo);
-		let snapshot = oldBlock && oldBlock.snapshots[index];
+		let snapshot = oldBlock?.snapshots[index];
 
 		if (!snapshot) {
 			snapshot = {};
@@ -389,7 +395,7 @@ class Manager {
 	}
 }
 
-const resolveSourceFile = mem(file => {
+const resolveSourceFile = memoize(file => {
 	const sourceMap = findSourceMap(file);
 	// Prior to Node.js 18.8.0, the value when a source map could not be found was `undefined`.
 	// This changed to `null` in <https://github.com/nodejs/node/pull/43875>. Check both.
@@ -407,7 +413,7 @@ const resolveSourceFile = mem(file => {
 		: payload.sources[0];
 });
 
-export const determineSnapshotDir = mem(({file, fixedLocation, projectDir}) => {
+export const determineSnapshotDir = memoize(({file, fixedLocation, projectDir}) => {
 	const testDir = path.dirname(resolveSourceFile(file));
 	if (fixedLocation) {
 		const relativeTestLocation = path.relative(projectDir, testDir);

package/lib/test.js

@@ -2,25 +2,23 @@ import concordance from 'concordance';
 import isPromise from 'is-promise';
 import plur from 'plur';
 
-import {AssertionError, Assertions, checkAssertionMessage} from './assert.js';
+import {AssertionError, Assertions, checkAssertionMessage, getAssertionStack} from './assert.js';
 import concordanceOptions from './concordance-options.js';
 import nowAndTimers from './now-and-timers.cjs';
 import parseTestArgs from './parse-test-args.js';
 
-const hasOwnProperty = (object, prop) => Object.prototype.hasOwnProperty.call(object, prop);
-
 function isExternalAssertError(error) {
 	if (typeof error !== 'object' || error === null) {
 		return false;
 	}
 
 	// Match errors thrown by <https://www.npmjs.com/package/expect>.
-	if (hasOwnProperty(error, 'matcherResult')) {
+	if (Object.hasOwn(error, 'matcherResult')) {
 		return true;
 	}
 
 	// Match errors thrown by <https://www.npmjs.com/package/chai> and <https://nodejs.org/api/assert.html>.
-	return hasOwnProperty(error, 'actual') && hasOwnProperty(error, 'expected');
+	return Object.hasOwn(error, 'actual') && Object.hasOwn(error, 'expected');
 }
 
 function formatErrorValue(label, error) {
@@ -28,13 +26,12 @@ function formatErrorValue(label, error) {
 	return {label, formatted};
 }
 
-const captureSavedError = () => {
-	const limitBefore = Error.stackTraceLimit;
-	Error.stackTraceLimit = 1;
-	const error = new Error(); // eslint-disable-line unicorn/error-message
-	Error.stackTraceLimit = limitBefore;
-	return error;
-};
+class TestFailure extends Error {
+	constructor() {
+		super('The test has failed');
+		this.name = 'TestFailure';
+	}
+}
 
 const testMap = new WeakMap();
 class ExecutionContext extends Assertions {
@@ -42,12 +39,16 @@ class ExecutionContext extends Assertions {
 		super({
 			pass() {
 				test.countPassedAssertion();
+				return true;
 			},
 			pending(promise) {
 				test.addPendingAssertion(promise);
 			},
 			fail(error) {
-				test.addFailedAssertion(error);
+				return test.addFailedAssertion(error);
+			},
+			failPending(error) {
+				return test.failPendingAssertion(error);
 			},
 			skip() {
 				test.countPassedAssertion();
@@ -72,7 +73,7 @@ class ExecutionContext extends Assertions {
 		};
 
 		this.plan = count => {
-			test.plan(count, captureSavedError());
+			test.plan(count, getAssertionStack());
 		};
 
 		this.plan.skip = () => {};
@@ -81,6 +82,10 @@ class ExecutionContext extends Assertions {
 			test.timeout(ms, message);
 		};
 
+		this.timeout.clear = () => {
+			test.clearTimeout();
+		};
+
 		this.teardown = callback => {
 			test.addTeardown(callback);
 		};
@@ -132,7 +137,7 @@ class ExecutionContext extends Assertions {
 
 					if (discarded) {
 						test.saveFirstError(new Error('Can’t commit a result that was previously discarded'));
-						return;
+						throw this.testFailure;
 					}
 
 					committed = true;
@@ -151,7 +156,7 @@ class ExecutionContext extends Assertions {
 				discard({retainLogs = false} = {}) {
 					if (committed) {
 						test.saveFirstError(new Error('Can’t discard a result that was previously committed'));
-						return;
+						throw this.testFailure;
 					}
 
 					if (discarded) {
@@ -196,7 +201,7 @@ class ExecutionContext extends Assertions {
 export default class Test {
 	constructor(options) {
 		this.contextRef = options.contextRef;
-		this.experiments = options.experiments || {};
+		this.experiments = options.experiments ?? {};
 		this.failWithoutAssertions = options.failWithoutAssertions;
 		this.fn = options.fn;
 		this.isHook = options.isHook === true;
@@ -280,7 +285,7 @@ export default class Test {
 		};
 
 		this.assertCount = 0;
-		this.assertError = undefined;
+		this.assertError = null;
 		this.attemptCount = 0;
 		this.calledEnd = false;
 		this.duration = null;
@@ -291,7 +296,7 @@ export default class Test {
 		this.pendingAttemptCount = 0;
 		this.planCount = null;
 		this.startedAt = 0;
-		this.timeoutMs = 0;
+		this.testFailure = null;
 		this.timeoutTimer = null;
 	}
 
@@ -316,7 +321,7 @@ export default class Test {
 		this.logs.push(text);
 	}
 
-	addPendingAssertion(promise) {
+	async addPendingAssertion(promise) {
 		if (this.finishing) {
 			this.saveFirstError(new Error('Assertion started, but test has already finished'));
 		}
@@ -329,12 +334,14 @@ export default class Test {
 		this.pendingAssertionCount++;
 		this.refreshTimeout();
 
-		promise
-			.catch(error => this.saveFirstError(error))
-			.then(() => {
-				this.pendingAssertionCount--;
-				this.refreshTimeout();
-			});
+		try {
+			await promise;
+		} catch {
+			// Ignore errors.
+		} finally {
+			this.pendingAssertionCount--;
+			this.refreshTimeout();
+		}
 	}
 
 	addFailedAssertion(error) {
@@ -349,6 +356,12 @@ export default class Test {
 		this.assertCount++;
 		this.refreshTimeout();
 		this.saveFirstError(error);
+		return this.testFailure;
+	}
+
+	failPendingAssertion(error) {
+		this.saveFirstError(error);
+		return this.testFailure;
 	}
 
 	finishAttempt({commit, deferredSnapshotRecordings, errors, logs, passed, retainLogs, snapshotCount, startingSnapshotCount}) {
@@ -387,15 +400,17 @@ export default class Test {
 		}
 
 		this.refreshTimeout();
+		if (this.testFailure) {
+			throw this.testFailure;
+		}
 	}
 
 	saveFirstError(error) {
-		if (!this.assertError) {
-			this.assertError = error;
-		}
+		this.assertError ??= error;
+		this.testFailure = new TestFailure();
 	}
 
-	plan(count, planError) {
+	plan(count, planAssertionStack) {
 		if (typeof count !== 'number') {
 			throw new TypeError('Expected a number');
 		}
@@ -404,11 +419,11 @@ export default class Test {
 
 		// In case the `planCount` doesn't match `assertCount, we need the stack of
 		// this function to throw with a useful stack.
-		this.planError = planError;
+		this.planAssertionStack = planAssertionStack;
 	}
 
 	timeout(ms, message) {
-		const result = checkAssertionMessage('timeout', message);
+		const result = checkAssertionMessage(message, 't.timeout()');
 		if (result !== true) {
 			this.saveFirstError(result);
 			// Allow the timeout to be set even when the message is invalid.
@@ -420,28 +435,19 @@ export default class Test {
 		}
 
 		this.clearTimeout();
-		this.timeoutMs = ms;
 		this.timeoutTimer = nowAndTimers.setCappedTimeout(() => {
-			this.saveFirstError(new Error(message || 'Test timeout exceeded'));
+			this.saveFirstError(new Error(message ?? 'Test timeout exceeded'));
 
 			if (this.finishDueToTimeout) {
 				this.finishDueToTimeout();
 			}
 		}, ms);
 
-		this.notifyTimeoutUpdate(this.timeoutMs);
+		this.notifyTimeoutUpdate(ms);
 	}
 
 	refreshTimeout() {
-		if (!this.timeoutTimer) {
-			return;
-		}
-
-		if (this.timeoutTimer.refresh) {
-			this.timeoutTimer.refresh();
-		} else {
-			this.timeout(this.timeoutMs);
-		}
+		this.timeoutTimer?.refresh();
 	}
 
 	clearTimeout() {
@@ -481,11 +487,9 @@ export default class Test {
 
 	verifyPlan() {
 		if (!this.assertError && this.planCount !== null && this.planCount !== this.assertCount) {
-			this.saveFirstError(new AssertionError({
-				assertion: 'plan',
-				message: `Planned for ${this.planCount} ${plur('assertion', this.planCount)}, but got ${this.assertCount}.`,
-				operator: '===',
-				savedError: this.planError,
+			this.saveFirstError(new AssertionError(`Planned for ${this.planCount} ${plur('assertion', this.planCount)}, but got ${this.assertCount}.`, {
+				assertion: 't.plan()',
+				assertionStack: this.planAssertionStack,
 			}));
 		}
 	}
@@ -518,54 +522,53 @@ export default class Test {
 
 	callFn() {
 		try {
-			return {
-				ok: true,
-				retval: this.fn.call(null, this.createExecutionContext()),
-			};
+			return [true, this.fn.call(null, this.createExecutionContext())];
 		} catch (error) {
-			return {
-				ok: false,
-				error,
-			};
+			return [false, error];
 		}
 	}
 
 	run() {
 		this.startedAt = nowAndTimers.now();
 
-		const result = this.callFn();
-		if (!result.ok) {
-			if (isExternalAssertError(result.error)) {
-				this.saveFirstError(new AssertionError({
-					message: 'Assertion failed',
-					savedError: result.error instanceof Error && result.error,
-					values: [{label: 'Assertion failed: ', formatted: result.error.message}],
+		const [syncOk, retval] = this.callFn();
+		if (!syncOk) {
+			if (this.testFailure !== null && retval === this.testFailure) {
+				return this.finish();
+			}
+
+			if (isExternalAssertError(retval)) {
+				this.saveFirstError(new AssertionError('Assertion failed', {
+					cause: retval,
+					formattedDetails: [{label: 'Assertion failed: ', formatted: retval.message}],
 				}));
 			} else {
-				this.saveFirstError(new AssertionError({
-					message: 'Error thrown in test',
-					savedError: result.error instanceof Error && result.error,
-					values: [formatErrorValue('Error thrown in test:', result.error)],
+				this.saveFirstError(new AssertionError('Error thrown in test', {
+					// TODO: Provide an assertion stack that traces to the test declaration,
+					// rather than AVA internals.
+					assertionStack: '',
+					cause: retval,
+					formattedDetails: [formatErrorValue('Error thrown in test:', retval)],
 				}));
 			}
 
 			return this.finish();
 		}
 
-		const returnedObservable = result.retval !== null && typeof result.retval === 'object' && typeof result.retval.subscribe === 'function';
-		const returnedPromise = isPromise(result.retval);
+		const returnedObservable = retval !== null && typeof retval === 'object' && typeof retval.subscribe === 'function';
+		const returnedPromise = isPromise(retval);
 
 		let promise;
 		if (returnedObservable) {
 			promise = new Promise((resolve, reject) => {
-				result.retval.subscribe({
+				retval.subscribe({
 					error: reject,
 					complete: () => resolve(),
 				});
 			});
 		} else if (returnedPromise) {
 			// `retval` can be any thenable, so convert to a proper promise.
-			promise = Promise.resolve(result.retval);
+			promise = Promise.resolve(retval);
 		}
 
 		if (promise) {
@@ -588,17 +591,19 @@ export default class Test {
 
 				promise
 					.catch(error => {
+						if (this.testFailure !== null && error === this.testFailure) {
+							return;
+						}
+
 						if (isExternalAssertError(error)) {
-							this.saveFirstError(new AssertionError({
-								message: 'Assertion failed',
-								savedError: error instanceof Error && error,
-								values: [{label: 'Assertion failed: ', formatted: error.message}],
+							this.saveFirstError(new AssertionError('Assertion failed', {
+								cause: error,
+								formattedDetails: [{label: 'Assertion failed: ', formatted: error.message}],
 							}));
 						} else {
-							this.saveFirstError(new AssertionError({
-								message: 'Rejected promise returned by test',
-								savedError: error instanceof Error && error,
-								values: [formatErrorValue('Rejected promise returned by test. Reason:', error)],
+							this.saveFirstError(new AssertionError('Rejected promise returned by test', {
+								cause: error,
+								formattedDetails: [formatErrorValue('Rejected promise returned by test. Reason:', error)],
 							}));
 						}
 					})
@@ -625,7 +630,11 @@ export default class Test {
 		if (this.metadata.failing) {
 			passed = !passed;
 
-			error = passed ? null : new Error('Test was expected to fail, but succeeded, you should stop marking the test as failing');
+			error = passed ? null : new AssertionError('Test was expected to fail, but succeeded, you should stop marking the test as failing', {
+				// TODO: Provide an assertion stack that traces to the test declaration,
+				// rather than AVA internals.
+				assertionStack: '',
+			});
 		}
 
 		return {