ava 3.11.0 → 3.13.0

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

@@ -0,0 +1,138 @@
+const events = require('events');
+const serializeError = require('../serialize-error');
+
+let Worker;
+try {
+	({Worker} = require('worker_threads')); // eslint-disable-line node/no-unsupported-features/node-builtins
+} catch {}
+
+const LOADER = require.resolve('./shared-worker-loader');
+
+let sharedWorkerCounter = 0;
+const launchedWorkers = new Map();
+
+const waitForAvailable = async worker => {
+	for await (const [message] of events.on(worker, 'message')) {
+		if (message.type === 'available') {
+			return;
+		}
+	}
+};
+
+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
+		}
+	});
+	const launched = {
+		statePromises: {
+			available: waitForAvailable(worker),
+			error: events.once(worker, 'error').then(([error]) => error) // eslint-disable-line promise/prefer-await-to-then
+		},
+		exited: false,
+		worker
+	};
+
+	launchedWorkers.set(filename, launched);
+	worker.once('exit', () => {
+		launched.exited = true;
+	});
+
+	return launched;
+}
+
+async function observeWorkerProcess(fork, runStatus) {
+	let registrationCount = 0;
+	let signalDeregistered;
+	const deregistered = new Promise(resolve => {
+		signalDeregistered = resolve;
+	});
+
+	fork.promise.finally(() => {
+		if (registrationCount === 0) {
+			signalDeregistered();
+		}
+	});
+
+	fork.onConnectSharedWorker(async channel => {
+		const launched = launchWorker(channel);
+
+		const handleChannelMessage = ({messageId, replyTo, serializedData}) => {
+			launched.worker.postMessage({
+				type: 'message',
+				testWorkerId: fork.forkId,
+				messageId,
+				replyTo,
+				serializedData
+			});
+		};
+
+		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) {
+				launched.worker.off('message', handleWorkerMessage);
+
+				registrationCount--;
+				if (registrationCount === 0) {
+					signalDeregistered();
+				}
+			}
+		};
+
+		launched.statePromises.error.then(error => { // eslint-disable-line promise/prefer-await-to-then
+			signalDeregistered();
+			launched.worker.off('message', handleWorkerMessage);
+			runStatus.emitStateChange({type: 'shared-worker-error', err: serializeError('Shared worker error', true, error)});
+			channel.signalError();
+		});
+
+		try {
+			await launched.statePromises.available;
+
+			registrationCount++;
+			launched.worker.postMessage({
+				type: 'register-test-worker',
+				id: fork.forkId,
+				file: fork.file
+			});
+
+			fork.promise.finally(() => {
+				launched.worker.postMessage({
+					type: 'deregister-test-worker',
+					id: fork.forkId
+				});
+
+				channel.off('message', handleChannelMessage);
+			});
+
+			launched.worker.on('message', handleWorkerMessage);
+			channel.on('message', handleChannelMessage);
+			channel.signalReady();
+		} catch {
+			return;
+		} finally {
+			// Attaching listeners has the side-effect of referencing the worker.
+			// Explicitly unreference it now so it does not prevent the main process
+			// from exiting.
+			launched.worker.unref();
+		}
+	});
+
+	return deregistered;
+}
+
+exports.observeWorkerProcess = observeWorkerProcess;

package/lib/provider-manager.js

