ava 3.15.0 → 4.0.0

package/eslint-plugin-helper.js

@@ -1,201 +0,0 @@
-'use strict';
-let isMainThread = true;
-let supportsWorkers = false;
-try {
-	({isMainThread} = require('worker_threads'));
-	supportsWorkers = true;
-} catch {}
-
-const {classify, hasExtension, isHelperish, matches, normalizeFileForMatching, normalizeGlobs, normalizePatterns} = require('./lib/globs');
-
-let resolveGlobs;
-let resolveGlobsSync;
-
-if (!supportsWorkers || !isMainThread) {
-	const normalizeExtensions = require('./lib/extensions');
-	const {loadConfig, loadConfigSync} = require('./lib/load-config');
-	const providerManager = require('./lib/provider-manager');
-
-	const configCache = new Map();
-
-	const collectProviders = ({conf, projectDir}) => {
-		const providers = [];
-		if (Reflect.has(conf, 'babel')) {
-			const {level, main} = providerManager.babel(projectDir);
-			providers.push({
-				level,
-				main: main({config: conf.babel}),
-				type: 'babel'
-			});
-		}
-
-		if (Reflect.has(conf, 'typescript')) {
-			const {level, main} = 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
-			})
-		};
-	};
-
-	resolveGlobsSync = (projectDir, overrideExtensions, overrideFiles) => {
-		if (!configCache.has(projectDir)) {
-			const conf = loadConfigSync({resolveFrom: projectDir});
-			const providers = collectProviders({conf, projectDir});
-			configCache.set(projectDir, {conf, providers});
-		}
-
-		const {conf, providers} = configCache.get(projectDir);
-		return buildGlobs({conf, providers, projectDir, overrideExtensions, overrideFiles});
-	};
-
-	resolveGlobs = async (projectDir, overrideExtensions, overrideFiles) => {
-		if (!configCache.has(projectDir)) {
-			configCache.set(projectDir, loadConfig({resolveFrom: projectDir}).then(conf => { // eslint-disable-line promise/prefer-await-to-then
-				const providers = collectProviders({conf, projectDir});
-				return {conf, providers};
-			}));
-		}
-
-		const {conf, providers} = await configCache.get(projectDir);
-		return buildGlobs({conf, providers, projectDir, overrideExtensions, overrideFiles});
-	};
-}
-
-if (supportsWorkers) {
-	const v8 = require('v8');
-
-	const MAX_DATA_LENGTH_EXCLUSIVE = 100 * 1024; // Allocate 100 KiB to exchange globs.
-
-	if (isMainThread) {
-		const {Worker} = require('worker_threads');
-		let data;
-		let sync;
-		let worker;
-
-		resolveGlobsSync = (projectDir, overrideExtensions, overrideFiles) => {
-			if (worker === undefined) {
-				const dataBuffer = new SharedArrayBuffer(MAX_DATA_LENGTH_EXCLUSIVE);
-				data = new Uint8Array(dataBuffer);
-
-				const syncBuffer = new SharedArrayBuffer(4);
-				sync = new Int32Array(syncBuffer);
-
-				worker = new Worker(__filename, {
-					workerData: {
-						dataBuffer,
-						syncBuffer,
-						firstMessage: {projectDir, overrideExtensions, overrideFiles}
-					}
-				});
-				worker.unref();
-			} else {
-				worker.postMessage({projectDir, overrideExtensions, overrideFiles});
-			}
-
-			Atomics.wait(sync, 0, 0);
-
-			const byteLength = Atomics.exchange(sync, 0, 0);
-			if (byteLength === MAX_DATA_LENGTH_EXCLUSIVE) {
-				throw new Error('Globs are over 100 KiB and cannot be resolved');
-			}
-
-			const globsOrError = v8.deserialize(data.slice(0, byteLength));
-			if (globsOrError instanceof Error) {
-				throw globsOrError;
-			}
-
-			return globsOrError;
-		};
-	} else {
-		const {parentPort, workerData} = require('worker_threads');
-		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;
-	}
-}
-
-const helperCache = new Map();
-
-function load(projectDir, overrides) {
-	const cacheKey = `${JSON.stringify(overrides)}\n${projectDir}`;
-	if (helperCache.has(cacheKey)) {
-		return helperCache.get(cacheKey);
-	}
-
-	let helperPatterns = [];
-	if (overrides && overrides.helpers !== undefined) {
-		if (!Array.isArray(overrides.helpers) || overrides.helpers.length === 0) {
-			throw new Error('The ’helpers’ override must be an array containing glob patterns.');
-		}
-
-		helperPatterns = normalizePatterns(overrides.helpers);
-	}
-
-	const globs = resolveGlobsSync(projectDir, overrides && overrides.extensions, overrides && overrides.files);
-
-	const classifyForESLint = file => {
-		const {isTest} = classify(file, globs);
-		let isHelper = false;
-		if (!isTest && hasExtension(globs.extensions, file)) {
-			file = normalizeFileForMatching(projectDir, file);
-			isHelper = isHelperish(file) || (helperPatterns.length > 0 && matches(file, helperPatterns));
-		}
-
-		return {isHelper, isTest};
-	};
-
-	const helper = Object.freeze({
-		classifyFile: classifyForESLint,
-		classifyImport: importPath => {
-			if (hasExtension(globs.extensions, importPath)) {
-				// The importPath has one of the test file extensions: we can classify
-				// it directly.
-				return classifyForESLint(importPath);
-			}
-
-			// Add the first extension. If multiple extensions are available, assume
-			// patterns are not biased to any particular extension.
-			return classifyForESLint(`${importPath}.${globs.extensions[0]}`);
-		}
-	});
-	helperCache.set(cacheKey, helper);
-	return helper;
-}
-
-exports.load = load;

