ava 4.0.0-alpha.1 → 4.0.1

package/lib/worker/base.js

@@ -1,44 +1,34 @@
-'use strict';
-const {pathToFileURL} = require('url');
-const path = require('path');
-const currentlyUnhandled = require('currently-unhandled')();
-const {isRunningInThread, isRunningInChildProcess} = require('./utils');
-
-// Check if the test is being run without AVA cli
-if (!isRunningInChildProcess && !isRunningInThread) {
-	const chalk = require('chalk'); // Use default Chalk instance.
-	if (process.argv[1]) {
-		const fp = path.relative('.', process.argv[1]);
-
-		console.log();
-		console.error(`Test files must be run with the AVA CLI:\n\n    ${chalk.grey.dim('$')} ${chalk.cyan('ava ' + fp)}\n`);
-
-		process.exit(1);
-	} else {
-		throw new Error('The ’ava’ module can only be imported in test files');
-	}
-}
+import {createRequire} from 'node:module';
+import process from 'node:process';
+import {pathToFileURL} from 'node:url';
+import {workerData} from 'node:worker_threads';
+
+import setUpCurrentlyUnhandled from 'currently-unhandled';
+
+import {set as setChalk} from '../chalk.js';
+import nowAndTimers from '../now-and-timers.cjs';
+import providerManager from '../provider-manager.js';
+import Runner from '../runner.js';
+import serializeError from '../serialize-error.js';
+
+import channel from './channel.cjs';
+import dependencyTracking from './dependency-tracker.js';
+import lineNumberSelection from './line-numbers.js';
+import {set as setOptions} from './options.cjs';
+import {flags, refs, sharedWorkerTeardowns} from './state.cjs';
+import {isRunningInThread, isRunningInChildProcess} from './utils.cjs';
 
