ava 3.12.1 → 3.13.0

package/lib/reporters/default.js

@@ -195,6 +195,7 @@ class Reporter {
 		this.internalErrors = [];
 		this.knownFailures = [];
 		this.lineNumberErrors = [];
+		this.sharedWorkerErrors = [];
 		this.uncaughtExceptions = [];
 		this.unhandledRejections = [];
 		this.unsavedSnapshots = [];
@@ -340,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;
@@ -710,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) {
@@ -734,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) {
@@ -756,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;
+

package/lib/worker/plugin.js

@@ -0,0 +1,121 @@
+const v8 = require('v8');
+const pkg = require('../../package.json');
+const subprocess = require('./subprocess');
+const options = require('./options');
+
+const workers = new Map();
+const workerTeardownFns = new WeakMap();
+
+function createSharedWorker(filename, initialData, teardown) {
+	const channel = subprocess.registerSharedWorker(filename, initialData, teardown);
+
+	class ReceivedMessage {
+		constructor(id, serializedData) {
+			this.id = id;
+			this.data = v8.deserialize(new Uint8Array(serializedData));
+		}
+
+		reply(data) {
+			return publishMessage(data, this.id);
+		}
+	}
+
+	// Ensure that, no matter how often it's received, we have a stable message
+	// object.
+	const messageCache = new WeakMap();
+	async function * receiveMessages(replyTo) {
+		for await (const evt of channel.receive()) {
+			if (replyTo === undefined && evt.replyTo !== undefined) {
+				continue;
+			}
+
+			if (replyTo !== undefined && evt.replyTo !== replyTo) {
+				continue;
+			}
+
+			let message = messageCache.get(evt);
+			if (message === undefined) {
+				message = new ReceivedMessage(evt.messageId, evt.serializedData);
+				messageCache.set(evt, message);
+			}
+
+			yield message;
+		}
+	}
+
+	function publishMessage(data, replyTo) {
+		const id = channel.post([...v8.serialize(data)], replyTo);
+
+		return {
+			id,
+			async * replies() {
+				yield * receiveMessages(id);
+			}
+		};
+	}
+
+	return {
+		available: channel.available,
+		protocol: 'experimental',
+
+		get currentlyAvailable() {
+			return channel.currentlyAvailable;
+		},
+
+		publish(data) {
+			return publishMessage(data);
+		},
+
+		async * subscribe() {
+			yield * receiveMessages();
+		}
+	};
+}
+
+const supportsSharedWorkers = process.versions.node >= '12.17.0';
+
+function registerSharedWorker({
+	filename,
+	initialData,
+	supportedProtocols,
+	teardown
+}) {
+	if (!options.get().experiments.sharedWorkers) {
+		throw new Error('Shared workers are experimental. Opt in to them in your AVA configuration');
+	}
+
+	if (!supportsSharedWorkers) {
+		throw new Error('Shared workers require Node.js 12.17 or newer');
+	}
+
+	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()}`);
+	}
+
+	let worker = workers.get(filename);
+	if (worker === undefined) {
+		worker = createSharedWorker(filename, initialData, async () => {
+			// Run possibly asynchronous teardown functions serially, in reverse
+			// order. Any error will crash the worker.
+			const teardownFns = workerTeardownFns.get(worker);
+			if (teardownFns !== undefined) {
+				for await (const fn of [...teardownFns].reverse()) {
+					await fn();
+				}
+			}
+		});
+		workers.set(filename, worker);
+	}
+
+	if (teardown !== undefined) {
+		if (workerTeardownFns.has(worker)) {
+			workerTeardownFns.get(worker).push(teardown);
+		} else {
+			workerTeardownFns.set(worker, [teardown]);
+		}
+	}
+
+	return worker;
+}
+
+exports.registerSharedWorker = registerSharedWorker;

package/lib/worker/subprocess.js

@@ -32,6 +32,8 @@ ipc.options.then(async options => {
 	const dependencyTracking = require('./dependency-tracker');
 	const lineNumberSelection = require('./line-numbers');
 
+	const sharedWorkerTeardowns = [];
+
 	async function exit(code) {
 		if (!process.exitCode) {
 			process.exitCode = code;
@@ -89,7 +91,7 @@ ipc.options.then(async options => {
 		exit(1);
 	});
 
-	runner.on('finish', () => {
+	runner.on('finish', async () => {
 		try {
 			const {cannotSave, touchedFiles} = runner.saveSnapshotState();
 			if (cannotSave) {
@@ -103,6 +105,14 @@ ipc.options.then(async options => {
 			return;
 		}
 
+		try {
+			await Promise.all(sharedWorkerTeardowns.map(fn => fn()));
+		} catch (error) {
+			ipc.send({type: 'uncaught-exception', err: serializeError('Shared worker teardown error', false, error, runner.file)});
+			exit(1);
+			return;
+		}
+
 		nowAndTimers.setImmediate(() => {
 			currentlyUnhandled()
 				.filter(rejection => !attributedRejections.has(rejection.promise))
@@ -129,6 +139,19 @@ ipc.options.then(async options => {
 		return runner;
 	};
 
+	exports.registerSharedWorker = (filename, initialData, teardown) => {
+		const {channel, forceUnref, ready} = ipc.registerSharedWorker(filename, initialData);
+		runner.waitForReady.push(ready);
+		sharedWorkerTeardowns.push(async () => {
+			try {
+				await teardown();
+			} finally {
+				forceUnref();
+			}
+		});
+		return channel;
+	};
+
 	// Store value to prevent required modules from modifying it.
 	const testPath = options.file;
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ava",
-	"version": "3.12.1",
+	"version": "3.13.0",
 	"description": "Node.js test runner that lets you develop with confidence.",
 	"license": "MIT",
 	"repository": "avajs/ava",
@@ -16,7 +16,8 @@
 		"lib",
 		"*.js",
 		"!*.config.js",
-		"index.d.ts"
+		"index.d.ts",
+		"*.d.ts"
 	],
 	"keywords": [
 		"🦄",
@@ -75,8 +76,8 @@
 		"concordance": "^5.0.1",
 		"convert-source-map": "^1.7.0",
 		"currently-unhandled": "^0.4.1",
-		"debug": "^4.1.1",
-		"del": "^5.1.0",
+		"debug": "^4.2.0",
+		"del": "^6.0.0",
 		"emittery": "^0.7.1",
 		"equal-length": "^1.0.0",
 		"figures": "^3.2.0",
@@ -85,19 +86,20 @@
 		"import-local": "^3.0.2",
 		"indent-string": "^4.0.0",
 		"is-error": "^2.2.2",
-		"is-plain-object": "^4.1.1",
+		"is-plain-object": "^5.0.0",
 		"is-promise": "^4.0.0",
 		"lodash": "^4.17.20",
 		"matcher": "^3.0.0",
 		"md5-hex": "^3.0.1",
-		"mem": "^6.1.0",
+		"mem": "^6.1.1",
 		"ms": "^2.1.2",
-		"ora": "^5.0.0",
+		"ora": "^5.1.0",
+		"p-event": "^4.2.0",
 		"p-map": "^4.0.0",
 		"picomatch": "^2.2.2",
 		"pkg-conf": "^3.1.0",
 		"plur": "^4.0.0",
-		"pretty-ms": "^7.0.0",
+		"pretty-ms": "^7.0.1",
 		"read-pkg": "^5.2.0",
 		"resolve-cwd": "^3.0.0",
 		"slash": "^3.0.0",
@@ -109,7 +111,7 @@
 		"trim-off-newlines": "^1.0.1",
 		"update-notifier": "^4.1.1",
 		"write-file-atomic": "^3.0.3",
-		"yargs": "^15.4.1"
+		"yargs": "^16.0.3"
 	},
 	"devDependencies": {
 		"@ava/babel": "^1.0.1",
@@ -117,12 +119,12 @@
 		"@babel/plugin-proposal-do-expressions": "^7.10.4",
 		"@sinonjs/fake-timers": "^6.0.1",
 		"ansi-escapes": "^4.3.1",
-		"c8": "^7.3.0",
+		"c8": "^7.3.1",
 		"delay": "^4.4.0",
 		"esm": "^3.2.25",
 		"execa": "^4.0.3",
 		"get-stream": "^6.0.0",
-		"p-event": "^4.2.0",
+		"it-first": "^1.0.4",
 		"proxyquire": "^2.1.3",
 		"react": "^16.13.1",
 		"react-test-renderer": "^16.13.1",
@@ -131,11 +133,11 @@
 		"source-map-fixtures": "^2.1.0",
 		"tap": "^14.10.8",
 		"temp-write": "^4.0.0",
-		"tempy": "^0.6.0",
+		"tempy": "^0.7.1",
 		"touch": "^3.1.0",
 		"tsd": "^0.13.1",
-		"typescript": "^3.9.7",
-		"xo": "^0.33.0",
+		"typescript": "^4.0.3",
+		"xo": "^0.33.1",
 		"zen-observable": "^0.8.15"
 	}
 }

package/plugin.d.ts

@@ -0,0 +1,81 @@
+export namespace SharedWorker {
+	export type ProtocolIdentifier = 'experimental';
+
+	/* eslint-disable @typescript-eslint/method-signature-style */
+	export type FactoryOptions = {
+		negotiateProtocol <Data = unknown>(supported: readonly ['experimental']): Experimental.Protocol<Data>;
+		// Add overloads for additional protocols.
+	};
+	/* eslint-enable @typescript-eslint/method-signature-style */
+
+	export type Factory = (options: FactoryOptions) => void;
+
+	export namespace Experimental {
+		export type Protocol<Data = unknown> = {
+			readonly initialData: Data;
+			readonly protocol: 'experimental';
+			broadcast: (data: Data) => BroadcastMessage<Data>;
+			ready: () => Protocol<Data>;
+			subscribe: () => AsyncIterableIterator<ReceivedMessage<Data>>;
+			testWorkers: () => AsyncIterableIterator<TestWorker<Data>>;
+		};
+
+		export type BroadcastMessage<Data = unknown> = {
+			readonly id: string;
+			replies: () => AsyncIterableIterator<ReceivedMessage<Data>>;
+		};
+
+		export type PublishedMessage<Data = unknown> = {
+			readonly id: string;
+			replies: () => AsyncIterableIterator<ReceivedMessage<Data>>;
+		};
+
+		export type ReceivedMessage<Data = unknown> = {
+			readonly data: Data;
+			readonly id: string;
+			readonly testWorker: TestWorker;
+			reply: (data: Data) => PublishedMessage<Data>;
+		};
+
+		export type TestWorker<Data = unknown> = {
+			readonly id: string;
+			readonly file: string;
+			publish: (data: Data) => PublishedMessage<Data>;
+			subscribe: () => AsyncIterableIterator<ReceivedMessage<Data>>;
+			teardown: <TeardownFn extends () => void> (fn: TeardownFn) => TeardownFn;
+		};
+	}
+
+	export namespace Plugin {
+		export type RegistrationOptions<Identifier extends ProtocolIdentifier, Data = unknown> = {
+			readonly filename: string;
+			readonly initialData?: Data;
+			readonly supportedProtocols: readonly Identifier[];
+			readonly teardown?: () => void;
+		};
+
+		export namespace Experimental {
+			export type Protocol<Data = unknown> = {
+				readonly available: Promise<void>;
+				readonly currentlyAvailable: boolean;
+				readonly protocol: 'experimental';
+				publish: (data: Data) => PublishedMessage<Data>;
+				subscribe: () => AsyncIterableIterator<ReceivedMessage<Data>>;
+			};
+
+			export type PublishedMessage<Data = unknown> = {
+				readonly id: string;
+				replies: () => AsyncIterableIterator<ReceivedMessage<Data>>;
+			};
+
+			export type ReceivedMessage<Data = unknown> = {
+				readonly data: Data;
+				readonly id: string;
+				reply: (data: Data) => PublishedMessage<Data>;
+			};
+		}
+	}
+}
+
+export function registerSharedWorker<Data = unknown>(options: SharedWorker.Plugin.RegistrationOptions<'experimental', Data>): SharedWorker.Plugin.Experimental.Protocol<Data>;
+// Add overloads for additional protocols.