ava 3.15.0 → 4.0.0

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,20 +1,19 @@
-/* eslint-disable node/no-deprecated-api */
-'use strict';
-const ipc = require('./ipc');
+import process from 'node:process';
+
+import channel from './channel.cjs';
 
 const seenDependencies = new Set();
 let newDependencies = [];
+
 function flush() {
 	if (newDependencies.length === 0) {
 		return;
 	}
 
-	ipc.send({type: 'dependencies', dependencies: newDependencies});
+	channel.send({type: 'dependencies', dependencies: newDependencies});
 	newDependencies = [];
 }
 
-exports.flush = flush;
-
 function track(filename) {
 	if (seenDependencies.has(filename)) {
 		return;
@@ -28,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/{ensure-forked.js → guard-environment.cjs}

@@ -1,15 +1,16 @@
 'use strict';
 const path = require('path');
-const chalk = require('chalk'); // Use default Chalk instance.
+const process = require('process');
+
+const {isRunningInThread, isRunningInChildProcess} = require('./utils.cjs');
 
 // Check if the test is being run without AVA cli
-const isForked = typeof process.send === 'function';
-if (!isForked) {
+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    ${chalk.grey.dim('$')} ${chalk.cyan('ava ' + fp)}\n`);
+		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 {

package/lib/worker/line-numbers.js

@@ -1,18 +1,27 @@
+import * as fs from 'node:fs';
+import {createRequire, findSourceMap} from 'node:module';
+import {pathToFileURL} from 'node:url';
+
+import callsites from 'callsites';
+
+const require = createRequire(import.meta.url);
+
 function parse(file) {
-	const fs = require('fs');
+	// Avoid loading these until we actually need to select tests by line number.
 	const acorn = require('acorn');
 	const walk = require('acorn-walk');
 
 	const ast = acorn.parse(fs.readFileSync(file, 'utf8'), {
 		ecmaVersion: 11,
-		locations: true
+		locations: true,
+		sourceType: 'module',
 	});
 
 	const locations = [];
 	walk.simple(ast, {
 		CallExpression(node) {
 			locations.push(node.loc);
-		}
+		},
 	});
 
 	// Walking is depth-first, but we want to sort these breadth-first.
@@ -49,36 +58,65 @@ function findTest(locations, declaration) {
 	return spans.pop();
 }
 
-const range = (start, end) => new Array(end - start + 1).fill(start).map((element, index) => element + index);
+const range = (start, end) => Array.from({length: end - start + 1}).fill(start).map((element, index) => element + index);
 
-module.exports = ({file, lineNumbers = []}) => {
+const translate = (sourceMap, pos) => {
+	if (sourceMap === undefined) {
+		return pos;
+	}
+
+	const entry = sourceMap.findEntry(pos.line - 1, pos.column); // Source maps are 0-based
+	return {
+		line: entry.originalLine + 1, // Readjust for Acorn.
+		column: entry.originalColumn,
+	};
+};
+
+export default function lineNumberSelection({file, lineNumbers = []}) {
 	if (lineNumbers.length === 0) {
 		return undefined;
 	}
 
-	// Avoid loading these until we actually need to select tests by line number.
-	const callsites = require('callsites');
-	const sourceMapSupport = require('source-map-support');
-
-	const locations = parse(file);
 	const selected = new Set(lineNumbers);
 
+	let locations = parse(file);
+	let lookedForSourceMap = false;
+	let sourceMap;
+
 	return () => {
+		if (!lookedForSourceMap) {
+			lookedForSourceMap = true;
+
+			// The returned function is called *after* the file has been loaded.
+			// Source maps are not available before then.
+			sourceMap = findSourceMap(file);
+
+			if (sourceMap !== undefined) {
+				locations = locations.map(({start, end}) => ({
+					start: translate(sourceMap, start),
+					end: translate(sourceMap, end),
+				}));
+			}
+		}
+
 		// Assume this is called from a test declaration, which is located in the file.
 		// If not… don't select the test!
-		const callSite = callsites().find(callSite => callSite.getFileName() === file);
+		const callSite = callsites().find(callSite => {
+			const current = callSite.getFileName();
+			if (file.startsWith('file://')) {
+				return current.startsWith('file://') ? file === current : file === pathToFileURL(current).toString();
+			}
+
+			return current.startsWith('file://') ? pathToFileURL(file).toString() === current : file === current;
+		});
 		if (!callSite) {
 			return false;
 		}
 
-		// FIXME: This assumes the callSite hasn't already been adjusted. It's likely
-		// that if `source-map-support/register` has been loaded, this would result
-		// in the wrong location.
-		const sourceCallSite = sourceMapSupport.wrapCallSite(callSite);
-		const start = {
-			line: sourceCallSite.getLineNumber(),
-			column: sourceCallSite.getColumnNumber() - 1 // Use 0-indexed columns.
-		};
+		const start = translate(sourceMap, {
+			line: callSite.getLineNumber(), // 1-based
+			column: callSite.getColumnNumber() - 1, // Comes out as 1-based, Acorn wants 0-based
+		});
 
 		const test = findTest(locations, start);
 		if (!test) {
@@ -87,4 +125,4 @@ module.exports = ({file, lineNumbers = []}) => {
 
 		return range(test.start.line, test.end.line).some(line => selected.has(line));
 	};
-};
+}

package/lib/worker/main.cjs

@@ -0,0 +1,12 @@
+'use strict';
+require('./guard-environment.cjs'); // eslint-disable-line import/no-unassigned-import
+
+const assert = require('assert');
+
+const {flags, refs} = require('./state.cjs');
+
+assert(refs.runnerChain);
+
+flags.loadedMain = true;
+
+module.exports = refs.runnerChain;

package/lib/worker/{plugin.js → plugin.cjs}

@@ -1,18 +1,29 @@
-const v8 = require('v8');
 const pkg = require('../../package.json');
-const subprocess = require('./subprocess');
-const options = require('./options');
+
+const {registerSharedWorker: register} = require('./channel.cjs');
+const options = require('./options.cjs');
+const {sharedWorkerTeardowns, waitForReady} = require('./state.cjs');
+
+require('./guard-environment.cjs'); // eslint-disable-line import/no-unassigned-import
 
 const workers = new Map();
 const workerTeardownFns = new WeakMap();
 
 function createSharedWorker(filename, initialData, teardown) {
-	const channel = subprocess.registerSharedWorker(filename, initialData, teardown);
+	const {channel, forceUnref, ready} = register(filename, initialData, teardown);
+	waitForReady.push(ready);
+	sharedWorkerTeardowns.push(async () => {
+		try {
+			await teardown();
+		} finally {
+			forceUnref();
+		}
+	});
 
 	class ReceivedMessage {
-		constructor(id, serializedData) {
+		constructor(id, data) {
 			this.id = id;
-			this.data = v8.deserialize(new Uint8Array(serializedData));
+			this.data = data;
 		}
 
 		reply(data) {
@@ -35,7 +46,7 @@ function createSharedWorker(filename, initialData, teardown) {
 
 			let message = messageCache.get(evt);
 			if (message === undefined) {
-				message = new ReceivedMessage(evt.messageId, evt.serializedData);
+				message = new ReceivedMessage(evt.messageId, evt.data);
 				messageCache.set(evt, message);
 			}
 
@@ -44,19 +55,19 @@ function createSharedWorker(filename, initialData, teardown) {
 	}
 
 	function publishMessage(data, replyTo) {
-		const id = channel.post([...v8.serialize(data)], replyTo);
+		const id = channel.post(data, replyTo);
 
 		return {
 			id,
 			async * replies() {
 				yield * receiveMessages(id);
-			}
+			},
 		};
 	}
 
 	return {
 		available: channel.available,
-		protocol: 'experimental',
+		protocol: 'ava-4',
 
 		get currentlyAvailable() {
 			return channel.currentlyAvailable;
@@ -68,30 +79,28 @@ function createSharedWorker(filename, initialData, teardown) {
 
 		async * subscribe() {
 			yield * receiveMessages();
-		}
+		},
 	};
 }
 
-const supportsSharedWorkers = process.versions.node >= '12.17.0';
-
 function registerSharedWorker({
 	filename,
 	initialData,
 	supportedProtocols,
-	teardown
+	teardown,
 }) {
-	if (!options.get().experiments.sharedWorkers) {
-		throw new Error('Shared workers are experimental. Opt in to them in your AVA configuration');
-	}
+	const options_ = options.get();
 
-	if (!supportsSharedWorkers) {
-		throw new Error('Shared workers require Node.js 12.17 or newer');
+	if (!options_.workerThreads) {
+		throw new Error('Shared workers can be used only when worker threads are enabled');
 	}
 
-	if (!supportedProtocols.includes('experimental')) {
-		throw new Error(`This version of AVA (${pkg.version}) does not support any of the desired shared worker protocols: ${supportedProtocols.join()}`);
+	if (!supportedProtocols.includes('ava-4')) {
+		throw new Error(`This version of AVA (${pkg.version}) does not support any of the desired shared worker protocols: ${supportedProtocols.join(',')}`);
 	}
 
+	filename = String(filename); // Allow URL instances.
+
 	let worker = workers.get(filename);
 	if (worker === undefined) {
 		worker = createSharedWorker(filename, initialData, async () => {

package/lib/worker/state.cjs

@@ -0,0 +1,5 @@
+'use strict';
+exports.flags = {loadedMain: false};
+exports.refs = {runnerChain: null};
+exports.sharedWorkerTeardowns = [];
+exports.waitForReady = [];

package/lib/worker/utils.cjs

@@ -0,0 +1,6 @@
+'use strict';
+const process = require('process');
+const {isMainThread} = require('worker_threads');
+
+exports.isRunningInThread = isMainThread === false;
+exports.isRunningInChildProcess = typeof process.send === 'function';