ava 4.0.0-alpha.1 → 4.0.1

package/lib/parse-test-args.js

@@ -1,15 +1,26 @@
-'use strict';
-function parseTestArgs(args) {
-	const rawTitle = typeof args[0] === 'string' ? args.shift() : undefined;
-	const receivedImplementationArray = Array.isArray(args[0]);
-	const implementations = receivedImplementationArray ? args.shift() : args.splice(0, 1);
+const buildTitle = (raw, implementation, args) => {
+	let value = implementation && implementation.title ? implementation.title(raw, ...args) : raw;
+	const isValid = typeof value === 'string';
+	if (isValid) {
+		value = value.trim().replace(/\s+/g, ' ');
+	}
 
-	const buildTitle = implementation => {
-		const title = implementation.title ? implementation.title(rawTitle, ...args) : rawTitle;
-		return {title, isSet: typeof title !== 'undefined', isValid: typeof title === 'string', isEmpty: !title};
+	return {
+		raw,
+		value,
+		isSet: value !== undefined,
+		isValid,
+		isEmpty: !isValid || value === '',
 	};
+};
 
-	return {args, buildTitle, implementations, rawTitle, receivedImplementationArray};
-}
+export default function parseTestArgs(args) {
+	const rawTitle = typeof args[0] === 'string' ? args.shift() : undefined;
+	const implementation = args.shift();
 
-module.exports = parseTestArgs;
+	return {
+		args,
+		implementation: implementation && implementation.exec ? implementation.exec : implementation,
+		title: buildTitle(rawTitle, implementation, args),
+	};
+}

package/lib/pkg.cjs

@@ -0,0 +1,2 @@
+'use strict';
+module.exports = require('../package.json');

package/lib/plugin-support/shared-worker-loader.js

@@ -1,20 +1,30 @@
-const {EventEmitter, on} = require('events');
-const v8 = require('v8');
-const {workerData, parentPort} = require('worker_threads');
-const pkg = require('../../package.json');
+import {EventEmitter, on} from 'node:events';
+import process from 'node:process';
+import {workerData, parentPort, threadId} from 'node:worker_threads';
 
-// Used to forward messages received over the `parentPort`. Every subscription
-// adds a listener, so do not enforce any maximums.
+import pkg from '../pkg.cjs';
+
+// Used to forward messages received over the `parentPort` and any direct ports
+// to test workers. Every subscription adds a listener, so do not enforce any
+// maximums.
 const events = new EventEmitter().setMaxListeners(0);
+const emitMessage = message => {
+	// Wait for a turn of the event loop, to allow new subscriptions to be
+	// set up in response to the previous message.
+	setImmediate(() => events.emit('message', message));
+};
 
 // Map of active test workers, used in receiveMessages() to get a reference to
 // the TestWorker instance, and relevant release functions.
 const activeTestWorkers = new Map();
 
+const internalMessagePort = Symbol('Internal MessagePort');
+
 class TestWorker {
-	constructor(id, file) {
+	constructor(id, file, port) {
 		this.id = id;
 		this.file = file;
+		this[internalMessagePort] = port;
 	}
 
 	teardown(fn) {
@@ -47,10 +57,10 @@ class TestWorker {
 }
 
 class ReceivedMessage {
-	constructor(testWorker, id, serializedData) {
+	constructor(testWorker, id, data) {
 		this.testWorker = testWorker;
 		this.id = id;
-		this.data = v8.deserialize(new Uint8Array(serializedData));
+		this.data = data;
 	}
 
 	reply(data) {
@@ -98,7 +108,7 @@ async function * receiveMessages(fromTestWorker, replyTo) {
 
 		let received = messageCache.get(message);
 		if (received === undefined) {
-			received = new ReceivedMessage(active.instance, message.messageId, message.serializedData);
+			received = new ReceivedMessage(active.instance, message.messageId, message.data);
 			messageCache.set(message, received);
 		}
 
@@ -107,59 +117,47 @@ async function * receiveMessages(fromTestWorker, replyTo) {
 }
 
 let messageCounter = 0;
-const messageIdPrefix = `${workerData.id}/message`;
+const messageIdPrefix = `${threadId}/message`;
 const nextMessageId = () => `${messageIdPrefix}/${++messageCounter}`;
 
 function publishMessage(testWorker, data, replyTo) {
 	const id = nextMessageId();
-	parentPort.postMessage({
+	testWorker[internalMessagePort].postMessage({
 		type: 'message',
 		messageId: id,
-		testWorkerId: testWorker.id,
-		serializedData: [...v8.serialize(data)],
-		replyTo
+		data,
+		replyTo,
 	});
 
 	return {
 		id,
 		async * replies() {
 			yield * receiveMessages(testWorker, id);
-		}
+		},
 	};
 }
 
 function broadcastMessage(data) {
 	const id = nextMessageId();
-	parentPort.postMessage({
-		type: 'broadcast',
-		messageId: id,
-		serializedData: [...v8.serialize(data)]
-	});
+	for (const trackedWorker of activeTestWorkers.values()) {
+		trackedWorker.instance[internalMessagePort].postMessage({
+			type: 'message',
+			messageId: id,
+			data,
+		});
+	}
 
 	return {
 		id,
 		async * replies() {
 			yield * receiveMessages(undefined, id);
-		}
+		},
 	};
 }
 
 async function loadFactory() {
-	try {
-		const mod = require(workerData.filename);
-		if (typeof mod === 'function') {
-			return mod;
-		}
-
-		return mod.default;
-	} catch (error) {
-		if (error && (error.code === 'ERR_REQUIRE_ESM' || (error.code === 'MODULE_NOT_FOUND' && workerData.filename.startsWith('file://')))) {
-			const {default: factory} = await import(workerData.filename); // eslint-disable-line node/no-unsupported-features/es-syntax
-			return factory;
-		}
-
-		throw error;
-	}
+	const {default: factory} = await import(workerData.filename); // eslint-disable-line node/no-unsupported-features/es-syntax
+	return factory;
 }
 
 let signalAvailable = () => {
@@ -175,7 +173,7 @@ loadFactory(workerData.filename).then(factory => {
 
 	factory({
 		negotiateProtocol(supported) {
-			if (!supported.includes('experimental')) {
+			if (!supported.includes('ava-4')) {
 				fatal = new Error(`This version of AVA (${pkg.version}) is not compatible with shared worker plugin at ${workerData.filename}`);
 				throw fatal;
 			}
@@ -184,12 +182,13 @@ loadFactory(workerData.filename).then(factory => {
 
 			parentPort.on('message', async message => {
 				if (message.type === 'register-test-worker') {
-					const {id, file} = message;
-					const instance = new TestWorker(id, file);
+					const {id, file, port} = message;
+					const instance = new TestWorker(id, file, port);
 
 					activeTestWorkers.set(id, {instance, teardownFns: new Set()});
 
 					produceTestWorker(instance);
+					port.on('message', message => emitMessage({testWorkerId: id, ...message}));
 				}
 
 				if (message.type === 'deregister-test-worker') {
@@ -205,18 +204,16 @@ loadFactory(workerData.filename).then(factory => {
 
 					parentPort.postMessage({
 						type: 'deregistered-test-worker',
-						id
+						id,
 					});
-				}
 
-				// Wait for a turn of the event loop, to allow new subscriptions to be
-				// set up in response to the previous message.
-				setImmediate(() => events.emit('message', message));
+					emitMessage(message);
+				}
 			});
 
 			return {
 				initialData: workerData.initialData,
-				protocol: 'experimental',
+				protocol: 'ava-4',
 
 				ready() {
 					signalAvailable();
@@ -235,9 +232,9 @@ loadFactory(workerData.filename).then(factory => {
 					for await (const [worker] of on(events, 'testWorker')) {
 						yield worker;
 					}
-				}
+				},
 			};
-		}
+		},
 	});
 }).catch(error => {
 	if (fatal === undefined) {

package/lib/plugin-support/shared-workers.js

@@ -1,11 +1,11 @@
-const events = require('events');
-const {Worker} = require('worker_threads');
+import events from 'node:events';
+import {pathToFileURL} from 'node:url';
+import {Worker} from 'node:worker_threads';
 
-const serializeError = require('../serialize-error');
+import serializeError from '../serialize-error.js';
 
-const LOADER = require.resolve('./shared-worker-loader');
+const LOADER = new URL('shared-worker-loader.js', import.meta.url);
 
-let sharedWorkerCounter = 0;
 const launchedWorkers = new Map();
 
 const waitForAvailable = async worker => {
@@ -16,30 +16,28 @@ const waitForAvailable = async worker => {
 	}
 };
 
-function launchWorker({filename, initialData}) {
+function launchWorker(filename, initialData) {
 	if (launchedWorkers.has(filename)) {
 		return launchedWorkers.get(filename);
 	}
 
-	const id = `shared-worker/${++sharedWorkerCounter}`;
 	const worker = new Worker(LOADER, {
 		// Ensure the worker crashes for unhandled rejections, rather than allowing undefined behavior.
 		execArgv: ['--unhandled-rejections=strict'],
 		workerData: {
 			filename,
-			id,
-			initialData
-		}
+			initialData,
+		},
 	});
 	worker.setMaxListeners(0);
 
 	const launched = {
 		statePromises: {
 			available: waitForAvailable(worker),
-			error: events.once(worker, 'error').then(([error]) => error) // eslint-disable-line promise/prefer-await-to-then
+			error: events.once(worker, 'error').then(([error]) => error),
 		},
 		exited: false,
-		worker
+		worker,
 	};
 
 	launchedWorkers.set(filename, launched);
@@ -50,7 +48,7 @@ function launchWorker({filename, initialData}) {
 	return launched;
 }
 
-async function observeWorkerProcess(fork, runStatus) {
+export async function observeWorkerProcess(fork, runStatus) {
 	let registrationCount = 0;
 	let signalDeregistered;
 	const deregistered = new Promise(resolve => {
@@ -63,26 +61,11 @@ async function observeWorkerProcess(fork, runStatus) {
 		}
 	});
 
-	fork.onConnectSharedWorker(async channel => {
-		const launched = launchWorker(channel);
-
-		const handleChannelMessage = ({messageId, replyTo, serializedData}) => {
-			launched.worker.postMessage({
-				type: 'message',
-				testWorkerId: fork.forkId,
-				messageId,
-				replyTo,
-				serializedData
-			});
-		};
+	fork.onConnectSharedWorker(async ({filename, initialData, port, signalError}) => {
+		const launched = launchWorker(filename, initialData);
 
 		const handleWorkerMessage = async message => {
-			if (message.type === 'broadcast' || (message.type === 'message' && message.testWorkerId === fork.forkId)) {
-				const {messageId, replyTo, serializedData} = message;
-				channel.forwardMessageToFork({messageId, replyTo, serializedData});
-			}
-
-			if (message.type === 'deregistered-test-worker' && message.id === fork.forkId) {
+			if (message.type === 'deregistered-test-worker' && message.id === fork.threadId) {
 				launched.worker.off('message', handleWorkerMessage);
 
 				registrationCount--;
@@ -92,35 +75,35 @@ async function observeWorkerProcess(fork, runStatus) {
 			}
 		};
 
-		launched.statePromises.error.then(error => { // eslint-disable-line promise/prefer-await-to-then
+		launched.statePromises.error.then(error => {
 			signalDeregistered();
 			launched.worker.off('message', handleWorkerMessage);
 			runStatus.emitStateChange({type: 'shared-worker-error', err: serializeError('Shared worker error', true, error)});
-			channel.signalError();
+			signalError();
 		});
 
 		try {
 			await launched.statePromises.available;
 
 			registrationCount++;
+
+			port.postMessage({type: 'ready'});
+
 			launched.worker.postMessage({
 				type: 'register-test-worker',
-				id: fork.forkId,
-				file: fork.file
-			});
+				id: fork.threadId,
+				file: pathToFileURL(fork.file).toString(),
+				port,
+			}, [port]);
 
 			fork.promise.finally(() => {
 				launched.worker.postMessage({
 					type: 'deregister-test-worker',
-					id: fork.forkId
+					id: fork.threadId,
 				});
-
-				channel.off('message', handleChannelMessage);
 			});
 
 			launched.worker.on('message', handleWorkerMessage);
-			channel.on('message', handleChannelMessage);
-			channel.signalReady();
 		} catch {
 			return;
 		} finally {
@@ -133,5 +116,3 @@ async function observeWorkerProcess(fork, runStatus) {
 
 	return deregistered;
 }
-
-exports.observeWorkerProcess = observeWorkerProcess;

package/lib/provider-manager.js

@@ -1,21 +1,21 @@
-const pkg = require('../package.json');
-const globs = require('./globs');
+import * as globs from './globs.js';
+import pkg from './pkg.cjs';
 
 const levels = {
-	ava3: 1,
-	pathRewrites: 2
+	// As the protocol changes, comparing levels by integer allows AVA to be
+	// compatible with different versions. Currently there is only one supported
+	// version, so this is effectively unused. The infrastructure is retained for
+	// future use.
+	levelIntegersAreCurrentlyUnused: 0,
 };
 
-exports.levels = levels;
-
 const levelsByProtocol = {
-	'ava-3': levels.ava3,
-	'ava-3.2': levels.pathRewrites
+	'ava-3.2': levels.levelIntegersAreCurrentlyUnused,
 };
 
-function load(providerModule, projectDir) {
+async function load(providerModule, projectDir) {
 	const ava = {version: pkg.version};
-	const makeProvider = require(providerModule);
+	const {default: makeProvider} = await import(providerModule); // eslint-disable-line node/no-unsupported-features/es-syntax
 
 	let fatal;
 	let level;
@@ -37,9 +37,9 @@ function load(providerModule, projectDir) {
 				},
 				identifier,
 				normalizeGlobPatterns: globs.normalizePatterns,
-				projectDir
+				projectDir,
 			};
-		}
+		},
 	});
 
 	if (fatal) {
@@ -49,5 +49,11 @@ function load(providerModule, projectDir) {
 	return {...provider, level};
 }
 
-exports.babel = projectDir => load('@ava/babel', projectDir);
-exports.typescript = projectDir => load('@ava/typescript', projectDir);
+const providerManager = {
+	levels,
+	async typescript(projectDir) {
+		return load('@ava/typescript', projectDir);
+	},
+};
+
+export default providerManager;

package/lib/reporters/beautify-stack.js

@@ -1,15 +1,10 @@
-'use strict';
-const StackUtils = require('stack-utils');
+import StackUtils from 'stack-utils';
 
 const stackUtils = new StackUtils({
 	ignoredPackages: [
-		'@ava/babel',
-		'@ava/require-precompiled',
 		'@ava/typescript',
-		'append-transform',
 		'ava',
-		'empower-core',
-		'nyc'
+		'nyc',
 	],
 	internals: [
 		// AVA internals, which ignoredPackages don't ignore when we run our own unit tests.
@@ -19,8 +14,8 @@ const stackUtils = new StackUtils({
 		/\(internal\/process\/task_queues\.js:\d+:\d+\)$/,
 		/\(internal\/modules\/cjs\/.+?\.js:\d+:\d+\)$/,
 		/async Promise\.all \(index/,
-		/new Promise \(<anonymous>\)/
-	]
+		/new Promise \(<anonymous>\)/,
+	],
 });
 
 /*
@@ -59,7 +54,7 @@ const stackUtils = new StackUtils({
  * Module.runMain (module.js:604:10)
  * ```
  */
-module.exports = stack => {
+export default function beautifyStack(stack) {
 	if (!stack) {
 		return [];
 	}
@@ -69,4 +64,4 @@ module.exports = stack => {
 		.split('\n')
 		.map(line => line.trim())
 		.filter(line => line !== '');
-};
+}

package/lib/reporters/colors.js

@@ -1,17 +1,42 @@
-'use strict';
-const chalk = require('../chalk').get();
+import {chalk} from '../chalk.js';
 
-module.exports = {
-	log: chalk.gray,
-	title: chalk.bold,
-	error: chalk.red,
-	skip: chalk.yellow,
-	todo: chalk.blue,
-	pass: chalk.green,
-	duration: chalk.gray.dim,
-	errorSource: chalk.gray,
-	errorStack: chalk.gray,
-	errorStackInternal: chalk.gray.dim,
-	stack: chalk.red,
-	information: chalk.magenta
+const colors = {
+	get log() {
+		return chalk.gray;
+	},
+	get title() {
+		return chalk.bold;
+	},
+	get error() {
+		return chalk.red;
+	},
+	get skip() {
+		return chalk.yellow;
+	},
+	get todo() {
+		return chalk.blue;
+	},
+	get pass() {
+		return chalk.green;
+	},
+	get duration() {
+		return chalk.gray.dim;
+	},
+	get errorSource() {
+		return chalk.gray;
+	},
+	get errorStack() {
+		return chalk.gray;
+	},
+	get errorStackInternal() {
+		return chalk.gray.dim;
+	},
+	get stack() {
+		return chalk.red;
+	},
+	get information() {
+		return chalk.magenta;
+	},
 };
+
+export default colors;