ava 3.15.0 → 4.0.0

package/lib/concordance-options.js

@@ -1,37 +1,32 @@
-'use strict';
-const util = require('util'); // eslint-disable-line unicorn/import-style
-const ansiStyles = require('ansi-styles');
-const stripAnsi = require('strip-ansi');
-const cloneDeepWith = require('lodash/cloneDeepWith');
-const reactPlugin = require('@concordance/react');
-const chalk = require('./chalk').get();
+import {inspect} from 'node:util';
 
-// Wrap Concordance's React plugin. Change the name to avoid collisions if in
-// the future users can register plugins themselves.
-const avaReactPlugin = {...reactPlugin, name: 'ava-plugin-react'};
-const plugins = [avaReactPlugin];
+import ansiStyles from 'ansi-styles';
+import {Chalk} from 'chalk'; // eslint-disable-line unicorn/import-style
+import stripAnsi from 'strip-ansi';
 
-const forceColor = new chalk.Instance({level: Math.max(chalk.level, 1)});
+import {chalk} from './chalk.js';
+
+const forceColor = new Chalk({level: Math.max(chalk.level, 1)});
 
 const colorTheme = {
 	boolean: ansiStyles.yellow,
 	circular: forceColor.grey('[Circular]'),
 	date: {
 		invalid: forceColor.red('invalid'),
-		value: ansiStyles.blue
+		value: ansiStyles.blue,
 	},
 	diffGutters: {
 		actual: forceColor.red('-') + ' ',
 		expected: forceColor.green('+') + ' ',
-		padding: '  '
+		padding: '  ',
 	},
 	error: {
 		ctor: {open: ansiStyles.grey.open + '(', close: ')' + ansiStyles.grey.close},
-		name: ansiStyles.magenta
+		name: ansiStyles.magenta,
 	},
 	function: {
 		name: ansiStyles.blue,
-		stringTag: ansiStyles.magenta
+		stringTag: ansiStyles.magenta,
 	},
 	global: ansiStyles.magenta,
 	item: {after: forceColor.grey(',')},
@@ -45,44 +40,16 @@ const colorTheme = {
 		closeBracket: forceColor.grey('}'),
 		ctor: ansiStyles.magenta,
 		stringTag: {open: ansiStyles.magenta.open + '@', close: ansiStyles.magenta.close},
-		secondaryStringTag: {open: ansiStyles.grey.open + '@', close: ansiStyles.grey.close}
+		secondaryStringTag: {open: ansiStyles.grey.open + '@', close: ansiStyles.grey.close},
 	},
 	property: {
 		after: forceColor.grey(','),
 		keyBracket: {open: forceColor.grey('['), close: forceColor.grey(']')},
-		valueFallback: forceColor.grey('…')
-	},
-	react: {
-		functionType: forceColor.grey('\u235F'),
-		openTag: {
-			start: forceColor.grey('<'),
-			end: forceColor.grey('>'),
-			selfClose: forceColor.grey('/'),
-			selfCloseVoid: ' ' + forceColor.grey('/')
-		},
-		closeTag: {
-			open: forceColor.grey('</'),
-			close: forceColor.grey('>')
-		},
-		tagName: ansiStyles.magenta,
-		attribute: {
-			separator: '=',
-			value: {
-				openBracket: forceColor.grey('{'),
-				closeBracket: forceColor.grey('}'),
-				string: {
-					line: {open: forceColor.blue('"'), close: forceColor.blue('"'), escapeQuote: '"'}
-				}
-			}
-		},
-		child: {
-			openBracket: forceColor.grey('{'),
-			closeBracket: forceColor.grey('}')
-		}
+		valueFallback: forceColor.grey('…'),
 	},
 	regexp: {
 		source: {open: ansiStyles.blue.open + '/', close: '/' + ansiStyles.blue.close},
-		flags: ansiStyles.yellow
+		flags: ansiStyles.yellow,
 	},
 	stats: {separator: forceColor.grey('---')},
 	string: {
@@ -94,45 +61,42 @@ const colorTheme = {
 		diff: {
 			insert: {
 				open: ansiStyles.bgGreen.open + ansiStyles.black.open,
-				close: ansiStyles.black.close + ansiStyles.bgGreen.close
+				close: ansiStyles.black.close + ansiStyles.bgGreen.close,
 			},
 			delete: {
 				open: ansiStyles.bgRed.open + ansiStyles.black.open,
-				close: ansiStyles.black.close + ansiStyles.bgRed.close
+				close: ansiStyles.black.close + ansiStyles.bgRed.close,
 			},
 			equal: ansiStyles.blue,
 			insertLine: {
 				open: ansiStyles.green.open,
-				close: ansiStyles.green.close
+				close: ansiStyles.green.close,
 			},
 			deleteLine: {
 				open: ansiStyles.red.open,
-				close: ansiStyles.red.close
-			}
-		}
+				close: ansiStyles.red.close,
+			},
+		},
 	},
 	symbol: ansiStyles.yellow,
 	typedArray: {
-		bytes: ansiStyles.yellow
+		bytes: ansiStyles.yellow,
 	},