package/index.js

@@ -1,8 +0,0 @@
-'use strict';
-
-// Ensure the same AVA install is loaded by the test file as by the test worker
-if (process.env.AVA_PATH && process.env.AVA_PATH !== __dirname) {
-	module.exports = require(process.env.AVA_PATH);
-} else {
-	module.exports = require('./lib/worker/main');
-}

package/lib/worker/ipc.js

@@ -1,201 +0,0 @@
-'use strict';
-const events = require('events');
-const pEvent = require('p-event');
-const {controlFlow} = require('../ipc-flow-control');
-const {get: getOptions} = require('./options');
-
-const selectAvaMessage = type => message => message.ava && message.ava.type === type;
-
-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) {
-	bufferedSend({ava: evt});
-}
-
-exports.send = send;
-
-let refs = 1;
-function ref() {
-	if (++refs === 1) {
-		process.channel.ref();
-	}
-}
-
-function unref() {
-	if (refs > 0 && --refs === 0) {
-		process.channel.unref();
-	}
-}
-
-exports.unref = unref;
-
-let pendingPings = Promise.resolve();
-async function flush() {
-	ref();
-	const promise = pendingPings.then(async () => { // eslint-disable-line promise/prefer-await-to-then
-		send({type: 'ping'});
-		await pEvent(process, 'message', selectAvaMessage('pong'));
-		if (promise === pendingPings) {
-			unref();
-		}
-	});
-	pendingPings = promise;
-	await promise;
-}
-
-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/main.js

@@ -1,21 +0,0 @@
-'use strict';
-const runner = require('./subprocess').getRunner();
-
-const makeCjsExport = () => {
-	function test(...args) {
-		return runner.chain(...args);
-	}
-
-	return Object.assign(test, runner.chain);
-};
-
-// Support CommonJS modules by exporting a test function that can be fully
-// chained. Also support ES module loaders by exporting __esModule and a
-// default. Support `import * as ava from 'ava'` use cases by exporting a
-// `test` member. Do all this whilst preventing `test.test.test() or
-// `test.default.test()` chains, though in CommonJS `test.test()` is
-// unavoidable.
-module.exports = Object.assign(makeCjsExport(), {
-	__esModule: true,
-	default: runner.chain
-});

package/lib/worker/subprocess.js

