ava 3.15.0 → 4.0.0

package/lib/watcher.js

@@ -1,18 +1,26 @@
-'use strict';
-const nodePath = require('path');
-const debug = require('debug')('ava:watcher');
-const chokidar = require('chokidar');
-const diff = require('lodash/difference');
-const flatten = require('lodash/flatten');
-const chalk = require('./chalk').get();
-const {applyTestFileFilter, classify, getChokidarIgnorePatterns} = require('./globs');
-const {levels: providerLevels} = require('./provider-manager');
-
-function rethrowAsync(err) {
+import nodePath from 'node:path';
+
+import chokidar_ from 'chokidar';
+import createDebug from 'debug';
+
+import {chalk} from './chalk.js';
+import {applyTestFileFilter, classify, getChokidarIgnorePatterns} from './globs.js';
+
+let chokidar = chokidar_;
+export function _testOnlyReplaceChokidar(replacement) {
+	chokidar = replacement;
+}
+
+let debug = createDebug('ava:watcher');
+export function _testOnlyReplaceDebug(replacement) {
+	debug = replacement('ava:watcher');
+}
+
+function rethrowAsync(error) {
 	// Don't swallow exceptions. Note that any
 	// expected error should already have been logged
 	setImmediate(() => {
-		throw err;
+		throw error;
 	});
 }
 
@@ -77,7 +85,7 @@ class TestDependency {
 	}
 }
 