-	undefined: ansiStyles.yellow
+	undefined: ansiStyles.yellow,
 };
 
-const plainTheme = cloneDeepWith(colorTheme, value => {
-	if (typeof value === 'string') {
-		return stripAnsi(value);
-	}
-});
+const plainTheme = JSON.parse(JSON.stringify(colorTheme), value => typeof value === 'string' ? stripAnsi(value) : value);
 
 const theme = chalk.level > 0 ? colorTheme : plainTheme;
 
-exports.default = {
+const concordanceOptions = {
 	// Use Node's object inspection depth, clamped to a minimum of 3
 	get maxDepth() {
-		return Math.max(3, util.inspect.defaultOptions.depth);
+		return Math.max(3, inspect.defaultOptions.depth);
 	},
-	plugins,
-	theme
+	theme,
 };
 
-exports.snapshotManager = {plugins, theme: plainTheme};
+export default concordanceOptions;
+
+export const snapshotManager = {theme: plainTheme};

package/lib/context-ref.js

@@ -1,7 +1,4 @@
-'use strict';
-const clone = require('lodash/clone');
-
-class ContextRef {
+export default class ContextRef {
 	constructor() {
 		this.value = {};
 	}
@@ -18,7 +15,6 @@ class ContextRef {
 		return new LateBinding(this);
 	}
 }
-module.exports = ContextRef;
 
 class LateBinding extends ContextRef {
 	constructor(ref) {
@@ -29,7 +25,8 @@ class LateBinding extends ContextRef {
 
 	get() {
 		if (!this.bound) {
-			this.set(clone(this.ref.get()));
+			const value = this.ref.get();
+			this.set(value !== null && typeof value === 'object' ? {...value} : value);
 		}
 
 		return super.get();

package/lib/create-chain.js

@@ -1,4 +1,3 @@
-'use strict';
 const chainRegistry = new WeakMap();
 
 function startChain(name, call, defaults) {
@@ -48,20 +47,16 @@ function createHookChain(hook, isAfterHook) {
 	// * `skip` must come at the end
 	// * no `only`
 	// * no repeating
-	extendChain(hook, 'cb', 'callback');
 	extendChain(hook, 'skip', 'skipped');
-	extendChain(hook.cb, 'skip', 'skipped');
 	if (isAfterHook) {
 		extendChain(hook, 'always');
-		extendChain(hook.always, 'cb', 'callback');
 		extendChain(hook.always, 'skip', 'skipped');
-		extendChain(hook.always.cb, 'skip', 'skipped');
 	}
 
 	return hook;
 }
 
-function createChain(fn, defaults, meta) {
+export default function createChain(fn, defaults, meta) {
 	// Test chaining rules:
 	// * `serial` must come at the start
 	// * `only` and `skip` must come at the end
@@ -69,27 +64,15 @@ function createChain(fn, defaults, meta) {
 	// * `only` and `skip` cannot be chained together
 	// * no repeating
 	const root = startChain('test', fn, {...defaults, type: 'test'});
-	extendChain(root, 'cb', 'callback');
 	extendChain(root, 'failing');
 	extendChain(root, 'only', 'exclusive');
 	extendChain(root, 'serial');
 	extendChain(root, 'skip', 'skipped');
-	extendChain(root.cb, 'failing');
-	extendChain(root.cb, 'only', 'exclusive');
-	extendChain(root.cb, 'skip', 'skipped');
-	extendChain(root.cb.failing, 'only', 'exclusive');
-	extendChain(root.cb.failing, 'skip', 'skipped');
 	extendChain(root.failing, 'only', 'exclusive');
 	extendChain(root.failing, 'skip', 'skipped');
-	extendChain(root.serial, 'cb', 'callback');
 	extendChain(root.serial, 'failing');
 	extendChain(root.serial, 'only', 'exclusive');
 	extendChain(root.serial, 'skip', 'skipped');
-	extendChain(root.serial.cb, 'failing');
-	extendChain(root.serial.cb, 'only', 'exclusive');
-	extendChain(root.serial.cb, 'skip', 'skipped');
-	extendChain(root.serial.cb.failing, 'only', 'exclusive');
-	extendChain(root.serial.cb.failing, 'skip', 'skipped');
 	extendChain(root.serial.failing, 'only', 'exclusive');
 	extendChain(root.serial.failing, 'skip', 'skipped');
 
@@ -108,9 +91,38 @@ function createChain(fn, defaults, meta) {
 	root.todo = startChain('test.todo', fn, {...defaults, type: 'test', todo: true});
 	root.serial.todo = startChain('test.serial.todo', fn, {...defaults, serial: true, type: 'test', todo: true});
 
+	root.macro = options => {
+		if (typeof options === 'function') {
+			return Object.freeze({exec: options});
+		}
+
+		return Object.freeze({exec: options.exec, title: options.title});
+	};
+
 	root.meta = meta;
 
+	// Our type definition uses ESM syntax; when using CJS with VSCode, the
+	// auto-completion assumes the root is accessed through `require('ava').default`.
+	// Placate VSCode by adding a mostly hidden default property on the root.
+	// This is available through both CJS and ESM imports. We use a proxy so that
+	// we don't end up with root.default.default.default chains.
+	Object.defineProperty(root, 'default', {
+		configurable: false,
+		enumerable: false,
+		writable: false,
+		value: new Proxy(root, {
+			apply(target, thisArg, argumentsList) {
+				target.apply(thisArg, argumentsList);
+			},
+			get(target, prop) {
+				if (prop === 'default') {
+					throw new TypeError('Cannot access default.default');
+				}
+
+				return target[prop];
+			},
+		}),
+	});
+
 	return root;
 }
-
-module.exports = createChain;

package/lib/environment-variables.js

@@ -1,5 +1,4 @@
-'use strict';
-function validateEnvironmentVariables(environmentVariables) {
+export default function validateEnvironmentVariables(environmentVariables) {
 	if (!environmentVariables) {
 		return {};
 	}
@@ -12,5 +11,3 @@ function validateEnvironmentVariables(environmentVariables) {
 
 	return environmentVariables;
 }
-
-module.exports = validateEnvironmentVariables;

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

@@ -0,0 +1,73 @@
+import v8 from 'node:v8';
+import {parentPort, workerData} from 'node:worker_threads';
+
+import normalizeExtensions from './extensions.js';
+import {normalizeGlobs} from './globs.js';
+import {loadConfig} from './load-config.js';
+import providerManager from './provider-manager.js';
+
+const MAX_DATA_LENGTH_EXCLUSIVE = 100 * 1024; // Allocate 100 KiB to exchange globs.
+
+const configCache = new Map();
+
+const collectProviders = async ({conf, projectDir}) => {
+	const providers = [];
+	if (Reflect.has(conf, 'typescript')) {
+		const {level, main} = await providerManager.typescript(projectDir);
+		providers.push({
+			level,
+			main: main({config: conf.typescript}),
+			type: 'typescript',
+		});
+	}
+
+	return providers;
+};
+
+const buildGlobs = ({conf, providers, projectDir, overrideExtensions, overrideFiles}) => {
+	const extensions = overrideExtensions
+		? normalizeExtensions(overrideExtensions)
+		: normalizeExtensions(conf.extensions, providers);
+
+	return {
+		cwd: projectDir,
+		...normalizeGlobs({
+			extensions,
+			files: overrideFiles ? overrideFiles : conf.files,
+			providers,
+		}),
+	};
+};
+
+const resolveGlobs = async (projectDir, overrideExtensions, overrideFiles) => {
+	if (!configCache.has(projectDir)) {
+		configCache.set(projectDir, loadConfig({resolveFrom: projectDir}).then(async conf => {
+			const providers = await collectProviders({conf, projectDir});
+			return {conf, providers};
+		}));
+	}
+
+	const {conf, providers} = await configCache.get(projectDir);
+	return buildGlobs({conf, providers, projectDir, overrideExtensions, overrideFiles});
+};
+
+const data = new Uint8Array(workerData.dataBuffer);
+const sync = new Int32Array(workerData.syncBuffer);
+
+const handleMessage = async ({projectDir, overrideExtensions, overrideFiles}) => {
+	let encoded;
+	try {
+		const globs = await resolveGlobs(projectDir, overrideExtensions, overrideFiles);
+		encoded = v8.serialize(globs);
+	} catch (error) {
+		encoded = v8.serialize(error);
+	}
+
+	const byteLength = encoded.length < MAX_DATA_LENGTH_EXCLUSIVE ? encoded.copy(data) : MAX_DATA_LENGTH_EXCLUSIVE;
+	Atomics.store(sync, 0, byteLength);
+	Atomics.notify(sync, 0);
+};
+
+parentPort.on('message', handleMessage);
+handleMessage(workerData.firstMessage);
+delete workerData.firstMessage;

package/lib/extensions.js

@@ -1,4 +1,4 @@
-module.exports = (configuredExtensions, providers = []) => {
+export default function resolveExtensions(configuredExtensions, providers = []) {
 	// Combine all extensions possible for testing. Remove duplicate extensions.
 	const duplicates = new Set();
 	const seen = new Set();
@@ -43,4 +43,4 @@ module.exports = (configuredExtensions, providers = []) => {
 	}
 
 	return [...seen];
-};
+}

package/lib/fork.js

@@ -1,68 +1,71 @@
-'use strict';
-const childProcess = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const Emittery = require('emittery');
-const {controlFlow} = require('./ipc-flow-control');
-
-if (fs.realpathSync(__filename) !== __filename) {
-	console.warn('WARNING: `npm link ava` and the `--preserve-symlink` flag are incompatible. We have detected that AVA is linked via `npm link`, and that you are using either an early version of Node 6, or the `--preserve-symlink` flag. This breaks AVA. You should upgrade to Node 6.2.0+, avoid the `--preserve-symlink` flag, or avoid using `npm link ava`.');
-}
-
-// In case the test file imports a different AVA install,
-// the presence of this variable allows it to require this one instead
-const AVA_PATH = path.resolve(__dirname, '..');
-const WORKER_PATH = require.resolve('./worker/subprocess');
+import childProcess from 'node:child_process';
+import process from 'node:process';
+import {fileURLToPath} from 'node:url';
+import {Worker} from 'node:worker_threads';
 
-class SharedWorkerChannel extends Emittery {
-	constructor({channelId, filename, initialData}, sendToFork) {
-		super();
+import Emittery from 'emittery';
+import {pEvent} from 'p-event';
 
-		this.id = channelId;
-		this.filename = filename;
-		this.initialData = initialData;
-		this.sendToFork = sendToFork;
-	}
+import {controlFlow} from './ipc-flow-control.cjs';
+import serializeError from './serialize-error.js';
 
-	signalReady() {
-		this.sendToFork({
-			type: 'shared-worker-ready',
-			channelId: this.id
-		});
-	}
-
-	signalError() {
-		this.sendToFork({
-			type: 'shared-worker-error',
-			channelId: this.id
-		});
-	}
+let workerPath = new URL('worker/base.js', import.meta.url);
+export function _testOnlyReplaceWorkerPath(replacement) {
+	workerPath = replacement;
+}
 
-	emitMessage({messageId, replyTo, serializedData}) {
-		this.emit('message', {
-			messageId,
-			replyTo,
-			serializedData
+const additionalExecArgv = ['--enable-source-maps'];
+
+const createWorker = (options, execArgv) => {
+	let worker;
+	let postMessage;
+	let close;
+	if (options.workerThreads) {
+		worker = new Worker(workerPath, {
+			argv: options.workerArgv,
+			env: {NODE_ENV: 'test', ...process.env, ...options.environmentVariables},
+			execArgv: [...execArgv, ...additionalExecArgv],
+			workerData: {
+				options,
+			},
+			trackUnmanagedFds: true,
+			stdin: true,
+			stdout: true,
+			stderr: true,
 		});
-	}
-
-	forwardMessageToFork({messageId, replyTo, serializedData}) {
-		this.sendToFork({
-			type: 'shared-worker-message',
-			channelId: this.id,
-			messageId,
-			replyTo,
-			serializedData
+		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
+			}
+		};
+	} else {
+		worker = childProcess.fork(fileURLToPath(workerPath), options.workerArgv, {
+			cwd: options.projectDir,
+			silent: true,
+			env: {NODE_ENV: 'test', ...process.env, ...options.environmentVariables},
+			execArgv: [...execArgv, ...additionalExecArgv],
 		});
+		postMessage = controlFlow(worker);
+		close = async () => worker.kill();
 	}
-}
-
-let forkCounter = 0;
 
-module.exports = (file, options, execArgv = process.execArgv) => {
-	const forkId = `fork/${++forkCounter}`;
-	const sharedWorkerChannels = new Map();
+	return {
+		worker,
+		postMessage,
+		close,
+	};
+};
 
+export default function loadFork(file, options, execArgv = process.execArgv) {
 	let finished = false;
 
 	const emitter = new Emittery();
@@ -75,31 +78,22 @@ module.exports = (file, options, execArgv = process.execArgv) => {
 	options = {
 		baseDir: process.cwd(),
 		file,
-		forkId,
-		...options
+		...options,
 	};
 
-	const subprocess = childProcess.fork(WORKER_PATH, options.workerArgv, {
-		cwd: options.projectDir,
-		silent: true,
-		env: {NODE_ENV: 'test', ...process.env, ...options.environmentVariables, AVA_PATH},
-		execArgv
-	});
-
-	subprocess.stdout.on('data', chunk => {
+	const {worker, postMessage, close} = createWorker(options, execArgv);
+	worker.stdout.on('data', chunk => {
 		emitStateChange({type: 'worker-stdout', chunk});
 	});
 
-	subprocess.stderr.on('data', chunk => {
+	worker.stderr.on('data', chunk => {
 		emitStateChange({type: 'worker-stderr', chunk});
 	});
 
-	const bufferedSend = controlFlow(subprocess);
-
 	let forcedExit = false;
 	const send = evt => {
 		if (!finished && !forcedExit) {
-			bufferedSend({ava: evt});
+			postMessage({ava: evt});
 		}
 	};
 
@@ -109,7 +103,7 @@ module.exports = (file, options, execArgv = process.execArgv) => {
 			resolve();
 		};
 
-		subprocess.on('message', message => {
+		worker.on('message', message => {
 			if (!message.ava) {
 				return;
 			}
@@ -119,15 +113,18 @@ module.exports = (file, options, execArgv = process.execArgv) => {
 					send({type: 'options', options});
 					break;
 				case 'shared-worker-connect': {
-					const channel = new SharedWorkerChannel(message.ava, send);
-					sharedWorkerChannels.set(channel.id, channel);
-					emitter.emit('connectSharedWorker', channel);
+					const {channelId, filename, initialData, port} = message.ava;
+					emitter.emit('connectSharedWorker', {
+						filename,
+						initialData,
+						port,
+						signalError() {
+							send({type: 'shared-worker-error', channelId});
+						},
+					});
 					break;
 				}
 
-				case 'shared-worker-message':
-					sharedWorkerChannels.get(message.ava.channelId).emitMessage(message.ava);
-					break;
 				case 'ping':
 					send({type: 'pong'});
 					break;
@@ -136,12 +133,12 @@ module.exports = (file, options, execArgv = process.execArgv) => {
 			}
 		});
 
-		subprocess.on('error', err => {
-			emitStateChange({type: 'worker-failed', err});
+		worker.on('error', error => {
+			emitStateChange({type: 'worker-failed', err: serializeError('Worker error', false, error, file)});
 			finish();
 		});
 
-		subprocess.on('exit', (code, signal) => {
+		worker.on('exit', (code, signal) => {
 			if (forcedExit) {
 				emitStateChange({type: 'worker-finished', forcedExit});
 			} else if (code > 0) {
@@ -158,12 +155,12 @@ module.exports = (file, options, execArgv = process.execArgv) => {
 
 	return {
 		file,
-		forkId,
+		threadId: worker.threadId,
 		promise,
 
 		exit() {
 			forcedExit = true;
-			subprocess.kill();
+			close();
 		},
 
 		notifyOfPeerFailure() {
@@ -176,6 +173,6 @@ module.exports = (file, options, execArgv = process.execArgv) => {
 
 		onStateChange(listener) {
 			return emitter.on('stateChange', listener);
-		}
+		},
 	};
-};
+}