ava 3.12.0 → 3.15.0

package/lib/load-config.js

@@ -1,27 +1,48 @@
 'use strict';
 const fs = require('fs');
 const path = require('path');
+const url = require('url');
 const vm = require('vm');
-const isPlainObject = require('is-plain-object');
+const {isPlainObject} = require('is-plain-object');
 const pkgConf = require('pkg-conf');
 
 const NO_SUCH_FILE = Symbol('no ava.config.js file');
 const MISSING_DEFAULT_EXPORT = Symbol('missing default export');
-const EXPERIMENTS = new Set(['configurableModuleFormat', 'disableSnapshotsInHooks', 'reverseTeardowns']);
+const EXPERIMENTS = new Set([
+	'configurableModuleFormat',
+	'disableNullExpectations',
+	'disableSnapshotsInHooks',
+	'nextGenConfig',
+	'reverseTeardowns',
+	'sharedWorkers'
+]);
 
 // *Very* rudimentary support for loading ava.config.js files containing an `export default` statement.
-const evaluateJsConfig = configFile => {
-	const contents = fs.readFileSync(configFile, 'utf8');
-	const script = new vm.Script(`'use strict';(()=>{let __export__;\n${contents.replace(/export default/g, '__export__ =')};return __export__;})()`, {
+const evaluateJsConfig = (contents, configFile) => {
+	const script = new vm.Script(`'use strict';(()=>{let __export__;\n${contents.toString('utf8').replace(/export default/g, '__export__ =')};return __export__;})()`, {
 		filename: configFile,
 		lineOffset: -1
 	});
-	return {
-		default: script.runInThisContext()
-	};
+	return script.runInThisContext();
 };
 
-const loadJsConfig = ({projectDir, configFile = path.join(projectDir, 'ava.config.js')}) => {
+const importConfig = async ({configFile, fileForErrorMessage}) => {
+	let module;
+	try {
+		module = await import(url.pathToFileURL(configFile)); // eslint-disable-line node/no-unsupported-features/es-syntax
+	} catch (error) {
+		throw Object.assign(new Error(`Error loading ${fileForErrorMessage}: ${error.message}`), {parent: error});
+	}
+
+	const {default: config = MISSING_DEFAULT_EXPORT} = module;
+	if (config === MISSING_DEFAULT_EXPORT) {
+		throw new Error(`${fileForErrorMessage} must have a default export`);
+	}
+
+	return config;
+};
+
+const loadJsConfig = ({projectDir, configFile = path.join(projectDir, 'ava.config.js')}, useImport = false) => {
 	if (!configFile.endsWith('.js')) {
 		return null;
 	}
@@ -30,7 +51,10 @@ const loadJsConfig = ({projectDir, configFile = path.join(projectDir, 'ava.confi
 
 	let config;
 	try {
-		({default: config = MISSING_DEFAULT_EXPORT} = evaluateJsConfig(configFile));
+		const contents = fs.readFileSync(configFile);
+		config = useImport && contents.includes('nonSemVerExperiments') && contents.includes('nextGenConfig') ?
+			importConfig({configFile, fileForErrorMessage}) :
+			evaluateJsConfig(contents, configFile) || MISSING_DEFAULT_EXPORT;
 	} catch (error) {
 		if (error.code === 'ENOENT') {
 			return null;
@@ -63,14 +87,17 @@ const loadCjsConfig = ({projectDir, configFile = path.join(projectDir, 'ava.conf
 	}
 };
 
-const loadMjsConfig = ({projectDir, configFile = path.join(projectDir, 'ava.config.mjs')}) => {
+const loadMjsConfig = ({projectDir, configFile = path.join(projectDir, 'ava.config.mjs')}, experimentally = false) => {
 	if (!configFile.endsWith('.mjs')) {
 		return null;
 	}
 
 	const fileForErrorMessage = path.relative(projectDir, configFile);
 	try {
-		fs.readFileSync(configFile);
+		const contents = fs.readFileSync(configFile);
+		if (experimentally && contents.includes('nonSemVerExperiments') && contents.includes('nextGenConfig')) {
+			return {config: importConfig({configFile, fileForErrorMessage}), fileForErrorMessage};
+		}
 	} catch (error) {
 		if (error.code === 'ENOENT') {
 			return null;
@@ -82,11 +109,7 @@ const loadMjsConfig = ({projectDir, configFile = path.join(projectDir, 'ava.conf
 	throw new Error(`AVA cannot yet load ${fileForErrorMessage} files`);
 };
 
-function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {}} = {}) { // eslint-disable-line complexity
-	let packageConf = pkgConf.sync('ava', {cwd: resolveFrom});
-	const filepath = pkgConf.filepath(packageConf);
-	const projectDir = filepath === null ? resolveFrom : path.dirname(filepath);
-
+function resolveConfigFile(projectDir, configFile) {
 	if (configFile) {
 		configFile = path.resolve(configFile); // Relative to CWD
 		if (path.basename(configFile) !== path.relative(projectDir, configFile)) {
@@ -98,6 +121,15 @@ function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {}} = {
 		}
 	}
 
+	return configFile;
+}
+
+function loadConfigSync({configFile, resolveFrom = process.cwd(), defaults = {}} = {}) {
+	let packageConf = pkgConf.sync('ava', {cwd: resolveFrom});
+	const filepath = pkgConf.filepath(packageConf);
+	const projectDir = filepath === null ? resolveFrom : path.dirname(filepath);
+
+	configFile = resolveConfigFile(projectDir, configFile);
 	const allowConflictWithPackageJson = Boolean(configFile);
 
 	let [{config: fileConf, fileForErrorMessage} = {config: NO_SUCH_FILE, fileForErrorMessage: undefined}, ...conflicting] = [
@@ -157,4 +189,79 @@ function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {}} = {
 	return config;
 }
 
-module.exports = loadConfig;
+exports.loadConfigSync = loadConfigSync;
+
+async function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {}} = {}) {
+	let packageConf = await pkgConf('ava', {cwd: resolveFrom});
+	const filepath = pkgConf.filepath(packageConf);
+	const projectDir = filepath === null ? resolveFrom : path.dirname(filepath);
+
+	configFile = resolveConfigFile(projectDir, configFile);
+	const allowConflictWithPackageJson = Boolean(configFile);
+
+	// TODO: Refactor resolution logic to implement https://github.com/avajs/ava/issues/2285.
+	let [{config: fileConf, fileForErrorMessage} = {config: NO_SUCH_FILE, fileForErrorMessage: undefined}, ...conflicting] = [
+		loadJsConfig({projectDir, configFile}, true),
+		loadCjsConfig({projectDir, configFile}),
+		loadMjsConfig({projectDir, configFile}, true)
+	].filter(result => result !== null);
+
+	if (conflicting.length > 0) {
+		throw new Error(`Conflicting configuration in ${fileForErrorMessage} and ${conflicting.map(({fileForErrorMessage}) => fileForErrorMessage).join(' & ')}`);
+	}
+
+	let sawPromise = false;
+	if (fileConf !== NO_SUCH_FILE) {
+		if (allowConflictWithPackageJson) {
+			packageConf = {};
+		} else if (Object.keys(packageConf).length > 0) {
+			throw new Error(`Conflicting configuration in ${fileForErrorMessage} and package.json`);
+		}
+
+		if (fileConf && typeof fileConf.then === 'function') { // eslint-disable-line promise/prefer-await-to-then
+			sawPromise = true;
+			fileConf = await fileConf;
+		}
+
+		if (!isPlainObject(fileConf) && typeof fileConf !== 'function') {
+			throw new TypeError(`${fileForErrorMessage} must export a plain object or factory function`);
+		}
+
+		if (typeof fileConf === 'function') {
+			fileConf = fileConf({projectDir});
+			if (fileConf && typeof fileConf.then === 'function') { // eslint-disable-line promise/prefer-await-to-then
+				sawPromise = true;
+				fileConf = await fileConf;
+			}
+
+			if (!isPlainObject(fileConf)) {
+				throw new TypeError(`Factory method exported by ${fileForErrorMessage} must return a plain object`);
+			}
+		}
+
+		if ('ava' in fileConf) {
+			throw new Error(`Encountered ’ava’ property in ${fileForErrorMessage}; avoid wrapping the configuration`);
+		}
+	}
+
+	const config = {...defaults, nonSemVerExperiments: {}, ...fileConf, ...packageConf, projectDir};
+
+	const {nonSemVerExperiments: experiments} = config;
+	if (!isPlainObject(experiments)) {
+		throw new Error(`nonSemVerExperiments from ${fileForErrorMessage} must be an object`);
+	}
+
+	for (const key of Object.keys(experiments)) {
+		if (!EXPERIMENTS.has(key)) {
+			throw new Error(`nonSemVerExperiments.${key} from ${fileForErrorMessage} is not a supported experiment`);
+		}
+	}
+
+	if (sawPromise && experiments.nextGenConfig !== true) {
+		throw new Error(`${fileForErrorMessage} exported a promise or an asynchronous factory function. You must enable the ’asyncConfigurationLoading’ experiment for this to work.`);
+	}
+
+	return config;
+}
+
+exports.loadConfig = loadConfig;

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

@@ -0,0 +1,252 @@
+const {EventEmitter, on} = require('events');
+const v8 = require('v8');
+const {workerData, parentPort} = require('worker_threads');
+const pkg = require('../../package.json');
+
+// Used to forward messages received over the `parentPort`. Every subscription
+// adds a listener, so do not enforce any maximums.
+const events = new EventEmitter().setMaxListeners(0);
+
+// Map of active test workers, used in receiveMessages() to get a reference to
+// the TestWorker instance, and relevant release functions.
+const activeTestWorkers = new Map();
+
+class TestWorker {
+	constructor(id, file) {
+		this.id = id;
+		this.file = file;
+	}
+
+	teardown(fn) {
+		let done = false;
+		const teardownFn = async () => {
+			if (done) {
+				return;
+			}
+
+			done = true;
+			if (activeTestWorkers.has(this.id)) {
+				activeTestWorkers.get(this.id).teardownFns.delete(teardownFn);
+			}
+
+			await fn();
+		};
+
+		activeTestWorkers.get(this.id).teardownFns.add(teardownFn);
+
+		return teardownFn;
+	}
+
+	publish(data) {
+		return publishMessage(this, data);
+	}
+
+	async * subscribe() {
+		yield * receiveMessages(this);
+	}
+}
+
+class ReceivedMessage {
+	constructor(testWorker, id, serializedData) {
+		this.testWorker = testWorker;
+		this.id = id;
+		this.data = v8.deserialize(new Uint8Array(serializedData));
+	}
+
+	reply(data) {
+		return publishMessage(this.testWorker, 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(fromTestWorker, replyTo) {
+	for await (const [message] of on(events, 'message')) {
+		if (fromTestWorker !== undefined) {
+			if (message.type === 'deregister-test-worker' && message.id === fromTestWorker.id) {
+				return;
+			}
+
+			if (message.type === 'message' && message.testWorkerId !== fromTestWorker.id) {
+				continue;
+			}
+		}
+
+		if (message.type !== 'message') {
+			continue;
+		}
+
+		if (replyTo === undefined && message.replyTo !== undefined) {
+			continue;
+		}
+
+		if (replyTo !== undefined && message.replyTo !== replyTo) {
+			continue;
+		}
+
+		const active = activeTestWorkers.get(message.testWorkerId);
+		// It is possible for a message to have been buffering for so long — perhaps
+		// due to the caller waiting before iterating to the next message — that the
+		// test worker has been deregistered. Ignore such messages.
+		//
+		// (This is really hard to write a test for, however!)
+		if (active === undefined) {
+			continue;
+		}
+
+		let received = messageCache.get(message);
+		if (received === undefined) {
+			received = new ReceivedMessage(active.instance, message.messageId, message.serializedData);
+			messageCache.set(message, received);
+		}
+
+		yield received;
+	}
+}
+
+let messageCounter = 0;
+const messageIdPrefix = `${workerData.id}/message`;
+const nextMessageId = () => `${messageIdPrefix}/${++messageCounter}`;
+
+function publishMessage(testWorker, data, replyTo) {
+	const id = nextMessageId();
+	parentPort.postMessage({
+		type: 'message',
+		messageId: id,
+		testWorkerId: testWorker.id,
+		serializedData: [...v8.serialize(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)]
+	});
+
+	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;
+	}
+}
+
+let signalAvailable = () => {
+	parentPort.postMessage({type: 'available'});
+	signalAvailable = () => {};
+};
+
+let fatal;
+loadFactory(workerData.filename).then(factory => {
+	if (typeof factory !== 'function') {
+		throw new TypeError(`Missing default factory function export for shared worker plugin at ${workerData.filename}`);
+	}
+
+	factory({
+		negotiateProtocol(supported) {
+			if (!supported.includes('experimental')) {
+				fatal = new Error(`This version of AVA (${pkg.version}) is not compatible with shared worker plugin at ${workerData.filename}`);
+				throw fatal;
+			}
+
+			const produceTestWorker = instance => events.emit('testWorker', instance);
+
+			parentPort.on('message', async message => {
+				if (message.type === 'register-test-worker') {
+					const {id, file} = message;
+					const instance = new TestWorker(id, file);
+
+					activeTestWorkers.set(id, {instance, teardownFns: new Set()});
+
+					produceTestWorker(instance);
+				}
+
+				if (message.type === 'deregister-test-worker') {
+					const {id} = message;
+					const {teardownFns} = activeTestWorkers.get(id);
+					activeTestWorkers.delete(id);
+
+					// Run possibly asynchronous release functions serially, in reverse
+					// order. Any error will crash the worker.
+					for await (const fn of [...teardownFns].reverse()) {
+						await fn();
+					}
+
+					parentPort.postMessage({
+						type: 'deregistered-test-worker',
+						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));
+			});
+
+			return {
+				initialData: workerData.initialData,
+				protocol: 'experimental',
+
+				ready() {
+					signalAvailable();
+					return this;
+				},
+
+				broadcast(data) {
+					return broadcastMessage(data);
+				},
+
+				async * subscribe() {
+					yield * receiveMessages();
+				},
+
+				async * testWorkers() {
+					for await (const [worker] of on(events, 'testWorker')) {
+						yield worker;
+					}
+				}
+			};
+		}
+	});
+}).catch(error => {
+	if (fatal === undefined) {
+		fatal = error;
+	}
+}).finally(() => {
+	if (fatal !== undefined) {
+		process.nextTick(() => {
+			throw fatal;
+		});
+	}
+});

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

@@ -0,0 +1,140 @@
+const events = require('events');
+const serializeError = require('../serialize-error');
+
+let Worker;
+try {
+	({Worker} = require('worker_threads'));
+} 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
+		}
+	});
+	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
+		},
+		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/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/reporters/tap.js

@@ -125,12 +125,22 @@ class TapReporter {
 		this.reportStream.write(`# ${stripAnsi(title)}${os.EOL}`);
 		if (evt.logs) {
 			for (const log of evt.logs) {
-				const logLines = indentString(log, 4).replace(/^ {4}/, '  # ');
+				const logLines = indentString(log, 4).replace(/^ {4}/gm, '#   ');
 				this.reportStream.write(`${logLines}${os.EOL}`);
 			}
 		}
 	}
 
+	writeTimeout(evt) {
+		const err = new Error(`Exited because no new tests completed within the last ${evt.period}ms of inactivity`);
+
+		for (const [testFile, tests] of evt.pendingTests) {
+			for (const title of tests) {
+				this.writeTest({testFile, title, err}, {passed: false, todo: false, skip: false});
+			}
+		}
+	}
+
 	consumeStateChange(evt) { // eslint-disable-line complexity
 		const fileStats = this.stats && evt.testFile ? this.stats.byFile.get(evt.testFile) : null;
 
@@ -172,7 +182,7 @@ class TapReporter {
 				this.writeTest(evt, {passed: true, todo: false, skip: false});
 				break;
 			case 'timeout':
-				this.writeCrash(evt, `Exited because no new tests completed within the last ${evt.period}ms of inactivity`);
+				this.writeTimeout(evt);
 				break;
 			case 'uncaught-exception':
 				this.writeCrash(evt);