-class Watcher {
+export default class Watcher {
 	constructor({api, filter = [], globs, projectDir, providers, reporter}) {
 		this.debouncer = new Debouncer(this);
 
@@ -88,7 +96,7 @@ class Watcher {
 
 		const patternFilters = filter.map(({pattern}) => pattern);
 
-		this.providers = providers.filter(({level}) => level >= providerLevels.pathRewrites);
+		this.providers = providers;
 		this.run = (specificFiles = [], updateSnapshots = false) => {
 			const clearLogOnNextRun = this.clearLogOnNextRun && this.runVector > 0;
 			if (this.runVector > 0) {
@@ -104,12 +112,18 @@ class Watcher {
 				if (runOnlyExclusive) {
 					// The test files that previously contained exclusive tests are always
 					// run, together with the remaining specific files.
-					const remainingFiles = diff(specificFiles, exclusiveFiles);
-					specificFiles = this.filesWithExclusiveTests.concat(remainingFiles);
+					const remainingFiles = specificFiles.filter(file => !exclusiveFiles.includes(file));
+					specificFiles = [...this.filesWithExclusiveTests, ...remainingFiles];
 				}
 
 				if (filter.length > 0) {
-					specificFiles = applyTestFileFilter({cwd: projectDir, filter: patternFilters, testFiles: specificFiles});
+					specificFiles = applyTestFileFilter({
+						cwd: projectDir,
+						expandDirectories: false,
+						filter: patternFilters,
+						testFiles: specificFiles,
+						treatFilterPatternsAsFiles: false,
+					});
 				}
 
 				this.pruneFailures(specificFiles);
@@ -125,21 +139,21 @@ class Watcher {
 					previousFailures: this.sumPreviousFailures(this.runVector),
 					runOnlyExclusive,
 					runVector: this.runVector,
-					updateSnapshots: updateSnapshots === true
-				}
+					updateSnapshots: updateSnapshots === true,
+				},
 			})
-				.then(runStatus => { // eslint-disable-line promise/prefer-await-to-then
+				.then(runStatus => {
 					reporter.endRun();
 					reporter.lineWriter.writeLine(END_MESSAGE);
 
 					if (this.clearLogOnNextRun && (
-						runStatus.stats.failedHooks > 0 ||
-						runStatus.stats.failedTests > 0 ||
-						runStatus.stats.failedWorkers > 0 ||
-						runStatus.stats.internalErrors > 0 ||
-						runStatus.stats.timeouts > 0 ||
-						runStatus.stats.uncaughtExceptions > 0 ||
-						runStatus.stats.unhandledRejections > 0
+						runStatus.stats.failedHooks > 0
+						|| runStatus.stats.failedTests > 0
+						|| runStatus.stats.failedWorkers > 0
+						|| runStatus.stats.internalErrors > 0
+						|| runStatus.stats.timeouts > 0
+						|| runStatus.stats.uncaughtExceptions > 0
+						|| runStatus.stats.unhandledRejections > 0
 					)) {
 						this.clearLogOnNextRun = false;
 					}
@@ -150,6 +164,7 @@ class Watcher {
 		this.testDependencies = [];
 		this.trackTestDependencies(api);
 
+		this.temporaryFiles = new Set();
 		this.touchedFiles = new Set();
 		this.trackTouchedFiles(api);
 
@@ -168,7 +183,7 @@ class Watcher {
 		chokidar.watch(['**/*'], {
 			cwd: this.globs.cwd,
 			ignored: getChokidarIgnorePatterns(this.globs),
-			ignoreInitial: true
+			ignoreInitial: true,
 		}).on('all', (event, path) => {
 			if (event === 'add' || event === 'change' || event === 'unlink') {
 				debug('Detected %s of %s', event, path);
@@ -231,9 +246,13 @@ class Watcher {
 					return;
 				}
 
-				for (const file of evt.files) {
+				for (const file of evt.files.changedFiles) {
 					this.touchedFiles.add(file);
 				}
+
+				for (const file of evt.files.temporaryFiles) {
+					this.temporaryFiles.add(file);
+				}
 			});
 		});
 	}
@@ -307,7 +326,7 @@ class Watcher {
 			this.filesWithFailures.push({
 				file,
 				vector,
-				count: 1
+				count: 1,
 			});
 		}
 	}
@@ -379,6 +398,14 @@ class Watcher {
 				return false;
 			}
 
+			// Unlike touched files, temporary files are never cleared. We may see
+			// adds and unlinks detected separately, so we track the temporary files
+			// as long as AVA is running.
+			if (this.temporaryFiles.has(path)) {
+				debug('Ignoring known temporary file %s', path);
+				return false;
+			}
+
 			return true;
 		});
 
@@ -394,21 +421,23 @@ class Watcher {
 		}
 
 		const dirtyHelpersAndSources = [];
-		const dirtyTests = [];
+		const addedOrChangedTests = [];
+		const unlinkedTests = [];
 		for (const filePath of dirtyPaths) {
 			const {isIgnoredByWatcher, isTest} = classify(filePath, this.globs);
 			if (!isIgnoredByWatcher) {
 				if (isTest) {
-					dirtyTests.push(filePath);
+					if (dirtyStates[filePath] === 'unlink') {
+						unlinkedTests.push(filePath);
+					} else {
+						addedOrChangedTests.push(filePath);
+					}
 				} else {
 					dirtyHelpersAndSources.push(filePath);
 				}
 			}
 		}
 
-		const addedOrChangedTests = dirtyTests.filter(path => dirtyStates[path] !== 'unlink');
-		const unlinkedTests = diff(dirtyTests, addedOrChangedTests);
-
 		this.cleanUnlinkedTests(unlinkedTests);
 
 		// No need to rerun tests if the only change is that tests were deleted
@@ -423,12 +452,10 @@ class Watcher {
 		}
 
 		// Try to find tests that depend on the changed source files
-		const testsByHelpersOrSource = dirtyHelpersAndSources.map(path => {
-			return this.testDependencies.filter(dep => dep.contains(path)).map(dep => {
-				debug('%s is a dependency of %s', path, dep.file);
-				return dep.file;
-			});
-		}, this).filter(tests => tests.length > 0);
+		const testsByHelpersOrSource = dirtyHelpersAndSources.map(path => this.testDependencies.filter(dep => dep.contains(path)).map(dep => {
+			debug('%s is a dependency of %s', path, dep.file);
+			return dep.file;
+		})).filter(tests => tests.length > 0);
 
 		// Rerun all tests if source files were changed that could not be traced to
 		// specific tests
@@ -440,8 +467,6 @@ class Watcher {
 		}
 
 		// Run all affected tests
-		this.run([...new Set(addedOrChangedTests.concat(flatten(testsByHelpersOrSource)))]);
+		this.run([...new Set([addedOrChangedTests, testsByHelpersOrSource].flat(2))]);
 	}
 }
-
-module.exports = Watcher;

package/lib/worker/base.js

@@ -0,0 +1,208 @@
+import {createRequire} from 'node:module';
+import process from 'node:process';
+import {pathToFileURL} from 'node:url';
+import {workerData} from 'node:worker_threads';
+
+import setUpCurrentlyUnhandled from 'currently-unhandled';
+
+import {set as setChalk} from '../chalk.js';
+import nowAndTimers from '../now-and-timers.cjs';
+import providerManager from '../provider-manager.js';
+import Runner from '../runner.js';
+import serializeError from '../serialize-error.js';
+
+import channel from './channel.cjs';
+import dependencyTracking from './dependency-tracker.js';
+import lineNumberSelection from './line-numbers.js';
+import {set as setOptions} from './options.cjs';
+import {flags, refs, sharedWorkerTeardowns} from './state.cjs';
+import {isRunningInThread, isRunningInChildProcess} from './utils.cjs';
+
+const currentlyUnhandled = setUpCurrentlyUnhandled();
+
+const run = async options => {
+	setOptions(options);
+	setChalk(options.chalkOptions);
+
+	if (options.chalkOptions.level > 0) {
+		const {stdout, stderr} = process;
+		global.console = Object.assign(global.console, new console.Console({stdout, stderr, colorMode: true}));
+	}
+
+	async function exit(code) {
+		if (!process.exitCode) {
+			process.exitCode = code;
+		}
+
+		dependencyTracking.flush();
+		await channel.flush();
+		process.exit(); // eslint-disable-line unicorn/no-process-exit
+	}
+
+	let checkSelectedByLineNumbers;
+	try {
+		checkSelectedByLineNumbers = lineNumberSelection({
+			file: options.file,
+			lineNumbers: options.lineNumbers,
+		});
+	} catch (error) {
+		channel.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,
+	});
+
+	refs.runnerChain = runner.chain;
+
+	channel.peerFailed.then(() => {
+		runner.interrupt();
+	});
+
+	runner.on('dependency', dependencyTracking.track);
+	runner.on('stateChange', state => channel.send(state));
+
+	runner.on('error', error => {
+		channel.send({type: 'internal-error', err: serializeError('Internal runner error', false, error, runner.file)});
+		exit(1);
+	});
+
+	runner.on('finish', async () => {
+		try {
+			const {touchedFiles} = runner.saveSnapshotState();
+			if (touchedFiles) {
+				channel.send({type: 'touched-files', files: touchedFiles});
+			}
+		} catch (error) {
+			channel.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) {
+			channel.send({type: 'uncaught-exception', err: serializeError('Shared worker teardown error', false, error, runner.file)});
+			exit(1);
+			return;
+		}
+
+		nowAndTimers.setImmediate(() => {
+			for (const rejection of currentlyUnhandled()) {
+				channel.send({type: 'unhandled-rejection', err: serializeError('Unhandled rejection', true, rejection.reason, runner.file)});
+			}
+
+			exit(0);
+		});
+	});
+
+	process.on('uncaughtException', error => {
+		channel.send({type: 'uncaught-exception', err: serializeError('Uncaught exception', true, error, runner.file)});
+		exit(1);
+	});
+
+	// Store value to prevent required modules from modifying it.
+	const testPath = options.file;
+
+	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 = [];
+	await Promise.all(providerStates.map(async ({type, state}) => {
+		if (type === 'typescript') {
+			const provider = await providerManager.typescript(projectDir);
+			providers.push(provider.worker({extensionsToLoadAsModules, state}));
+		}
+	}));
+
+	const require = createRequire(import.meta.url);
+	const load = async ref => {
+		for (const provider of providers) {
+			if (provider.canLoad(ref)) {
+				return provider.load(ref, {requireFn: require});
+			}
+		}
+
+		for (const extension of extensionsToLoadAsModules) {
+			if (ref.endsWith(`.${extension}`)) {
+				return import(pathToFileURL(ref)); // eslint-disable-line node/no-unsupported-features/es-syntax
+			}
+		}
+
+		// We still support require() since it's more easily monkey-patched.
+		return require(ref);
+	};
+
+	try {
+		for await (const ref of (options.require || [])) {
+			await load(ref);
+		}
+
+		// Install dependency tracker after the require configuration has been evaluated
+		// to make sure we also track dependencies with custom require hooks
+		dependencyTracking.install(require.extensions, 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 {default: inspector} = await import('node:inspector'); // eslint-disable-line node/no-unsupported-features/es-syntax
+			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 (flags.loadedMain) {
+			// Unreference the 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.
+			channel.unref();
+		} else {
+			channel.send({type: 'missing-ava-import'});
+			exit(1);
+		}
+	} catch (error) {
+		channel.send({type: 'uncaught-exception', err: serializeError('Uncaught exception', true, error, runner.file)});
+		exit(1);
+	}
+};
+
+const onError = 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;
+	});
+};
+
+if (isRunningInThread) {
+	channel.send({type: 'starting'}); // AVA won't terminate the worker thread until it's seen this message.
+	const {options} = workerData;
+	delete workerData.options; // Don't allow user code access.
+	run(options).catch(onError);
+} else if (isRunningInChildProcess) {
+	channel.send({type: 'ready-for-options'});
+	channel.options.then(run).catch(onError);
+}