@@ -21,7 +21,7 @@ function load(providerModule, projectDir) {
 	let level;
 	const provider = makeProvider({
 		negotiateProtocol(identifiers, {version}) {
-			const [identifier] = identifiers.filter(identifier => Reflect.has(levelsByProtocol, identifier));
+			const identifier = identifiers.find(identifier => Reflect.has(levelsByProtocol, identifier));
 
 			if (identifier === undefined) {
 				fatal = new Error(`This version of AVA (${ava.version}) is not compatible with ${providerModule}@${version}`);

package/lib/reporters/default.js

@@ -18,7 +18,6 @@ const colors = require('./colors');
 const formatSerializedError = require('./format-serialized-error');
 const improperUsageMessages = require('./improper-usage-messages');
 const prefixTitle = require('./prefix-title');
-const whileCorked = require('./while-corked');
 
 const nodeInternals = require('stack-utils').nodeInternals();
 
@@ -97,6 +96,48 @@ class LineWriterWithSpinner extends LineWriter {
 	}
 }
 
+function manageCorking(stream) {
+	let corked = false;
+	const cork = () => {
+		corked = true;
+		stream.cork();
+	};
+
+	const uncork = () => {
+		corked = false;
+		stream.uncork();
+	};
+
+	return {
+		decorateFlushingWriter(fn) {
+			return function (...args) {
+				if (corked) {
+					stream.uncork();
+				}
+
+				try {
+					return fn.apply(this, args);
+				} finally {
+					if (corked) {
+						stream.cork();
+					}
+				}
+			};
+		},
+
+		decorateWriter(fn) {
+			return function (...args) {
+				cork();
+				try {
+					return fn.apply(this, args);
+				} finally {
+					uncork();
+				}
+			};
+		}
+	};
+}
+
 class Reporter {
 	constructor({
 		verbose,
@@ -112,13 +153,16 @@ class Reporter {
 		this.stdStream = stdStream;
 		this.watching = watching;
 		this.relativeFile = file => path.relative(projectDir, file);
-		this.consumeStateChange = whileCorked(this.reportStream, this.consumeStateChange);
+
+		const {decorateWriter, decorateFlushingWriter} = manageCorking(this.reportStream);
+		this.consumeStateChange = decorateWriter(this.consumeStateChange);
+		this.endRun = decorateWriter(this.endRun);
 
 		if (this.verbose) {
 			this.durationThreshold = durationThreshold || 100;
 			this.spinner = null;
+			this.clearSpinner = () => {};
 			this.lineWriter = new LineWriter(this.reportStream);
-			this.endRun = whileCorked(this.reportStream, this.endRun);
 		} else {
 			this.spinner = ora({
 				isEnabled: true,
@@ -128,8 +172,8 @@ class Reporter {
 				spinner: spinner || (process.platform === 'win32' ? 'line' : 'dots'),
 				stream: reportStream
 			});
+			this.clearSpinner = decorateFlushingWriter(this.spinner.clear.bind(this.spinner));
 			this.lineWriter = new LineWriterWithSpinner(this.reportStream, this.spinner);
-			this.endRun = whileCorked(this.reportStream, whileCorked(this.lineWriter, this.endRun));
 		}
 
 		this.reset();
@@ -151,6 +195,7 @@ class Reporter {
 		this.internalErrors = [];
 		this.knownFailures = [];
 		this.lineNumberErrors = [];
+		this.sharedWorkerErrors = [];
 		this.uncaughtExceptions = [];
 		this.unhandledRejections = [];
 		this.unsavedSnapshots = [];
@@ -296,6 +341,19 @@ class Reporter {
 				break;
 			}
 
+			case 'shared-worker-error': {
+				this.sharedWorkerErrors.push(event);
+
+				if (this.verbose) {
+					this.lineWriter.ensureEmptyLine();
+					this.lineWriter.writeLine(colors.error(`${figures.cross} Error in shared worker`));
+					this.lineWriter.writeLine();
+					this.writeErr(event);
+				}
+
+				break;
+			}
+
 			case 'snapshot-error':
 				this.unsavedSnapshots.push(event);
 				break;
@@ -362,9 +420,7 @@ class Reporter {
 
 			case 'worker-stderr': {
 				// Forcibly clear the spinner, writing the chunk corrupts the TTY.
-				if (this.spinner !== null) {
-					this.spinner.clear();
-				}
+				this.clearSpinner();
 
 				this.stdStream.write(event.chunk);
 				// If the chunk does not end with a linebreak, *forcibly* write one to
@@ -386,9 +442,7 @@ class Reporter {
 
 			case 'worker-stdout': {
 				// Forcibly clear the spinner, writing the chunk corrupts the TTY.
-				if (this.spinner !== null) {
-					this.spinner.clear();
-				}
+				this.clearSpinner();
 
 				this.stdStream.write(event.chunk);
 				// If the chunk does not end with a linebreak, *forcibly* write one to
@@ -670,7 +724,7 @@ class Reporter {
 		}
 
 		if (this.failures.length > 0) {
-			const writeTrailingLines = this.internalErrors.length > 0 || this.uncaughtExceptions.length > 0 || this.unhandledRejections.length > 0;
+			const writeTrailingLines = this.internalErrors.length > 0 || this.sharedWorkerErrors.length > 0 || this.uncaughtExceptions.length > 0 || this.unhandledRejections.length > 0;
 
 			const lastFailure = this.failures[this.failures.length - 1];
 			for (const event of this.failures) {
@@ -694,7 +748,7 @@ class Reporter {
 
 		if (!this.verbose) {
 			if (this.internalErrors.length > 0) {
-				const writeTrailingLines = this.uncaughtExceptions.length > 0 || this.unhandledRejections.length > 0;
+				const writeTrailingLines = this.sharedWorkerErrors.length > 0 || this.uncaughtExceptions.length > 0 || this.unhandledRejections.length > 0;
 
 				const last = this.internalErrors[this.internalErrors.length - 1];
 				for (const event of this.internalErrors) {
@@ -716,6 +770,23 @@ class Reporter {
 				}
 			}
 
+			if (this.sharedWorkerErrors.length > 0) {
+				const writeTrailingLines = this.uncaughtExceptions.length > 0 || this.unhandledRejections.length > 0;
+
+				const last = this.sharedWorkerErrors[this.sharedWorkerErrors.length - 1];
+				for (const evt of this.sharedWorkerErrors) {
+					this.lineWriter.writeLine(colors.error(`${figures.cross} Error in shared worker`));
+					this.lineWriter.writeLine();
+					this.writeErr(evt.err);
+					if (evt !== last || writeTrailingLines) {
+						this.lineWriter.writeLine();
+						this.lineWriter.writeLine();
+					}
+
+					wroteSomething = true;
+				}
+			}
+
 			if (this.uncaughtExceptions.length > 0) {
 				const writeTrailingLines = this.unhandledRejections.length > 0;
 

package/lib/run-status.js

@@ -27,6 +27,7 @@ class RunStatus extends Emittery {
 			passedKnownFailingTests: 0,
 			passedTests: 0,
 			selectedTests: 0,
+			sharedWorkerErrors: 0,
 			skippedTests: 0,
 			timeouts: 0,
 			todoTests: 0,
@@ -93,6 +94,9 @@ class RunStatus extends Emittery {
 					this.addPendingTest(event);
 				}
 
+				break;
+			case 'shared-worker-error':
+				stats.sharedWorkerErrors++;
 				break;
 			case 'test-failed':
 				stats.failedTests++;
@@ -164,6 +168,7 @@ class RunStatus extends Emittery {
 			this.stats.failedHooks > 0 ||
 			this.stats.failedTests > 0 ||
 			this.stats.failedWorkers > 0 ||
+			this.stats.sharedWorkerErrors > 0 ||
 			this.stats.timeouts > 0 ||
 			this.stats.uncaughtExceptions > 0 ||
 			this.stats.unhandledRejections > 0

package/lib/runner.js

@@ -42,6 +42,7 @@ class Runner extends Emittery {
 			serial: [],
 			todo: []
 		};
+		this.waitForReady = [];
 
 		const uniqueTestTitles = new Set();
 		this.registerUniqueTitle = title => {
@@ -444,6 +445,8 @@ class Runner extends Emittery {
 			});
 		}
 
+		await Promise.all(this.waitForReady);
+
 		if (concurrentTests.length === 0 && serialTests.length === 0) {
 			this.emit('finish');
 			// Don't run any hooks if there are no tests to run.

package/lib/test.js

@@ -187,7 +187,8 @@ class ExecutionContext extends assert.Assertions {
 	}
 
 	get passed() {
-		return testMap.get(this).testPassed;
+		const test = testMap.get(this);
+		return test.isHook ? test.testPassed : !test.assertError;
 	}
 
 	_throwsArgStart(assertion, file, line) {

package/lib/worker/ipc.js

@@ -1,50 +1,42 @@
 'use strict';
-const Emittery = require('emittery');
+const events = require('events');
+const pEvent = require('p-event');
+const {controlFlow} = require('../ipc-flow-control');
+const {get: getOptions} = require('./options');
 
-const emitter = new Emittery();
-process.on('message', message => {
-	if (!message.ava) {
-		return;
-	}
-
-	switch (message.ava.type) {
-		case 'options':
-			emitter.emit('options', message.ava.options);
-			break;
-		case 'peer-failed':
-			emitter.emit('peerFailed');
-			break;
-		case 'pong':
-			emitter.emit('pong');
-			break;
-		default:
-			break;
-	}
-});
+const selectAvaMessage = type => message => message.ava && message.ava.type === type;
 
-exports.options = emitter.once('options');
-exports.peerFailed = emitter.once('peerFailed');
+exports.options = pEvent(process, 'message', selectAvaMessage('options')).then(message => message.ava.options);
+exports.peerFailed = pEvent(process, 'message', selectAvaMessage('peer-failed'));
 
+const bufferedSend = controlFlow(process);
 function send(evt) {
-	if (process.connected) {
-		process.send({ava: evt});
-	}
+	bufferedSend({ava: evt});
 }
 
 exports.send = send;
 
+let refs = 1;
+function ref() {
+	if (++refs === 1) {
+		process.channel.ref();
+	}
+}
+
 function unref() {
-	process.channel.unref();
+	if (refs > 0 && --refs === 0) {
+		process.channel.unref();
+	}
 }
 
 exports.unref = unref;
 
 let pendingPings = Promise.resolve();
 async function flush() {
-	process.channel.ref();
+	ref();
 	const promise = pendingPings.then(async () => { // eslint-disable-line promise/prefer-await-to-then
 		send({type: 'ping'});
-		await emitter.once('pong');
+		await pEvent(process, 'message', selectAvaMessage('pong'));
 		if (promise === pendingPings) {
 			unref();
 		}
@@ -54,3 +46,156 @@ async function flush() {
 }
 
 exports.flush = flush;
+
+let channelCounter = 0;
+let messageCounter = 0;
+
+const channelEmitters = new Map();
+function createChannelEmitter(channelId) {
+	if (channelEmitters.size === 0) {
+		process.on('message', message => {
+			if (!message.ava) {
+				return;
+			}
+
+			const {channelId, type, ...payload} = message.ava;
+			if (
+				type === 'shared-worker-error' ||
+				type === 'shared-worker-message' ||
+				type === 'shared-worker-ready'
+			) {
+				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 = `${getOptions().forkId}/channel/${++channelCounter}`;
+	const [channelEmitter, unsubscribe] = createChannelEmitter(channelId);
+
+	let forcedUnref = false;
+	let refs = 0;
+	const forceUnref = () => {
+		if (forcedUnref) {
+			return;
+		}
+
+		forcedUnref = true;
+		if (refs > 0) {
+			unref();
+		}
+	};
+
+	const refChannel = () => {
+		if (!forcedUnref && ++refs === 1) {
+			ref();
+		}
+	};
+
+	const unrefChannel = () => {
+		if (!forcedUnref && refs > 0 && --refs === 0) {
+			unref();
+		}
+	};
+
+	send({
+		type: 'shared-worker-connect',
+		channelId,
+		filename,
+		initialData
+	});
+
+	let currentlyAvailable = false;
+	let error = null;
+
+	refChannel();
+	const ready = pEvent(channelEmitter, 'shared-worker-ready').then(() => { // eslint-disable-line promise/prefer-await-to-then
+		currentlyAvailable = error === null;
+	}).finally(unrefChannel);
+
+	const messageEmitters = new Set();
+	const handleMessage = 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);
+			}
+		});
+	};
+
+	channelEmitter.on('shared-worker-message', handleMessage);
+
+	pEvent(channelEmitter, 'shared-worker-error').then(() => { // eslint-disable-line promise/prefer-await-to-then
+		unsubscribe();
+		forceUnref();
+
+		error = new Error('The shared worker is no longer available');
+		currentlyAvailable = false;
+		for (const emitter of messageEmitters) {
+			emitter.emit('error', error);
+		}
+	});
+
+	return {
+		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 {
+					refChannel();
+					for await (const [message] of events.on(emitter, 'message')) {
+						yield message;
+					}
+				} finally {
+					unrefChannel();
+					messageEmitters.delete(emitter);
+				}
+			},
+
+			post(serializedData, replyTo) {
+				if (error !== null) {
+					throw error;
+				}
+
+				if (!currentlyAvailable) {
+					throw new Error('Shared worker is not yet available');
+				}
+
+				const messageId = `${channelId}/message/${++messageCounter}`;
+				send({
+					type: 'shared-worker-message',
+					channelId,
+					messageId,
+					replyTo,
+					serializedData
+				});
+
+				return messageId;
+			}
+		}
+	};
+}
+
+exports.registerSharedWorker = registerSharedWorker;
+