ava 4.0.0-alpha.1 → 4.0.1

package/lib/test.js

@@ -1,11 +1,11 @@
-'use strict';
-const concordance = require('concordance');
-const isPromise = require('is-promise');
-const plur = require('plur');
-const assert = require('./assert');
-const nowAndTimers = require('./now-and-timers');
-const parseTestArgs = require('./parse-test-args');
-const concordanceOptions = require('./concordance-options').default;
+import concordance from 'concordance';
+import isPromise from 'is-promise';
+import plur from 'plur';
+
+import {AssertionError, Assertions, checkAssertionMessage} from './assert.js';
+import concordanceOptions from './concordance-options.js';
+import nowAndTimers from './now-and-timers.cjs';
+import parseTestArgs from './parse-test-args.js';
 
 function formatErrorValue(label, error) {
 	const formatted = concordance.format(error, concordanceOptions);
@@ -21,7 +21,7 @@ const captureSavedError = () => {
 };
 
 const testMap = new WeakMap();
-class ExecutionContext extends assert.Assertions {
+class ExecutionContext extends Assertions {
 	constructor(test) {
 		super({
 			pass: () => {
@@ -36,12 +36,9 @@ class ExecutionContext extends assert.Assertions {
 			skip: () => {
 				test.countPassedAssertion();
 			},
-			compareWithSnapshot: options => {
-				return test.compareWithSnapshot(options);
-			},
-			powerAssert: test.powerAssert,
+			compareWithSnapshot: options => test.compareWithSnapshot(options),
 			experiments: test.experiments,
-			disableSnapshots: test.isHook === true
+			disableSnapshots: test.isHook === true,
 		});
 		testMap.set(this, test);
 
@@ -50,11 +47,9 @@ class ExecutionContext extends assert.Assertions {
 		};
 
 		this.log = (...inputArgs) => {
-			const args = inputArgs.map(value => {
-				return typeof value === 'string' ?
-					value :
-					concordance.format(value, concordanceOptions);
-			});
+			const args = inputArgs.map(value => typeof value === 'string'
+				? value
+				: concordance.format(value, concordanceOptions));
 			if (args.length > 0) {
 				test.addLog(args.join(' '));
 			}
@@ -81,90 +76,86 @@ class ExecutionContext extends assert.Assertions {
 				throw error;
 			}
 
-			const {args, buildTitle, implementations, receivedImplementationArray} = parseTestArgs(attemptArgs);
+			const {args, implementation, title} = parseTestArgs(attemptArgs);
 
-			if (implementations.length === 0) {
+			if (!implementation) {
 				throw new TypeError('Expected an implementation.');
 			}
 
-			const attemptPromises = implementations.map((implementation, index) => {
-				let {title, isSet, isValid, isEmpty} = buildTitle(implementation);
+			if (Array.isArray(implementation)) {
+				throw new TypeError('AVA 4 no longer supports t.try() with multiple implementations.');
+			}
 
-				if (!isSet || isEmpty) {
-					title = `${test.title} ─ attempt ${test.attemptCount + 1 + index}`;
-				} else if (isValid) {
-					title = `${test.title} ─ ${title}`;
-				} else {
-					throw new TypeError('`t.try()` titles must be strings'); // Throw synchronously!
-				}
+			let attemptTitle;
+			if (!title.isSet || title.isEmpty) {
+				attemptTitle = `${test.title} ─ attempt ${test.attemptCount + 1}`;
+			} else if (title.isValid) {
+				attemptTitle = `${test.title} ─ ${title.value}`;
+			} else {
+				throw new TypeError('`t.try()` titles must be strings');
+			}
 
-				if (!test.registerUniqueTitle(title)) {
-					throw new Error(`Duplicate test title: ${title}`);
-				}
+			if (!test.registerUniqueTitle(attemptTitle)) {
+				throw new Error(`Duplicate test title: ${attemptTitle}`);
+			}
+
+			let committed = false;
+			let discarded = false;
 
-				return {implementation, title};
-			}).map(async ({implementation, title}) => {
-				let committed = false;
-				let discarded = false;
-
-				const {assertCount, deferredSnapshotRecordings, errors, logs, passed, snapshotCount, startingSnapshotCount} = await test.runAttempt(title, t => implementation(t, ...args));
-
-				return {
-					errors,
-					logs: [...logs], // Don't allow modification of logs.
-					passed,
-					title,
-					commit: ({retainLogs = true} = {}) => {
-						if (committed) {
-							return;
-						}
-
-						if (discarded) {
-							test.saveFirstError(new Error('Can’t commit a result that was previously discarded'));
-							return;
-						}
-
-						committed = true;
-						test.finishAttempt({
-							assertCount,
-							commit: true,
-							deferredSnapshotRecordings,
-							errors,
-							logs,
-							passed,
-							retainLogs,
-							snapshotCount,
-							startingSnapshotCount
-						});
-					},
-					discard: ({retainLogs = false} = {}) => {
-						if (committed) {
-							test.saveFirstError(new Error('Can’t discard a result that was previously committed'));
-							return;
-						}
-
-						if (discarded) {
-							return;
-						}
-
-						discarded = true;
-						test.finishAttempt({
-							assertCount: 0,
-							commit: false,
-							deferredSnapshotRecordings,
-							errors,
-							logs,
-							passed,
-							retainLogs,
-							snapshotCount,
-							startingSnapshotCount
-						});
+			const {assertCount, deferredSnapshotRecordings, errors, logs, passed, snapshotCount, startingSnapshotCount} = await test.runAttempt(attemptTitle, t => implementation(t, ...args));
+
+			return {
+				errors,
+				logs: [...logs], // Don't allow modification of logs.
+				passed,
+				title: attemptTitle,
+				commit: ({retainLogs = true} = {}) => {
+					if (committed) {
+						return;
+					}
+
+					if (discarded) {
+						test.saveFirstError(new Error('Can’t commit a result that was previously discarded'));
+						return;
+					}
+
+					committed = true;
+					test.finishAttempt({
+						assertCount,
+						commit: true,
+						deferredSnapshotRecordings,
+						errors,
+						logs,
+						passed,
+						retainLogs,
+						snapshotCount,
+						startingSnapshotCount,
+					});
+				},
+				discard: ({retainLogs = false} = {}) => {
+					if (committed) {
+						test.saveFirstError(new Error('Can’t discard a result that was previously committed'));
+						return;
+					}
+
+					if (discarded) {
+						return;
 					}
-				};
-			});
 
-			const results = await Promise.all(attemptPromises);
-			return receivedImplementationArray ? results : results[0];
+					discarded = true;
+					test.finishAttempt({
+						assertCount: 0,
+						commit: false,
+						deferredSnapshotRecordings,
+						errors,
+						logs,
+						passed,
+						retainLogs,
+						snapshotCount,
+						startingSnapshotCount,
+					});
+				},
+			};
 		};
 	}
 
@@ -184,17 +175,9 @@ class ExecutionContext extends assert.Assertions {
 		const test = testMap.get(this);
 		return test.isHook ? test.testPassed : !test.assertError;
 	}
-
-	_throwsArgStart(assertion, file, line) {
-		testMap.get(this).trackThrows({assertion, file, line});
-	}
-
-	_throwsArgEnd() {
-		testMap.get(this).trackThrows(null);
-	}
 }
 
-class Test {
+export default class Test {
 	constructor(options) {
 		this.contextRef = options.contextRef;
 		this.experiments = options.experiments || {};
@@ -202,12 +185,12 @@ class Test {
 		this.fn = options.fn;
 		this.isHook = options.isHook === true;
 		this.metadata = options.metadata;
-		this.powerAssert = options.powerAssert;
 		this.title = options.title;
 		this.testPassed = options.testPassed;
 		this.registerUniqueTitle = options.registerUniqueTitle;
 		this.logs = [];
 		this.teardowns = [];
+		this.notifyTimeoutUpdate = options.notifyTimeoutUpdate;
 
 		const {snapshotBelongsTo = this.title, nextSnapshotIndex = 0} = options;
 		this.snapshotBelongsTo = snapshotBelongsTo;
@@ -229,7 +212,7 @@ class Test {
 				expected,
 				index,
 				label,
-				taskIndex: this.metadata.taskIndex
+				taskIndex: this.metadata.taskIndex,
 			});
 			if (record) {
 				this.deferredSnapshotRecordings.push(record);
@@ -244,7 +227,7 @@ class Test {
 					belongsTo: snapshotBelongsTo,
 					index: this.nextSnapshotIndex,
 					deferRecording,
-					taskIndex: this.metadata.taskIndex
+					taskIndex: this.metadata.taskIndex,
 				});
 				if (record) {
 					this.deferredSnapshotRecordings.push(record);
@@ -272,7 +255,7 @@ class Test {
 				contextRef: contextRef.copy(),
 				snapshotBelongsTo,
 				nextSnapshotIndex,
-				title
+				title,
 			});
 
 			const {deferredSnapshotRecordings, error, logs, passed, assertCount, snapshotCount} = await attempt.run();
@@ -285,13 +268,11 @@ class Test {
 		this.attemptCount = 0;
 		this.calledEnd = false;
 		this.duration = null;
-		this.finishDueToAttributedError = null;
 		this.finishDueToInactivity = null;
 		this.finishDueToTimeout = null;
 		this.finishing = false;
 		this.pendingAssertionCount = 0;
 		this.pendingAttemptCount = 0;
-		this.pendingThrowsAssertion = null;
 		this.planCount = null;
 		this.startedAt = 0;
 		this.timeoutMs = 0;
@@ -334,7 +315,7 @@ class Test {
 
 		promise
 			.catch(error => this.saveFirstError(error))
-			.then(() => { // eslint-disable-line promise/prefer-await-to-then
+			.then(() => {
 				this.pendingAssertionCount--;
 				this.refreshTimeout();
 			});
@@ -411,7 +392,7 @@ class Test {
 	}
 
 	timeout(ms, message) {
-		const result = assert.checkAssertionMessage('timeout', message);
+		const result = checkAssertionMessage('timeout', message);
 		if (result !== true) {
 			this.saveFirstError(result);
 			// Allow the timeout to be set even when the message is invalid.
@@ -431,6 +412,8 @@ class Test {
 				this.finishDueToTimeout();
 			}
 		}, ms);
+
+		this.notifyTimeoutUpdate(this.timeoutMs);
 	}
 
 	refreshTimeout() {
@@ -482,11 +465,11 @@ class Test {
 
 	verifyPlan() {
 		if (!this.assertError && this.planCount !== null && this.planCount !== this.assertCount) {
-			this.saveFirstError(new assert.AssertionError({
+			this.saveFirstError(new AssertionError({
 				assertion: 'plan',
 				message: `Planned for ${this.planCount} ${plur('assertion', this.planCount)}, but got ${this.assertCount}.`,
 				operator: '===',
-				savedError: this.planError
+				savedError: this.planError,
 			}));
 		}
 	}
@@ -517,70 +500,16 @@ class Test {
 		}
 	}
 
-	trackThrows(pending) {
-		this.pendingThrowsAssertion = pending;
-	}
-
-	detectImproperThrows(error) {
-		if (!this.pendingThrowsAssertion) {
-			return false;
-		}
-
-		const pending = this.pendingThrowsAssertion;
-		this.pendingThrowsAssertion = null;
-
-		const values = [];
-		if (error) {
-			values.push(formatErrorValue(`The following error was thrown, possibly before \`t.${pending.assertion}()\` could be called:`, error));
-		}
-
-		this.saveFirstError(new assert.AssertionError({
-			assertion: pending.assertion,
-			fixedSource: {file: pending.file, line: pending.line},
-			improperUsage: true,
-			message: `Improper usage of \`t.${pending.assertion}()\` detected`,
-			savedError: error instanceof Error && error,
-			values
-		}));
-		return true;
-	}
-
-	waitForPendingThrowsAssertion() {
-		return new Promise(resolve => {
-			this.finishDueToAttributedError = () => {
-				resolve(this.finish());
-			};
-
-			this.finishDueToInactivity = () => {
-				this.detectImproperThrows();
-				resolve(this.finish());
-			};
-
-			// Wait up to a second to see if an error can be attributed to the
-			// pending assertion.
-			nowAndTimers.setTimeout(() => this.finishDueToInactivity(), 1000).unref();
-		});
-	}
-
-	attributeLeakedError(error) {
-		if (!this.detectImproperThrows(error)) {
-			return false;
-		}
-
-		this.finishDueToAttributedError();
-		return true;
-	}
-
 	callFn() {
 		try {
 			return {
 				ok: true,
-				retval: this.fn.call(null, this.createExecutionContext())
+				retval: this.fn.call(null, this.createExecutionContext()),
 			};
 		} catch (error) {
 			return {
 				ok: false,
-				error
+				error,
 			};
 		}
 	}
@@ -590,13 +519,11 @@ class Test {
 
 		const result = this.callFn();
 		if (!result.ok) {
-			if (!this.detectImproperThrows(result.error)) {
-				this.saveFirstError(new assert.AssertionError({
-					message: 'Error thrown in test',
-					savedError: result.error instanceof Error && result.error,
-					values: [formatErrorValue('Error thrown in test:', result.error)]
-				}));
-			}
+			this.saveFirstError(new AssertionError({
+				message: 'Error thrown in test',
+				savedError: result.error instanceof Error && result.error,
+				values: [formatErrorValue('Error thrown in test:', result.error)],
+			}));
 
 			return this.finish();
 		}
@@ -609,7 +536,7 @@ class Test {
 			promise = new Promise((resolve, reject) => {
 				result.retval.subscribe({
 					error: reject,
-					complete: () => resolve()
+					complete: () => resolve(),
 				});
 			});
 		} else if (returnedPromise) {
@@ -628,24 +555,22 @@ class Test {
 				};
 
 				this.finishDueToInactivity = () => {
-					const error = returnedObservable ?
-						new Error('Observable returned by test never completed') :
-						new Error('Promise returned by test never resolved');
+					const error = returnedObservable
+						? new Error('Observable returned by test never completed')
+						: new Error('Promise returned by test never resolved');
 					this.saveFirstError(error);
 					resolve(this.finish());
 				};
 
 				promise
 					.catch(error => {
-						if (!this.detectImproperThrows(error)) {
-							this.saveFirstError(new assert.AssertionError({
-								message: 'Rejected promise returned by test',
-								savedError: error instanceof Error && error,
-								values: [formatErrorValue('Rejected promise returned by test. Reason:', error)]
-							}));
-						}
+						this.saveFirstError(new AssertionError({
+							message: 'Rejected promise returned by test',
+							savedError: error instanceof Error && error,
+							values: [formatErrorValue('Rejected promise returned by test. Reason:', error)],
+						}));
 					})
-					.then(() => resolve(this.finish())); // eslint-disable-line promise/prefer-await-to-then
+					.then(() => resolve(this.finish()));
 			});
 		}
 
@@ -655,10 +580,6 @@ class Test {
 	async finish() {
 		this.finishing = true;
 
-		if (!this.assertError && this.pendingThrowsAssertion) {
-			return this.waitForPendingThrowsAssertion();
-		}
-
 		this.clearTimeout();
 		this.verifyPlan();
 		this.verifyAssertions();
@@ -684,9 +605,7 @@ class Test {
 			passed,
 			snapshotCount: this.snapshotCount,
 			assertCount: this.assertCount,
-			title: this.title
+			title: this.title,
 		};
 	}
 }
-
-module.exports = Test;

package/lib/watcher.js

@@ -1,12 +1,20 @@
-'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');
+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
@@ -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);
+					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, ...flatten(testsByHelpersOrSource)])]);
+		this.run([...new Set([addedOrChangedTests, testsByHelpersOrSource].flat(2))]);
 	}
 }
-
-module.exports = Watcher;