ava 5.3.1 → 6.0.0

package/lib/cli.js

@@ -1,30 +1,25 @@
-
 import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
+import v8 from 'node:v8';
 
 import arrify from 'arrify';
-import ciParallelVars from 'ci-parallel-vars';
 import figures from 'figures';
 import yargs from 'yargs';
-import {hideBin} from 'yargs/helpers'; // eslint-disable-line n/file-extension-in-import
+import {hideBin} from 'yargs/helpers';
 
+import {asyncEventIteratorFromApi} from './api-event-iterator.js';
 import Api from './api.js';
 import {chalk} from './chalk.js';
 import validateEnvironmentVariables from './environment-variables.js';
 import normalizeExtensions from './extensions.js';
 import {normalizeGlobs, normalizePattern} from './globs.js';
-import {controlFlow} from './ipc-flow-control.cjs';
 import isCi from './is-ci.js';
 import {splitPatternAndLineNumbers} from './line-numbers.js';
 import {loadConfig} from './load-config.js';
 import normalizeModuleTypes from './module-types.js';
 import normalizeNodeArguments from './node-arguments.js';
 import pkg from './pkg.cjs';
-import providerManager from './provider-manager.js';
-import DefaultReporter from './reporters/default.js';
-import TapReporter from './reporters/tap.js';
-import Watcher from './watcher.js';
 
 function exit(message) {
 	console.error(`\n  ${chalk.red(figures.cross)} ${message}`);
@@ -174,7 +169,7 @@ export default async function loadCli() { // eslint-disable-line complexity
 			type: 'string',
 		}), argv => {
 			if (activeInspector) {
-				debug.files = argv.pattern || [];
+				debug.files = argv.pattern ?? [];
 			}
 		})
 		.command(
@@ -224,7 +219,7 @@ export default async function loadCli() { // eslint-disable-line complexity
 	const combined = {...conf};
 
 	for (const flag of Object.keys(FLAGS)) {
-		if (flag === 'no-worker-threads' && Reflect.has(argv, 'worker-threads')) {
+		if (flag === 'no-worker-threads' && Object.hasOwn(argv, 'worker-threads')) {
 			combined.workerThreads = argv['worker-threads'];
 			continue;
 		}
@@ -284,7 +279,7 @@ export default async function loadCli() { // eslint-disable-line complexity
 
 			process.exit(0); // eslint-disable-line unicorn/no-process-exit
 		} catch (error) {
-			exit(`Error removing AVA cache files in ${cacheDir}\n\n${chalk.gray((error && error.stack) || error)}`);
+			exit(`Error removing AVA cache files in ${cacheDir}\n\n${chalk.gray(error?.stack ?? error)}`);
 		}
 	}
 
@@ -297,7 +292,7 @@ export default async function loadCli() { // eslint-disable-line complexity
 			exit('Watch mode is not available in CI, as it prevents AVA from terminating.');
 		}
 
-		if (debug !== null) {
+		if (debug !== null && !process.env.TEST_AVA) {
 			exit('Watch mode is not available when debugging.');
 		}
 	}
@@ -316,32 +311,24 @@ export default async function loadCli() { // eslint-disable-line complexity
 		}
 	}
 
-	if (Reflect.has(combined, 'concurrency') && (!Number.isInteger(combined.concurrency) || combined.concurrency < 0)) {
-		exit('The --concurrency or -c flag must be provided with a nonnegative integer.');
-	}
-
-	if (!combined.tap && Object.keys(experiments).length > 0) {
-		console.log(chalk.magenta(`  ${figures.warning} Experiments are enabled. These are unsupported and may change or be removed at any time.`));
+	if (Object.hasOwn(combined, 'concurrency') && (!Number.isInteger(combined.concurrency) || combined.concurrency < 0)) {
+		exit('The --concurrency or -c flag must be provided with a non-negative integer.');
 	}
 
-	if (Reflect.has(conf, 'babel')) {
-		exit('Built-in Babel support has been removed.');
-	}
-
-	if (Reflect.has(conf, 'compileEnhancements')) {
-		exit('Enhancement compilation must be configured in AVA’s Babel options.');
+	if (Object.hasOwn(conf, 'sortTestFiles') && typeof conf.sortTestFiles !== 'function') {
+		exit('’sortTestFiles’ must be a comparator function.');
 	}
 
-	if (Reflect.has(conf, 'helpers')) {
-		exit('AVA no longer compiles helpers. Add exclusion patterns to the ’files’ configuration and specify ’compileAsTests’ in the Babel options instead.');
+	if (Object.hasOwn(conf, 'watch')) {
+		exit('’watch’ must not be configured, use the --watch CLI flag instead.');
 	}
 
-	if (Reflect.has(conf, 'sources')) {
-		exit('’sources’ has been removed. Use ’ignoredByWatcher’ to provide glob patterns of files that the watcher should ignore.');
+	if (Object.hasOwn(conf, 'ignoredByWatcher')) {
+		exit('’ignoredByWatcher’ has moved to ’watchMode.ignoreChanges’.');
 	}
 
-	if (Reflect.has(conf, 'sortTestFiles') && typeof conf.sortTestFiles !== 'function') {
-		exit('’sortTestFiles’ must be a comparator function.');
+	if (!combined.tap && Object.keys(experiments).length > 0) {
+		console.log(chalk.magenta(`  ${figures.warning} Experiments are enabled. These are unsupported and may change or be removed at any time.`));
 	}
 
 	let projectPackageObject;
@@ -353,14 +340,16 @@ export default async function loadCli() { // eslint-disable-line complexity
 		}
 	}
 
-	const {type: defaultModuleType = 'commonjs'} = projectPackageObject || {};
+	const {type: defaultModuleType = 'commonjs'} = projectPackageObject ?? {};
 
 	const providers = [];
-	if (Reflect.has(conf, 'typescript')) {
+	if (Object.hasOwn(conf, 'typescript')) {
+		const {default: providerManager} = await import('./provider-manager.js');
 		try {
-			const {level, main} = await providerManager.typescript(projectDir);
+			const {identifier: protocol, level, main} = await providerManager.typescript(projectDir);
 			providers.push({
 				level,
+				protocol,
 				main: main({config: conf.typescript}),
 				type: 'typescript',
 			});
@@ -392,7 +381,7 @@ export default async function loadCli() { // eslint-disable-line complexity
 
 	let globs;
 	try {
-		globs = normalizeGlobs({files: conf.files, ignoredByWatcher: conf.ignoredByWatcher, extensions, providers});
+		globs = normalizeGlobs({files: conf.files, ignoredByWatcher: conf.watchMode?.ignoreChanges, extensions, providers});
 	} catch (error) {
 		exit(error.message);
 	}
@@ -405,14 +394,17 @@ export default async function loadCli() { // eslint-disable-line complexity
 	}
 
 	let parallelRuns = null;
-	if (isCi && ciParallelVars && combined.utilizeParallelBuilds !== false) {
-		const {index: currentIndex, total: totalRuns} = ciParallelVars;
-		parallelRuns = {currentIndex, totalRuns};
+	if (isCi && combined.utilizeParallelBuilds !== false) {
+		const {default: ciParallelVars} = await import('ci-parallel-vars');
+		if (ciParallelVars) {
+			const {index: currentIndex, total: totalRuns} = ciParallelVars;
+			parallelRuns = {currentIndex, totalRuns};
+		}
 	}
 
 	const match = combined.match === '' ? [] : arrify(combined.match);
 
-	const input = debug ? debug.files : (argv.pattern || []);
+	const input = debug ? debug.files : (argv.pattern ?? []);
 	const filter = input
 		.map(pattern => splitPatternAndLineNumbers(pattern))
 		.map(({pattern, ...rest}) => ({
@@ -423,7 +415,7 @@ export default async function loadCli() { // eslint-disable-line complexity
 	const api = new Api({
 		cacheEnabled: combined.cache !== false,
 		chalkOptions,
-		concurrency: combined.concurrency || 0,
+		concurrency: combined.concurrency ?? 0,
 		workerThreads: combined.workerThreads !== false,
 		debug,
 		environmentVariables,
@@ -443,36 +435,58 @@ export default async function loadCli() { // eslint-disable-line complexity
 		require: arrify(combined.require),
 		serial: combined.serial,
 		snapshotDir: combined.snapshotDir ? path.resolve(projectDir, combined.snapshotDir) : null,
-		timeout: combined.timeout || '10s',
+		timeout: combined.timeout ?? '10s',
 		updateSnapshots: combined.updateSnapshots,
 		workerArgv: argv['--'],
 	});
 
-	const reporter = combined.tap && !combined.watch && debug === null ? new TapReporter({
-		extensions: globs.extensions,
-		projectDir,
-		reportStream: process.stdout,
-		stdStream: process.stderr,
-	}) : new DefaultReporter({
-		extensions: globs.extensions,
-		projectDir,
-		reportStream: process.stdout,
-		stdStream: process.stderr,
-		watching: combined.watch,
-	});
-
-	api.on('run', plan => {
-		reporter.startRun(plan);
+	let reporter;
+	if (combined.tap && !argv.watch && debug === null) {
+		const {default: TapReporter} = await import('./reporters/tap.js');
+		reporter = new TapReporter({
+			extensions: globs.extensions,
+			projectDir,
+			reportStream: process.stdout,
+			stdStream: process.stderr,
+		});
+	} else {
+		const {default: Reporter} = await import('./reporters/default.js');
+		reporter = new Reporter({
+			extensions: globs.extensions,
+			projectDir,
+			reportStream: process.stdout,
+			stdStream: process.stderr,
+			watching: argv.watch,
+		});
+	}
 
-		if (process.env.AVA_EMIT_RUN_STATUS_OVER_IPC === 'I\'ll find a payphone baby / Take some time to talk to you') {
-			const bufferedSend = controlFlow(process);
+	if (process.env.TEST_AVA) {
+		const {controlFlow} = await import('./ipc-flow-control.cjs');
+		const bufferedSend = controlFlow(process);
 
+		api.on('run', plan => {
 			plan.status.on('stateChange', evt => {
 				bufferedSend(evt);
 			});
-		}
+		});
+	}
+
+	if (combined.observeRun && experiments.observeRunsFromConfig) {
+		combined.observeRun({
+			events: asyncEventIteratorFromApi(api),
+		});
+	}
+
+	api.on('run', plan => {
+		reporter.startRun(plan);
 
 		plan.status.on('stateChange', evt => {
+			if (evt.type === 'end' || evt.type === 'interrupt') {
+				// Write out code coverage data when the run ends, lest a process
+				// interrupt causes it to be lost.
+				v8.takeCoverage();
+			}
+
 			if (evt.type === 'interrupt') {
 				reporter.endRun();
 				process.exit(1); // eslint-disable-line unicorn/no-process-exit
@@ -480,16 +494,36 @@ export default async function loadCli() { // eslint-disable-line complexity
 		});
 	});
 
-	if (combined.watch) {
-		const watcher = new Watcher({
+	if (argv.watch) {
+		const {available, start} = await import('./watcher.js');
+		if (!available(projectDir)) {
+			exit('Watch mode requires support for recursive fs.watch()');
+			return;
+		}
+
+		let abortController;
+		if (process.env.TEST_AVA) {
+			const {takeCoverage} = await import('node:v8');
+			abortController = new AbortController();
+			process.on('message', message => {
+				if (message === 'abort-watcher') {
+					abortController.abort();
+					takeCoverage();
+				}
+			});
+			process.channel?.unref();
+		}
+
+		start({
 			api,
 			filter,
 			globs,
 			projectDir,
 			providers,
 			reporter,
+			stdin: process.stdin,
+			signal: abortController.signal,
 		});
-		watcher.observeStdin(process.stdin);
 	} else {
 		let debugWithoutSpecificFile = false;
 		api.on('run', plan => {

package/lib/code-excerpt.js

@@ -8,13 +8,13 @@ import {chalk} from './chalk.js';
 const formatLineNumber = (lineNumber, maxLineNumber) =>
 	' '.repeat(Math.max(0, String(maxLineNumber).length - String(lineNumber).length)) + lineNumber;
 
-export default function exceptCode(source, options = {}) {
+export default function excerptCode(source, options = {}) {
 	if (!source.isWithinProject || source.isDependency) {
 		return null;
 	}
 
 	const {file, line} = source;
-	const maxWidth = options.maxWidth || 80;
+	const maxWidth = (options.maxWidth ?? 0) || 80;
 
 	let contents;
 	try {

package/lib/eslint-plugin-helper-worker.js

@@ -12,8 +12,8 @@ const configCache = new Map();
 
 const collectProviders = async ({conf, projectDir}) => {
 	const providers = [];
-	if (Reflect.has(conf, 'typescript')) {
-		const {level, main} = await providerManager.typescript(projectDir);
+	if (Object.hasOwn(conf, 'typescript')) {
+		const {level, main} = await providerManager.typescript(projectDir, {fullConfig: conf});
 		providers.push({
 			level,
 			main: main({config: conf.typescript}),
@@ -33,7 +33,7 @@ const buildGlobs = ({conf, providers, projectDir, overrideExtensions, overrideFi
 		cwd: projectDir,
 		...normalizeGlobs({
 			extensions,
-			files: overrideFiles || conf.files,
+			files: overrideFiles ?? conf.files,
 			providers,
 		}),
 	};

package/lib/fork.js

@@ -4,10 +4,9 @@ import {fileURLToPath} from 'node:url';
 import {Worker} from 'node:worker_threads';
 
 import Emittery from 'emittery';
-import {pEvent} from 'p-event';
 
 import {controlFlow} from './ipc-flow-control.cjs';
-import serializeError from './serialize-error.js';
+import serializeError, {tagWorkerError} from './serialize-error.js';
 
 let workerPath = new URL('worker/base.js', import.meta.url);
 export function _testOnlyReplaceWorkerPath(replacement) {
@@ -35,13 +34,8 @@ const createWorker = (options, execArgv) => {
 		});
 		postMessage = worker.postMessage.bind(worker);
 
-		// Ensure we've seen this event before we terminate the worker thread, as a
-		// workaround for https://github.com/nodejs/node/issues/38418.
-		const starting = pEvent(worker, 'message', ({ava}) => ava && ava.type === 'starting');
-
 		close = async () => {
 			try {
-				await starting;
 				await worker.terminate();
 			} finally {
 				// No-op
@@ -53,6 +47,7 @@ const createWorker = (options, execArgv) => {
 			silent: true,
 			env: {NODE_ENV: 'test', ...process.env, ...options.environmentVariables},
 			execArgv: [...execArgv, ...additionalExecArgv],
+			serialization: 'advanced',
 		});
 		postMessage = controlFlow(worker);
 		close = async () => worker.kill();
@@ -127,11 +122,6 @@ export default function loadFork(file, options, execArgv = process.execArgv) {
 					break;
 				}
 
-				case 'ping': {
-					send({type: 'pong'});
-					break;
-				}
-
 				default: {
 					emitStateChange(message.ava);
 				}
@@ -139,7 +129,7 @@ export default function loadFork(file, options, execArgv = process.execArgv) {
 		});
 
 		worker.on('error', error => {
-			emitStateChange({type: 'worker-failed', err: serializeError('Worker error', false, error, file)});
+			emitStateChange({type: 'worker-failed', err: serializeError(tagWorkerError(error))});
 			finish();
 		});
 

package/lib/glob-helpers.cjs

@@ -16,8 +16,6 @@ const defaultPicomatchIgnorePatterns = [
 	...defaultIgnorePatterns.map(pattern => `${pattern}/**/*`),
 ];
 
-const defaultMatchNoIgnore = picomatch(defaultPicomatchIgnorePatterns);
-
 const matchingCache = new WeakMap();
 const processMatchingPatterns = input => {
 	let result = matchingCache.get(input);
@@ -46,15 +44,9 @@ const processMatchingPatterns = input => {
 
 exports.processMatchingPatterns = processMatchingPatterns;
 
-const matchesIgnorePatterns = (file, patterns) => {
-	const {matchNoIgnore} = processMatchingPatterns(patterns);
-	return matchNoIgnore(file) || defaultMatchNoIgnore(file);
-};
-
-function classify(file, {cwd, extensions, filePatterns, ignoredByWatcherPatterns}) {
+function classify(file, {cwd, extensions, filePatterns}) {
 	file = normalizeFileForMatching(cwd, file);
 	return {
-		isIgnoredByWatcher: matchesIgnorePatterns(file, ignoredByWatcherPatterns),
 		isTest: hasExtension(extensions, file) && !isHelperish(file) && filePatterns.length > 0 && matches(file, filePatterns),
 	};
 }

package/lib/globs.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 import {globby, globbySync} from 'globby';
+import picomatch from 'picomatch';
 
 import {
 	defaultIgnorePatterns,
@@ -26,6 +27,7 @@ const defaultIgnoredByWatcherPatterns = [
 	'**/*.snap.md', // No need to rerun tests when the Markdown files change.
 	'ava.config.js', // Config is not reloaded so avoid rerunning tests when it changes.
 	'ava.config.cjs', // Config is not reloaded so avoid rerunning tests when it changes.
+	'ava.config.mjs', // Config is not reloaded so avoid rerunning tests when it changes.
 ];
 
 const buildExtensionPattern = extensions => extensions.length === 1 ? extensions[0] : `{${extensions.join(',')}}`;
@@ -36,7 +38,7 @@ export function normalizeGlobs({extensions, files: filePatterns, ignoredByWatche
 	}
 
 	if (ignoredByWatcherPatterns !== undefined && (!Array.isArray(ignoredByWatcherPatterns) || ignoredByWatcherPatterns.length === 0)) {
-		throw new Error('The ’ignoredByWatcher’ configuration must be an array containing glob patterns.');
+		throw new Error('The ’watchMode.ignoreChanges’ configuration must be an array containing glob patterns.');
 	}
 
 	const extensionPattern = buildExtensionPattern(extensions);
@@ -125,11 +127,13 @@ export async function findTests({cwd, extensions, filePatterns}) {
 	return files.filter(file => !path.basename(file).startsWith('_'));
 }
 
-export function getChokidarIgnorePatterns({ignoredByWatcherPatterns}) {
-	return [
+export function buildIgnoreMatcher({ignoredByWatcherPatterns}) {
+	const patterns = [
 		...defaultIgnorePatterns.map(pattern => `${pattern}/**/*`),
 		...ignoredByWatcherPatterns.filter(pattern => !pattern.startsWith('!')),
 	];
+
+	return picomatch(patterns, {dot: true});
 }
 
 export function applyTestFileFilter({ // eslint-disable-line complexity

package/lib/line-numbers.js

@@ -13,7 +13,7 @@ const sortNumbersAscending = array => {
 };
 
 const parseNumber = string => Number.parseInt(string, 10);
-const removeAllWhitespace = string => string.replace(/\s/g, '');
+const removeAllWhitespace = string => string.replaceAll(/\s/g, '');
 const range = (start, end) => Array.from({length: end - start + 1}).fill(start).map((element, index) => element + index);
 
 const parseLineNumbers = suffix => sortNumbersAscending(distinctArray(

package/lib/load-config.js

@@ -4,11 +4,11 @@ import process from 'node:process';
 import url from 'node:url';
 
 import {isPlainObject} from 'is-plain-object';
-import {packageConfig, packageJsonPath} from 'pkg-conf';
+import {packageConfig, packageJsonPath} from 'package-config';
 
 const NO_SUCH_FILE = Symbol('no ava.config.js file');
 const MISSING_DEFAULT_EXPORT = Symbol('missing default export');
-const EXPERIMENTS = new Set();
+const EXPERIMENTS = new Set(['observeRunsFromConfig']);
 
 const importConfig = async ({configFile, fileForErrorMessage}) => {
 	const {default: config = MISSING_DEFAULT_EXPORT} = await import(url.pathToFileURL(configFile));
@@ -41,7 +41,7 @@ function resolveConfigFile(configFile) {
 	return configFile;
 }
 
-const gitScmFile = process.env.AVA_FAKE_SCM_ROOT || '.git';
+const gitScmFile = process.env.AVA_FAKE_SCM_ROOT ?? '.git';
 
 async function findRepoRoot(fromDir) {
 	const {root} = path.parse(fromDir);

package/lib/parse-test-args.js

@@ -1,8 +1,8 @@
 const buildTitle = (raw, implementation, args) => {
-	let value = implementation && implementation.title ? implementation.title(raw, ...args) : raw;
+	let value = implementation?.title?.(raw, ...args) ?? raw;
 	const isValid = typeof value === 'string';
 	if (isValid) {
-		value = value.trim().replace(/\s+/g, ' ');
+		value = value.trim().replaceAll(/\s+/g, ' ');
 	}
 
 	return {
@@ -20,7 +20,7 @@ export default function parseTestArgs(args) {
 
 	return {
 		args,
-		implementation: implementation && implementation.exec ? implementation.exec : implementation,
+		implementation: implementation?.exec ?? implementation,
 		title: buildTitle(rawTitle, implementation, args),
 	};
 }

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

@@ -2,7 +2,7 @@ import events from 'node:events';
 import {pathToFileURL} from 'node:url';
 import {Worker} from 'node:worker_threads';
 
-import serializeError from '../serialize-error.js';
+import serializeError, {tagWorkerError} from '../serialize-error.js';
 
 const LOADER = new URL('shared-worker-loader.js', import.meta.url);
 
@@ -34,7 +34,7 @@ function launchWorker(filename, initialData) {
 	const launched = {
 		statePromises: {
 			available: waitForAvailable(worker),
-			error: events.once(worker, 'error').then(([error]) => error),
+			error: events.once(worker, 'error').then(([error]) => tagWorkerError(error)),
 		},
 		exited: false,
 		worker,
@@ -97,14 +97,14 @@ export async function observeWorkerProcess(fork, runStatus) {
 		launched.statePromises.error.then(error => {
 			launched.worker.off('message', handleWorkerMessage);
 			removeAllInstances();
-			runStatus.emitStateChange({type: 'shared-worker-error', err: serializeError('Shared worker error', true, error)});
+			runStatus.emitStateChange({type: 'shared-worker-error', err: serializeError(error)});
 			signalError();
 		});
 
 		try {
 			await launched.statePromises.available;
 
-			port.postMessage({type: 'ready'});
+			port.postMessage({ava: {type: 'ready'}});
 
 			launched.worker.postMessage({
 				type: 'register-test-worker',

package/lib/provider-manager.js

@@ -1,19 +1,17 @@
 import * as globs from './globs.js';
 import pkg from './pkg.cjs';
 
-const levels = {
+export const levels = {
 	// As the protocol changes, comparing levels by integer allows AVA to be
-	// compatible with different versions. Currently there is only one supported
-	// version, so this is effectively unused. The infrastructure is retained for
-	// future use.
-	levelIntegersAreCurrentlyUnused: 0,
+	// compatible with different versions.
+	ava6: 1,
 };
 
-const levelsByProtocol = {
-	'ava-3.2': levels.levelIntegersAreCurrentlyUnused,
-};
+const levelsByProtocol = Object.assign(Object.create(null), {
+	'ava-6': levels.ava6,
+});
 
-async function load(providerModule, projectDir) {
+async function load(providerModule, projectDir, selectProtocol = () => true) {
 	const ava = {version: pkg.version};
 	const {default: makeProvider} = await import(providerModule);
 
@@ -21,7 +19,8 @@ async function load(providerModule, projectDir) {
 	let level;
 	const provider = makeProvider({
 		negotiateProtocol(identifiers, {version}) {
-			const identifier = identifiers.find(identifier => Reflect.has(levelsByProtocol, identifier));
+			const identifier = identifiers
+				.find(identifier => selectProtocol(identifier) && Object.hasOwn(levelsByProtocol, identifier));
 
 			if (identifier === undefined) {
 				fatal = new Error(`This version of AVA (${ava.version}) is not compatible with ${providerModule}@${version}`);
@@ -50,9 +49,8 @@ async function load(providerModule, projectDir) {
 }
 
 const providerManager = {
-	levels,
-	async typescript(projectDir) {
-		return load('@ava/typescript', projectDir);
+	async typescript(projectDir, {protocol} = {}) {
+		return load('@ava/typescript', projectDir, identifier => protocol === undefined || identifier === protocol);
 	},
 };
 

package/lib/reporters/beautify-stack.js

@@ -4,7 +4,6 @@ const stackUtils = new StackUtils({
 	ignoredPackages: [
 		'@ava/typescript',
 		'ava',
-		'nyc',
 	],
 	internals: [
 		// AVA internals, which ignoredPackages don't ignore when we run our own unit tests.