ava 3.15.0 → 4.0.0

package/lib/load-config.js

@@ -1,40 +1,17 @@
-'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 pkgConf = require('pkg-conf');
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import url from 'node:url';
+
+import {isPlainObject} from 'is-plain-object';
+import {packageConfig, packageJsonPath} from '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',
-	'disableNullExpectations',
-	'disableSnapshotsInHooks',
-	'nextGenConfig',
-	'reverseTeardowns',
-	'sharedWorkers'
-]);
-
-// *Very* rudimentary support for loading ava.config.js files containing an `export default` statement.
-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 script.runInThisContext();
-};
+const EXPERIMENTS = new Set();
 
 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;
+	const {default: config = MISSING_DEFAULT_EXPORT} = await import(url.pathToFileURL(configFile)); // eslint-disable-line node/no-unsupported-features/es-syntax
 	if (config === MISSING_DEFAULT_EXPORT) {
 		throw new Error(`${fileForErrorMessage} must have a default export`);
 	}
@@ -42,79 +19,22 @@ const importConfig = async ({configFile, fileForErrorMessage}) => {
 	return config;
 };
 
-const loadJsConfig = ({projectDir, configFile = path.join(projectDir, 'ava.config.js')}, useImport = false) => {
-	if (!configFile.endsWith('.js')) {
+const loadConfigFile = async ({projectDir, configFile}) => {
+	if (!fs.existsSync(configFile)) {
 		return null;
 	}
 
 	const fileForErrorMessage = path.relative(projectDir, configFile);
-
-	let config;
 	try {
-		const contents = fs.readFileSync(configFile);
-		config = useImport && contents.includes('nonSemVerExperiments') && contents.includes('nextGenConfig') ?
-			importConfig({configFile, fileForErrorMessage}) :
-			evaluateJsConfig(contents, configFile) || MISSING_DEFAULT_EXPORT;
+		return {config: await importConfig({configFile, fileForErrorMessage}), configFile, fileForErrorMessage};
 	} catch (error) {
-		if (error.code === 'ENOENT') {
-			return null;
-		}
-
 		throw Object.assign(new Error(`Error loading ${fileForErrorMessage}: ${error.message}`), {parent: error});
 	}
-
-	if (config === MISSING_DEFAULT_EXPORT) {
-		throw new Error(`${fileForErrorMessage} must have a default export, using ES module syntax`);
-	}
-
-	return {config, fileForErrorMessage};
-};
-
-const loadCjsConfig = ({projectDir, configFile = path.join(projectDir, 'ava.config.cjs')}) => {
-	if (!configFile.endsWith('.cjs')) {
-		return null;
-	}
-
-	const fileForErrorMessage = path.relative(projectDir, configFile);
-	try {
-		return {config: require(configFile), fileForErrorMessage};
-	} catch (error) {
-		if (error.code === 'MODULE_NOT_FOUND') {
-			return null;
-		}
-
-		throw Object.assign(new Error(`Error loading ${fileForErrorMessage}`), {parent: error});
-	}
 };
 
-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 {
-		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;
-		}
-
-		throw Object.assign(new Error(`Error loading ${fileForErrorMessage}`), {parent: error});
-	}
-
-	throw new Error(`AVA cannot yet load ${fileForErrorMessage} files`);
-};
-
-function resolveConfigFile(projectDir, configFile) {
+function resolveConfigFile(configFile) {
 	if (configFile) {
 		configFile = path.resolve(configFile); // Relative to CWD
-		if (path.basename(configFile) !== path.relative(projectDir, configFile)) {
-			throw new Error('Config files must be located next to the package.json file');
-		}
 
 		if (!configFile.endsWith('.js') && !configFile.endsWith('.cjs') && !configFile.endsWith('.mjs')) {
 			throw new Error('Config files must have .js, .cjs or .mjs extensions');
@@ -124,93 +44,64 @@ function resolveConfigFile(projectDir, configFile) {
 	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);
+const gitScmFile = process.env.AVA_FAKE_SCM_ROOT || '.git';
 
-	configFile = resolveConfigFile(projectDir, configFile);
-	const allowConflictWithPackageJson = Boolean(configFile);
-
-	let [{config: fileConf, fileForErrorMessage} = {config: NO_SUCH_FILE, fileForErrorMessage: undefined}, ...conflicting] = [
-		loadJsConfig({projectDir, configFile}),
-		loadCjsConfig({projectDir, configFile}),
-		loadMjsConfig({projectDir, configFile})
-	].filter(result => result !== null);
+async function findRepoRoot(fromDir) {
+	const {root} = path.parse(fromDir);
+	let dir = fromDir;
+	while (root !== dir) {
+		try {
+			const stat = await fs.promises.stat(path.join(dir, gitScmFile)); // eslint-disable-line no-await-in-loop
+			if (stat.isFile() || stat.isDirectory()) {
+				return dir;
+			}
+		} catch {}
 
-	if (conflicting.length > 0) {
-		throw new Error(`Conflicting configuration in ${fileForErrorMessage} and ${conflicting.map(({fileForErrorMessage}) => fileForErrorMessage).join(' & ')}`);
+		dir = path.dirname(dir);
 	}
 
-	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`);
-		}
+	return root;
+}
 
-		if (fileConf && typeof fileConf.then === 'function') { // eslint-disable-line promise/prefer-await-to-then
-			throw new TypeError(`${fileForErrorMessage} must not export a promise`);
-		}
+export async function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {}} = {}) {
+	let packageConf = await packageConfig('ava', {cwd: resolveFrom});
+	const filepath = packageJsonPath(packageConf);
+	const projectDir = filepath === undefined ? resolveFrom : path.dirname(filepath);
 
-		if (!isPlainObject(fileConf) && typeof fileConf !== 'function') {
-			throw new TypeError(`${fileForErrorMessage} must export a plain object or factory function`);
-		}
+	const repoRoot = await findRepoRoot(projectDir);
 
-		if (typeof fileConf === 'function') {
-			fileConf = fileConf({projectDir});
-			if (fileConf && typeof fileConf.then === 'function') { // eslint-disable-line promise/prefer-await-to-then
-				throw new TypeError(`Factory method exported by ${fileForErrorMessage} must not return a promise`);
-			}
-
-			if (!isPlainObject(fileConf)) {
-				throw new TypeError(`Factory method exported by ${fileForErrorMessage} must return a plain object`);
-			}
-		}
+	// Conflicts are only allowed when an explicit config file is provided.
+	const allowConflictWithPackageJson = Boolean(configFile);
+	configFile = resolveConfigFile(configFile);
 
-		if ('ava' in fileConf) {
-			throw new Error(`Encountered ’ava’ property in ${fileForErrorMessage}; avoid wrapping the configuration`);
+	let fileConf = NO_SUCH_FILE;
+	let fileForErrorMessage;
+	let conflicting = [];
+	if (configFile) {
+		const loaded = await loadConfigFile({projectDir, configFile});
+		if (loaded !== null) {
+			({config: fileConf, fileForErrorMessage} = loaded);
 		}
-	}
+	} else {
+		let searchDir = projectDir;
+		const stopAt = path.dirname(repoRoot);
+		do {
+			const results = await Promise.all([ // eslint-disable-line no-await-in-loop
+				loadConfigFile({projectDir, configFile: path.join(searchDir, 'ava.config.js')}),
+				loadConfigFile({projectDir, configFile: path.join(searchDir, 'ava.config.cjs')}),
+				loadConfigFile({projectDir, configFile: path.join(searchDir, 'ava.config.mjs')}),
+			]);
 
-	const config = {...defaults, nonSemVerExperiments: {}, ...fileConf, ...packageConf, projectDir};
+			[{config: fileConf, fileForErrorMessage, configFile} = {config: NO_SUCH_FILE, fileForErrorMessage: undefined}, ...conflicting] = results.filter(result => result !== null);
 
-	const {nonSemVerExperiments: experiments} = config;
-	if (!isPlainObject(experiments)) {
-		throw new Error(`nonSemVerExperiments from ${fileForErrorMessage} must be an object`);
+			searchDir = path.dirname(searchDir);
+		} while (fileConf === NO_SUCH_FILE && searchDir !== stopAt);
 	}
 
-	for (const key of Object.keys(experiments)) {
-		if (!EXPERIMENTS.has(key)) {
-			throw new Error(`nonSemVerExperiments.${key} from ${fileForErrorMessage} is not a supported experiment`);
-		}
-	}
-
-	return config;
-}
-
-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 = {};
@@ -218,21 +109,12 @@ async function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {
 			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;
-			}
+			fileConf = await fileConf({projectDir});
 
 			if (!isPlainObject(fileConf)) {
 				throw new TypeError(`Factory method exported by ${fileForErrorMessage} must return a plain object`);
@@ -244,7 +126,7 @@ async function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {
 		}
 	}
 
-	const config = {...defaults, nonSemVerExperiments: {}, ...fileConf, ...packageConf, projectDir};
+	const config = {...defaults, nonSemVerExperiments: {}, ...fileConf, ...packageConf, projectDir, configFile};
 
 	const {nonSemVerExperiments: experiments} = config;
 	if (!isPlainObject(experiments)) {
@@ -257,11 +139,5 @@ async function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {
 		}
 	}
 
-	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/module-types.js

@@ -54,12 +54,12 @@ const deriveFromArray = (extensions, defaultModuleType) => {
 	return moduleTypes;
 };
 
-module.exports = (configuredExtensions, defaultModuleType, experiments) => {
+export default function moduleTypes(configuredExtensions, defaultModuleType) {
 	if (configuredExtensions === undefined) {
 		return {
 			cjs: 'commonjs',
 			mjs: 'module',
-			js: defaultModuleType
+			js: defaultModuleType,
 		};
 	}
 
@@ -67,9 +67,5 @@ module.exports = (configuredExtensions, defaultModuleType, experiments) => {
 		return deriveFromArray(configuredExtensions, defaultModuleType);
 	}
 
-	if (!experiments.configurableModuleFormat) {
-		throw new Error('You must enable the `configurableModuleFormat` experiment in order to specify module types');
-	}
-
 	return deriveFromObject(configuredExtensions, defaultModuleType);
-};
+}

package/lib/node-arguments.js

@@ -1,7 +1,8 @@
-'use strict';
-const arrgv = require('arrgv');
+import process from 'node:process';
 
-function normalizeNodeArguments(fromConf = [], fromArgv = '') {
+import arrgv from 'arrgv';
+
+export default function normalizeNodeArguments(fromConf = [], fromArgv = '') {
 	let parsedArgv = [];
 	if (fromArgv !== '') {
 		try {
@@ -13,5 +14,3 @@ function normalizeNodeArguments(fromConf = [], fromArgv = '') {
 
 	return [...process.execArgv, ...fromConf, ...parsedArgv];
 }
-
-module.exports = normalizeNodeArguments;

package/lib/parse-test-args.js

@@ -1,15 +1,26 @@
-'use strict';
-function parseTestArgs(args) {
-	const rawTitle = typeof args[0] === 'string' ? args.shift() : undefined;
-	const receivedImplementationArray = Array.isArray(args[0]);
-	const implementations = receivedImplementationArray ? args.shift() : args.splice(0, 1);
+const buildTitle = (raw, implementation, args) => {
+	let value = implementation && implementation.title ? implementation.title(raw, ...args) : raw;
+	const isValid = typeof value === 'string';
+	if (isValid) {
+		value = value.trim().replace(/\s+/g, ' ');
+	}
 
-	const buildTitle = implementation => {
-		const title = implementation.title ? implementation.title(rawTitle, ...args) : rawTitle;
-		return {title, isSet: typeof title !== 'undefined', isValid: typeof title === 'string', isEmpty: !title};
+	return {
+		raw,
+		value,
+		isSet: value !== undefined,
+		isValid,
+		isEmpty: !isValid || value === '',
 	};
+};
 
-	return {args, buildTitle, implementations, rawTitle, receivedImplementationArray};
-}
+export default function parseTestArgs(args) {
+	const rawTitle = typeof args[0] === 'string' ? args.shift() : undefined;
+	const implementation = args.shift();
 
-module.exports = parseTestArgs;
+	return {
+		args,
+		implementation: implementation && implementation.exec ? implementation.exec : implementation,
+		title: buildTitle(rawTitle, implementation, args),
+	};
+}

package/lib/pkg.cjs

@@ -0,0 +1,2 @@
+'use strict';
+module.exports = require('../package.json');

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

@@ -1,20 +1,30 @@
-const {EventEmitter, on} = require('events');
-const v8 = require('v8');
-const {workerData, parentPort} = require('worker_threads');
-const pkg = require('../../package.json');
+import {EventEmitter, on} from 'node:events';
+import process from 'node:process';
+import {workerData, parentPort, threadId} from 'node:worker_threads';
 
-// Used to forward messages received over the `parentPort`. Every subscription
-// adds a listener, so do not enforce any maximums.
+import pkg from '../pkg.cjs';
+
+// Used to forward messages received over the `parentPort` and any direct ports
+// to test workers. Every subscription adds a listener, so do not enforce any
+// maximums.
 const events = new EventEmitter().setMaxListeners(0);
+const emitMessage = message => {
+	// 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));
+};
 
 // Map of active test workers, used in receiveMessages() to get a reference to
 // the TestWorker instance, and relevant release functions.
 const activeTestWorkers = new Map();
 
+const internalMessagePort = Symbol('Internal MessagePort');
+
 class TestWorker {
-	constructor(id, file) {
+	constructor(id, file, port) {
 		this.id = id;
 		this.file = file;
+		this[internalMessagePort] = port;
 	}
 
 	teardown(fn) {
@@ -47,10 +57,10 @@ class TestWorker {
 }
 
 class ReceivedMessage {
-	constructor(testWorker, id, serializedData) {
+	constructor(testWorker, id, data) {
 		this.testWorker = testWorker;
 		this.id = id;
-		this.data = v8.deserialize(new Uint8Array(serializedData));
+		this.data = data;
 	}
 
 	reply(data) {
@@ -98,7 +108,7 @@ async function * receiveMessages(fromTestWorker, replyTo) {
 
 		let received = messageCache.get(message);
 		if (received === undefined) {
-			received = new ReceivedMessage(active.instance, message.messageId, message.serializedData);
+			received = new ReceivedMessage(active.instance, message.messageId, message.data);
 			messageCache.set(message, received);
 		}
 
@@ -107,59 +117,47 @@ async function * receiveMessages(fromTestWorker, replyTo) {
 }
 
 let messageCounter = 0;
-const messageIdPrefix = `${workerData.id}/message`;
+const messageIdPrefix = `${threadId}/message`;
 const nextMessageId = () => `${messageIdPrefix}/${++messageCounter}`;
 
 function publishMessage(testWorker, data, replyTo) {
 	const id = nextMessageId();
-	parentPort.postMessage({
+	testWorker[internalMessagePort].postMessage({
 		type: 'message',
 		messageId: id,
-		testWorkerId: testWorker.id,
-		serializedData: [...v8.serialize(data)],
-		replyTo
+		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)]
-	});
+	for (const trackedWorker of activeTestWorkers.values()) {
+		trackedWorker.instance[internalMessagePort].postMessage({
+			type: 'message',
+			messageId: id,
+			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;
-	}
+	const {default: factory} = await import(workerData.filename); // eslint-disable-line node/no-unsupported-features/es-syntax
+	return factory;
 }
 
 let signalAvailable = () => {
@@ -175,7 +173,7 @@ loadFactory(workerData.filename).then(factory => {
 
 	factory({
 		negotiateProtocol(supported) {
-			if (!supported.includes('experimental')) {
+			if (!supported.includes('ava-4')) {
 				fatal = new Error(`This version of AVA (${pkg.version}) is not compatible with shared worker plugin at ${workerData.filename}`);
 				throw fatal;
 			}
@@ -184,12 +182,13 @@ loadFactory(workerData.filename).then(factory => {
 
 			parentPort.on('message', async message => {
 				if (message.type === 'register-test-worker') {
-					const {id, file} = message;
-					const instance = new TestWorker(id, file);
+					const {id, file, port} = message;
+					const instance = new TestWorker(id, file, port);
 
 					activeTestWorkers.set(id, {instance, teardownFns: new Set()});
 
 					produceTestWorker(instance);
+					port.on('message', message => emitMessage({testWorkerId: id, ...message}));
 				}
 
 				if (message.type === 'deregister-test-worker') {
@@ -205,18 +204,16 @@ loadFactory(workerData.filename).then(factory => {
 
 					parentPort.postMessage({
 						type: 'deregistered-test-worker',
-						id
+						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));
+					emitMessage(message);
+				}
 			});
 
 			return {
 				initialData: workerData.initialData,
-				protocol: 'experimental',
+				protocol: 'ava-4',
 
 				ready() {
 					signalAvailable();
@@ -235,9 +232,9 @@ loadFactory(workerData.filename).then(factory => {
 					for await (const [worker] of on(events, 'testWorker')) {
 						yield worker;
 					}
-				}
+				},
 			};
-		}
+		},
 	});
 }).catch(error => {
 	if (fatal === undefined) {