-const channel = require('./channel');
+const currentlyUnhandled = setUpCurrentlyUnhandled();
 
 const run = async options => {
-	require('./options').set(options);
-	require('../chalk').set(options.chalkOptions);
+	setOptions(options);
+	setChalk(options.chalkOptions);
 
 	if (options.chalkOptions.level > 0) {
 		const {stdout, stderr} = process;
 		global.console = Object.assign(global.console, new console.Console({stdout, stderr, colorMode: true}));
 	}
 
-	const nowAndTimers = require('../now-and-timers');
-	const providerManager = require('../provider-manager');
-	const Runner = require('../runner');
-	const serializeError = require('../serialize-error');
-	const dependencyTracking = require('./dependency-tracker');
-	const lineNumberSelection = require('./line-numbers');
-
-	const sharedWorkerTeardowns = [];
-
 	async function exit(code) {
 		if (!process.exitCode) {
 			process.exitCode = code;
@@ -46,16 +36,14 @@ const run = async options => {
 
 		dependencyTracking.flush();
 		await channel.flush();
-		process.exit();
+		process.exit(); // eslint-disable-line unicorn/no-process-exit
 	}
 
-	// TODO: Initialize providers here, then pass to lineNumberSelection() so they
-	// can be used to parse the test file.
 	let checkSelectedByLineNumbers;
 	try {
 		checkSelectedByLineNumbers = lineNumberSelection({
 			file: options.file,
-			lineNumbers: options.lineNumbers
+			lineNumbers: options.lineNumbers,
 		});
 	} catch (error) {
 		channel.send({type: 'line-number-selection-error', err: serializeError('Line number selection error', false, error, options.file)});
@@ -74,18 +62,13 @@ const run = async options => {
 		runOnlyExclusive: options.runOnlyExclusive,
 		serial: options.serial,
 		snapshotDir: options.snapshotDir,
-		updateSnapshots: options.updateSnapshots
+		updateSnapshots: options.updateSnapshots,
 	});
 
-	channel.peerFailed.then(() => { // eslint-disable-line promise/prefer-await-to-then
-		runner.interrupt();
-	});
+	refs.runnerChain = runner.chain;
 
-	const attributedRejections = new Set();
-	process.on('unhandledRejection', (reason, promise) => {
-		if (runner.attributeLeakedError(reason)) {
-			attributedRejections.add(promise);
-		}
+	channel.peerFailed.then(() => {
+		runner.interrupt();
 	});
 
 	runner.on('dependency', dependencyTracking.track);
@@ -98,7 +81,7 @@ const run = async options => {
 
 	runner.on('finish', async () => {
 		try {
-			const {touchedFiles} = runner.saveSnapshotState();
+			const {touchedFiles} = await runner.saveSnapshotState();
 			if (touchedFiles) {
 				channel.send({type: 'touched-files', files: touchedFiles});
 			}
@@ -117,7 +100,7 @@ const run = async options => {
 		}
 
 		nowAndTimers.setImmediate(() => {
-			for (const rejection of currentlyUnhandled().filter(rejection => !attributedRejections.has(rejection.promise))) {
+			for (const rejection of currentlyUnhandled()) {
 				channel.send({type: 'unhandled-rejection', err: serializeError('Unhandled rejection', true, rejection.reason, runner.file)});
 			}
 
@@ -126,43 +109,13 @@ const run = async options => {
 	});
 
 	process.on('uncaughtException', error => {
-		if (runner.attributeLeakedError(error)) {
-			return;
-		}
-
 		channel.send({type: 'uncaught-exception', err: serializeError('Uncaught exception', true, error, runner.file)});
 		exit(1);
 	});
 
-	let accessedRunner = false;
-	exports.getRunner = () => {
-		accessedRunner = true;
-		return runner;
-	};
-
-	exports.registerSharedWorker = (filename, initialData, teardown) => {
-		const {channel: sharedWorkerChannel, forceUnref, ready} = channel.registerSharedWorker(filename, initialData);
-		runner.waitForReady.push(ready);
-		sharedWorkerTeardowns.push(async () => {
-			try {
-				await teardown();
-			} finally {
-				forceUnref();
-			}
-		});
-		return sharedWorkerChannel;
-	};
-
 	// Store value to prevent required modules from modifying it.
 	const testPath = options.file;
 
-	// Install basic source map support.
-	const sourceMapSupport = require('source-map-support');
-	sourceMapSupport.install({
-		environment: 'node',
-		handleUncaughtExceptions: false
-	});
-
 	const extensionsToLoadAsModules = Object.entries(options.moduleTypes)
 		.filter(([, type]) => type === 'module')
 		.map(([extension]) => extension);
@@ -170,33 +123,29 @@ const run = async options => {
 	// Install before processing options.require, so if helpers are added to the
 	// require configuration the *compiled* helper will be loaded.
 	const {projectDir, providerStates = []} = options;
-	const providers = providerStates.map(({type, state}) => {
-		if (type === 'babel') {
-			const provider = providerManager.babel(projectDir).worker({extensionsToLoadAsModules, state});
-			runner.powerAssert = provider.powerAssert;
-			return provider;
-		}
-
+	const providers = [];
+	await Promise.all(providerStates.map(async ({type, state}) => {
 		if (type === 'typescript') {
-			return providerManager.typescript(projectDir).worker({extensionsToLoadAsModules, state});
+			const provider = await providerManager.typescript(projectDir);
+			providers.push(provider.worker({extensionsToLoadAsModules, state}));
 		}
+	}));
 
-		return null;
-	}).filter(provider => provider !== null);
-
+	const require = createRequire(import.meta.url);
 	const load = async ref => {
-		for (const extension of extensionsToLoadAsModules) {
-			if (ref.endsWith(`.${extension}`)) {
-				return import(pathToFileURL(ref)); // eslint-disable-line node/no-unsupported-features/es-syntax
-			}
-		}
-
 		for (const provider of providers) {
 			if (provider.canLoad(ref)) {
 				return provider.load(ref, {requireFn: require});
 			}
 		}
 
+		for (const extension of extensionsToLoadAsModules) {
+			if (ref.endsWith(`.${extension}`)) {
+				return import(pathToFileURL(ref)); // eslint-disable-line node/no-unsupported-features/es-syntax
+			}
+		}
+
+		// We still support require() since it's more easily monkey-patched.
 		return require(ref);
 	};
 
@@ -207,12 +156,12 @@ const run = async options => {
 
 		// Install dependency tracker after the require configuration has been evaluated
 		// to make sure we also track dependencies with custom require hooks
-		dependencyTracking.install(testPath);
+		dependencyTracking.install(require.extensions, testPath);
 
 		if (options.debug && options.debug.port !== undefined && options.debug.host !== undefined) {
 			// If an inspector was active when the main process started, and is
 			// already active for the worker process, do not open a new one.
-			const inspector = require('inspector'); // eslint-disable-line node/no-unsupported-features/node-builtins
+			const {default: inspector} = await import('node:inspector'); // eslint-disable-line node/no-unsupported-features/es-syntax
 			if (!options.debug.active || inspector.url() === undefined) {
 				inspector.open(options.debug.port, options.debug.host, true);
 			}
@@ -224,7 +173,7 @@ const run = async options => {
 
 		await load(testPath);
 
-		if (accessedRunner) {
+		if (flags.loadedMain) {
 			// Unreference the channel if the test file required AVA. This stops it
 			// from keeping the event loop busy, which means the `beforeExit` event can be
 			// used to detect when tests stall.
@@ -249,11 +198,11 @@ const onError = error => {
 };
 
 if (isRunningInThread) {
-	const {workerData} = require('worker_threads');
+	channel.send({type: 'starting'}); // AVA won't terminate the worker thread until it's seen this message.
 	const {options} = workerData;
 	delete workerData.options; // Don't allow user code access.
 	run(options).catch(onError);
 } else if (isRunningInChildProcess) {
 	channel.send({type: 'ready-for-options'});
-	channel.options.then(run).catch(onError); // eslint-disable-line promise/prefer-await-to-then
+	channel.options.then(run).catch(onError);
 }

package/lib/worker/channel.cjs

@@ -0,0 +1,290 @@
+'use strict';
+const events = require('events');
+const process = require('process');
+const {MessageChannel, threadId} = require('worker_threads');
+
+const timers = require('../now-and-timers.cjs');
+
+const {isRunningInChildProcess, isRunningInThread} = require('./utils.cjs');
+
+let pEvent = async (emitter, event, options) => {
+	// We need to import p-event, but import() is asynchronous. Buffer any events
+	// emitted in the meantime. Don't handle errors.
+	const buffer = [];
+	const addToBuffer = (...args) => buffer.push(args);
+	emitter.on(event, addToBuffer);
+
+	try {
+		({pEvent} = await import('p-event')); // eslint-disable-line node/no-unsupported-features/es-syntax
+	} finally {
+		emitter.off(event, addToBuffer);
+	}
+
+	if (buffer.length === 0) {
+		return pEvent(emitter, event, options);
+	}
+
+	// Now replay buffered events.
+	const replayEmitter = new events.EventEmitter();
+	const promise = pEvent(replayEmitter, event, options);
+	for (const args of buffer) {
+		replayEmitter.emit(event, ...args);
+	}
+
+	const replay = (...args) => replayEmitter.emit(event, ...args);
+	emitter.on(event, replay);
+
+	try {
+		return await promise;
+	} finally {
+		emitter.off(event, replay);
+	}
+};
+
+const selectAvaMessage = type => message => message.ava && message.ava.type === type;
+
+class RefCounter {
+	constructor() {
+		this.count = 0;
+	}
+
+	refAndTest() {
+		return ++this.count === 1;
+	}
+
+	testAndUnref() {
+		return this.count > 0 && --this.count === 0;
+	}
+}
+
+class MessagePortHandle {
+	constructor(port) {
+		this.counter = new RefCounter();
+		this.unreferenceable = false;
+		this.channel = port;
+		// Referencing the port does not immediately prevent the thread from
+		// exiting. Use a timer to keep a reference for at least a second.
+		this.workaroundTimer = timers.setTimeout(() => {}, 1000).unref();
+	}
+
+	forceUnref() {
+		if (this.unreferenceable) {
+			return;
+		}
+
+		this.unreferenceable = true;
+		this.workaroundTimer.unref();
+		this.channel.unref();
+	}
+
+	ref() {
+		if (!this.unreferenceable && this.counter.refAndTest()) {
+			this.workaroundTimer.refresh().ref();
+			this.channel.ref();
+		}
+	}
+
+	unref() {
+		if (!this.unreferenceable && this.counter.testAndUnref()) {
+			this.workaroundTimer.unref();
+			this.channel.unref();
+		}
+	}
+
+	send(evt, transferList) {
+		this.channel.postMessage({ava: evt}, transferList);
+	}
+}
+
+class IpcHandle {
+	constructor(bufferedSend) {
+		this.counter = new RefCounter();
+		this.channel = process;
+		this.sendRaw = bufferedSend;
+	}
+
+	ref() {
+		if (this.counter.refAndTest()) {
+			process.channel.ref();
+		}
+	}
+
+	unref() {
+		if (this.counter.testAndUnref()) {
+			process.channel.unref();
+		}
+	}
+
+	send(evt) {
+		this.sendRaw({ava: evt});
+	}
+}
+
+let handle;
+if (isRunningInChildProcess) {
+	const {controlFlow} = require('../ipc-flow-control.cjs');
+	handle = new IpcHandle(controlFlow(process));
+} else if (isRunningInThread) {
+	const {parentPort} = require('worker_threads');
+	handle = new MessagePortHandle(parentPort);
+}
+
+// The attaching of message listeners will cause the port to be referenced by
+// Node.js. In order to keep track, explicitly reference before attaching.
+handle.ref();
+
+exports.options = pEvent(handle.channel, 'message', selectAvaMessage('options')).then(message => message.ava.options);
+exports.peerFailed = pEvent(handle.channel, 'message', selectAvaMessage('peer-failed'));
+exports.send = handle.send.bind(handle);
+exports.unref = handle.unref.bind(handle);
+
+let pendingPings = Promise.resolve();
+async function flush() {
+	handle.ref();
+	const promise = pendingPings.then(async () => {
+		handle.send({type: 'ping'});
+		await pEvent(handle.channel, 'message', selectAvaMessage('pong'));
+		if (promise === pendingPings) {
+			handle.unref();
+		}
+	});
+	pendingPings = promise;
+	await promise;
+}
+
+exports.flush = flush;
+
+let channelCounter = 0;
+let messageCounter = 0;
+
+const channelEmitters = new Map();
+function createChannelEmitter(channelId) {
+	if (channelEmitters.size === 0) {
+		handle.channel.on('message', message => {
+			if (!message.ava) {
+				return;
+			}
+
+			const {channelId, type, ...payload} = message.ava;
+			if (type === 'shared-worker-error') {
+				const emitter = channelEmitters.get(channelId);
+				if (emitter !== undefined) {
+					emitter.emit(type, payload);
+				}
+			}
+		});
+	}
+
+	const emitter = new events.EventEmitter();
+	channelEmitters.set(channelId, emitter);
+	return [emitter, () => channelEmitters.delete(channelId)];
+}
+
+function registerSharedWorker(filename, initialData) {
+	const channelId = `${threadId}/channel/${++channelCounter}`;
+
+	const {port1: ourPort, port2: theirPort} = new MessageChannel();
+	const sharedWorkerHandle = new MessagePortHandle(ourPort);
+
+	const [channelEmitter, unsubscribe] = createChannelEmitter(channelId);
+
+	handle.send({
+		type: 'shared-worker-connect',
+		channelId,
+		filename,
+		initialData,
+		port: theirPort,
+	}, [theirPort]);
+
+	let currentlyAvailable = false;
+	let error = null;
+
+	// The attaching of message listeners will cause the port to be referenced by
+	// Node.js. In order to keep track, explicitly reference before attaching.
+	sharedWorkerHandle.ref();
+	const ready = pEvent(ourPort, 'message', ({type}) => type === 'ready').then(() => {
+		currentlyAvailable = error === null;
+	}).finally(() => {
+		// Once ready, it's up to user code to subscribe to messages, which (see
+		// below) causes us to reference the port.
+		sharedWorkerHandle.unref();
+	});
+
+	const messageEmitters = new Set();
+
+	// Errors are received over the test worker channel, not the message port
+	// dedicated to the shared worker.
+	pEvent(channelEmitter, 'shared-worker-error').then(() => {
+		unsubscribe();
+		sharedWorkerHandle.forceUnref();
+		error = new Error('The shared worker is no longer available');
+		currentlyAvailable = false;
+		for (const emitter of messageEmitters) {
+			emitter.emit('error', error);
+		}
+	});
+
+	ourPort.on('message', message => {
+		if (message.type === 'message') {
+			// Wait for a turn of the event loop, to allow new subscriptions to be set
+			// up in response to the previous message.
+			setImmediate(() => {
+				for (const emitter of messageEmitters) {
+					emitter.emit('message', message);
+				}
+			});
+		}
+	});
+
+	return {
+		forceUnref: () => sharedWorkerHandle.forceUnref(),
+		ready,
+		channel: {
+			available: ready,
+
+			get currentlyAvailable() {
+				return currentlyAvailable;
+			},
+
+			async * receive() {
+				if (error !== null) {
+					throw error;
+				}
+
+				const emitter = new events.EventEmitter();
+				messageEmitters.add(emitter);
+				try {
+					sharedWorkerHandle.ref();
+					for await (const [message] of events.on(emitter, 'message')) {
+						yield message;
+					}
+				} finally {
+					sharedWorkerHandle.unref();
+					messageEmitters.delete(emitter);
+				}
+			},
+
+			post(data, replyTo) {
+				if (error !== null) {
+					throw error;
+				}
+
+				if (!currentlyAvailable) {
+					throw new Error('Shared worker is not yet available');
+				}
+
+				const messageId = `${channelId}/message/${++messageCounter}`;
+				ourPort.postMessage({
+					type: 'message',
+					messageId,
+					replyTo,
+					data,
+				});
+
+				return messageId;
+			},
+		},
+	};
+}
+
+exports.registerSharedWorker = registerSharedWorker;

package/lib/worker/dependency-tracker.js

@@ -1,6 +1,6 @@
-/* eslint-disable node/no-deprecated-api */
-'use strict';
-const channel = require('./channel');
+import process from 'node:process';
+
+import channel from './channel.cjs';
 
 const seenDependencies = new Set();
 let newDependencies = [];
@@ -14,8 +14,6 @@ function flush() {
 	newDependencies = [];
 }
 
-exports.flush = flush;
-
 function track(filename) {
 	if (seenDependencies.has(filename)) {
 		return;
@@ -29,20 +27,22 @@ function track(filename) {
 	newDependencies.push(filename);
 }
 
-exports.track = track;
-
-function install(testPath) {
-	for (const ext of Object.keys(require.extensions)) {
-		const wrappedHandler = require.extensions[ext];
-
-		require.extensions[ext] = (module, filename) => {
-			if (filename !== testPath) {
-				track(filename);
-			}
-
-			wrappedHandler(module, filename);
-		};
-	}
-}
-
-exports.install = install;
+const tracker = {
+	flush,
+	track,
+	install(extensions, testPath) {
+		for (const ext of Object.keys(extensions)) {
+			const wrappedHandler = extensions[ext];
+
+			extensions[ext] = (module, filename) => {
+				if (filename !== testPath) {
+					track(filename);
+				}
+
+				wrappedHandler(module, filename);
+			};
+		}
+	},
+};
+
+export default tracker;

package/lib/worker/guard-environment.cjs

@@ -0,0 +1,19 @@
+'use strict';
+const path = require('path');
+const process = require('process');
+
+const {isRunningInThread, isRunningInChildProcess} = require('./utils.cjs');
+
+// Check if the test is being run without AVA cli
+if (!isRunningInChildProcess && !isRunningInThread) {
+	if (process.argv[1]) {
+		const fp = path.relative('.', process.argv[1]);
+
+		console.log();
+		console.error(`Test files must be run with the AVA CLI:\n\n    $ ava ${fp}\n`);
+
+		process.exit(1); // eslint-disable-line unicorn/no-process-exit
+	} else {
+		throw new Error('The ’ava’ module can only be imported in test files');
+	}
+}