@@ -1,266 +0,0 @@
-'use strict';
-const {pathToFileURL} = require('url');
-const currentlyUnhandled = require('currently-unhandled')();
-
-require('./ensure-forked'); // eslint-disable-line import/no-unassigned-import
-
-const ipc = require('./ipc');
-
-const supportsESM = async () => {
-	try {
-		await import('data:text/javascript,'); // eslint-disable-line node/no-unsupported-features/es-syntax
-		return true;
-	} catch {}
-
-	return false;
-};
-
-ipc.send({type: 'ready-for-options'});
-ipc.options.then(async options => {
-	require('./options').set(options);
-	require('../chalk').set(options.chalkOptions);
-
-	if (options.chalkOptions.level > 0) {
-		const {stdout, stderr} = process;
-		global.console = Object.assign(global.console, new console.Console({stdout, stderr, colorMode: true}));
-	}
-
-	const nowAndTimers = require('../now-and-timers');
-	const providerManager = require('../provider-manager');
-	const Runner = require('../runner');
-	const serializeError = require('../serialize-error');
-	const dependencyTracking = require('./dependency-tracker');
-	const lineNumberSelection = require('./line-numbers');
-
-	const sharedWorkerTeardowns = [];
-
-	async function exit(code) {
-		if (!process.exitCode) {
-			process.exitCode = code;
-		}
-
-		dependencyTracking.flush();
-		await ipc.flush();
-		process.exit(); // eslint-disable-line unicorn/no-process-exit
-	}
-
-	// TODO: Initialize providers here, then pass to lineNumberSelection() so they
-	// can be used to parse the test file.
-	let checkSelectedByLineNumbers;
-	try {
-		checkSelectedByLineNumbers = lineNumberSelection({
-			file: options.file,
-			lineNumbers: options.lineNumbers
-		});
-	} catch (error) {
-		ipc.send({type: 'line-number-selection-error', err: serializeError('Line number selection error', false, error, options.file)});
-		checkSelectedByLineNumbers = () => false;
-	}
-
-	const runner = new Runner({
-		checkSelectedByLineNumbers,
-		experiments: options.experiments,
-		failFast: options.failFast,
-		failWithoutAssertions: options.failWithoutAssertions,
-		file: options.file,
-		match: options.match,
-		projectDir: options.projectDir,
-		recordNewSnapshots: options.recordNewSnapshots,
-		runOnlyExclusive: options.runOnlyExclusive,
-		serial: options.serial,
-		snapshotDir: options.snapshotDir,
-		updateSnapshots: options.updateSnapshots
-	});
-
-	ipc.peerFailed.then(() => { // eslint-disable-line promise/prefer-await-to-then
-		runner.interrupt();
-	});
-
-	const attributedRejections = new Set();
-	process.on('unhandledRejection', (reason, promise) => {
-		if (runner.attributeLeakedError(reason)) {
-			attributedRejections.add(promise);
-		}
-	});
-
-	runner.on('dependency', dependencyTracking.track);
-	runner.on('stateChange', state => ipc.send(state));
-
-	runner.on('error', error => {
-		ipc.send({type: 'internal-error', err: serializeError('Internal runner error', false, error, runner.file)});
-		exit(1);
-	});
-
-	runner.on('finish', async () => {
-		try {
-			const {cannotSave, touchedFiles} = runner.saveSnapshotState();
-			if (cannotSave) {
-				ipc.send({type: 'snapshot-error'});
-			} else if (touchedFiles) {
-				ipc.send({type: 'touched-files', files: touchedFiles});
-			}
-		} catch (error) {
-			ipc.send({type: 'internal-error', err: serializeError('Internal runner error', false, error, runner.file)});
-			exit(1);
-			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))
-				.forEach(rejection => {
-					ipc.send({type: 'unhandled-rejection', err: serializeError('Unhandled rejection', true, rejection.reason, runner.file)});
-				});
-
-			exit(0);
-		});
-	});
-
-	process.on('uncaughtException', error => {
-		if (runner.attributeLeakedError(error)) {
-			return;
-		}
-
-		ipc.send({type: 'uncaught-exception', err: serializeError('Uncaught exception', true, error, runner.file)});
-		exit(1);
-	});
-
-	let accessedRunner = false;
-	exports.getRunner = () => {
-		accessedRunner = true;
-		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;
-
-	// Install basic source map support.
-	const sourceMapSupport = require('source-map-support');
-	sourceMapSupport.install({
-		environment: 'node',
-		handleUncaughtExceptions: false
-	});
-
-	const extensionsToLoadAsModules = Object.entries(options.moduleTypes)
-		.filter(([, type]) => type === 'module')
-		.map(([extension]) => extension);
-
-	// Install before processing options.require, so if helpers are added to the
-	// require configuration the *compiled* helper will be loaded.
-	const {projectDir, providerStates = []} = options;
-	const providers = providerStates.map(({type, state}) => {
-		if (type === 'babel') {
-			const provider = providerManager.babel(projectDir).worker({extensionsToLoadAsModules, state});
-			runner.powerAssert = provider.powerAssert;
-			return provider;
-		}
-
-		if (type === 'typescript') {
-			return providerManager.typescript(projectDir).worker({extensionsToLoadAsModules, state});
-		}
-
-		return null;
-	}).filter(provider => provider !== null);
-
-	let requireFn = require;
-	let isESMSupported;
-	const load = async ref => {
-		for (const extension of extensionsToLoadAsModules) {
-			if (ref.endsWith(`.${extension}`)) {
-				if (typeof isESMSupported !== 'boolean') {
-					// Lazily determine support since this prints an experimental warning.
-					// eslint-disable-next-line no-await-in-loop
-					isESMSupported = await supportsESM();
-				}
-
-				if (isESMSupported) {
-					return import(pathToFileURL(ref)); // eslint-disable-line node/no-unsupported-features/es-syntax
-				}
-
-				ipc.send({type: 'internal-error', err: serializeError('Internal runner error', false, new Error('ECMAScript Modules are not supported in this Node.js version.'))});
-				exit(1);
-				return;
-			}
-		}
-
-		for (const provider of providers) {
-			if (provider.canLoad(ref)) {
-				return provider.load(ref, {requireFn});
-			}
-		}
-
-		return requireFn(ref);
-	};
-
-	try {
-		for await (const ref of (options.require || [])) {
-			const mod = await load(ref);
-
-			try {
-				if (Reflect.has(mod, Symbol.for('esm:package'))) {
-					requireFn = mod(module);
-				}
-			} catch {}
-		}
-
-		// Install dependency tracker after the require configuration has been evaluated
-		// to make sure we also track dependencies with custom require hooks
-		dependencyTracking.install(testPath);
-
-		if (options.debug && options.debug.port !== undefined && options.debug.host !== undefined) {
-			// If an inspector was active when the main process started, and is
-			// already active for the worker process, do not open a new one.
-			const inspector = require('inspector'); // eslint-disable-line node/no-unsupported-features/node-builtins
-			if (!options.debug.active || inspector.url() === undefined) {
-				inspector.open(options.debug.port, options.debug.host, true);
-			}
-
-			if (options.debug.break) {
-				debugger; // eslint-disable-line no-debugger
-			}
-		}
-
-		await load(testPath);
-
-		if (accessedRunner) {
-			// Unreference the IPC channel if the test file required AVA. This stops it
-			// from keeping the event loop busy, which means the `beforeExit` event can be
-			// used to detect when tests stall.
-			ipc.unref();
-		} else {
-			ipc.send({type: 'missing-ava-import'});
-			exit(1);
-		}
-	} catch (error) {
-		ipc.send({type: 'uncaught-exception', err: serializeError('Uncaught exception', true, error, runner.file)});
-		exit(1);
-	}
-}).catch(error => {
-	// There shouldn't be any errors, but if there are we may not have managed
-	// to bootstrap enough code to serialize them. Re-throw and let the process
-	// crash.
-	setImmediate(() => {
-		throw error;
-	});
-});

package/plugin.js

@@ -1,9 +0,0 @@
-'use strict';
-const path = require('path');
-
-// Ensure the same AVA install is loaded by the test file as by the test worker
-if (process.env.AVA_PATH && process.env.AVA_PATH !== __dirname) {
-	module.exports = require(path.join(process.env.AVA_PATH, 'plugin'));
-} else {
-	module.exports = require('./lib/worker/plugin');
-}