ava 2.0.0 → 2.4.0

package/lib/test.js

@@ -6,6 +6,7 @@ const isObservable = require('is-observable');
 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;
 
 function formatErrorValue(label, error) {
@@ -13,13 +14,12 @@ function formatErrorValue(label, error) {
 	return {label, formatted};
 }
 
-const captureStack = start => {
+const captureSavedError = () => {
 	const limitBefore = Error.stackTraceLimit;
 	Error.stackTraceLimit = 1;
-	const obj = {};
-	Error.captureStackTrace(obj, start);
+	const err = new Error();
 	Error.stackTraceLimit = limitBefore;
-	return obj.stack;
+	return err;
 };
 
 const testMap = new WeakMap();
@@ -60,7 +60,7 @@ class ExecutionContext extends assert.Assertions {
 		};
 
 		this.plan = count => {
-			test.plan(count, captureStack(test.plan));
+			test.plan(count, captureSavedError());
 		};
 
 		this.plan.skip = () => {};
@@ -68,11 +68,100 @@ class ExecutionContext extends assert.Assertions {
 		this.timeout = ms => {
 			test.timeout(ms);
 		};
+
+		this.try = async (...attemptArgs) => {
+			if (test.experiments.tryAssertion !== true) {
+				throw new Error('t.try() is currently an experiment. Opt in by setting `nonSemVerExperiments.tryAssertion` to `true`.');
+			}
+
+			const {args, buildTitle, implementations, receivedImplementationArray} = parseTestArgs(attemptArgs);
+
+			if (implementations.length === 0) {
+				throw new TypeError('Expected an implementation.');
+			}
+
+			const attemptPromises = implementations.map(implementation => {
+				let {title, isSet, isValid, isEmpty} = buildTitle(implementation);
+
+				if (!isSet || isEmpty) {
+					title = `${test.title} (attempt ${test.attemptCount + 1})`;
+				} else if (!isValid) {
+					throw new TypeError('`t.try()` titles must be strings'); // Throw synchronously!
+				}
+
+				if (!test.registerUniqueTitle(title)) {
+					throw new Error(`Duplicate test title: ${title}`);
+				}
+
+				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 results = await Promise.all(attemptPromises);
+			return receivedImplementationArray ? results : results[0];
+		};
 	}
 
 	get end() {
 		const end = testMap.get(this).bindEndCallback();
-		const endFn = error => end(error, captureStack(endFn));
+		const endFn = error => end(error, captureSavedError());
 		return endFn;
 	}
 
@@ -100,32 +189,74 @@ class ExecutionContext extends assert.Assertions {
 class Test {
 	constructor(options) {
 		this.contextRef = options.contextRef;
+		this.experiments = options.experiments || {};
 		this.failWithoutAssertions = options.failWithoutAssertions;
 		this.fn = options.fn;
 		this.metadata = options.metadata;
 		this.title = options.title;
+		this.registerUniqueTitle = options.registerUniqueTitle;
 		this.logs = [];
 
-		this.snapshotInvocationCount = 0;
-		this.compareWithSnapshot = assertionOptions => {
-			const belongsTo = assertionOptions.id || this.title;
-			const {expected} = assertionOptions;
-			const index = assertionOptions.id ? 0 : this.snapshotInvocationCount++;
-			const label = assertionOptions.id ? '' : assertionOptions.message || `Snapshot ${this.snapshotInvocationCount}`;
-			return options.compareTestSnapshot({belongsTo, expected, index, label});
+		const {snapshotBelongsTo = this.title, nextSnapshotIndex = 0} = options;
+		this.snapshotBelongsTo = snapshotBelongsTo;
+		this.nextSnapshotIndex = nextSnapshotIndex;
+		this.snapshotCount = 0;
+
+		const deferRecording = this.metadata.inline;
+		this.deferredSnapshotRecordings = [];
+		this.compareWithSnapshot = ({expected, id, message}) => {
+			this.snapshotCount++;
+
+			// TODO: In a breaking change, reject non-undefined, falsy IDs and messages.
+			const belongsTo = id || snapshotBelongsTo;
+			const index = id ? 0 : this.nextSnapshotIndex++;
+			const label = id ? '' : message || `Snapshot ${index + 1}`; // Human-readable labels start counting at 1.
+
+			const {record, ...result} = options.compareTestSnapshot({belongsTo, deferRecording, expected, index, label});
+			if (record) {
+				this.deferredSnapshotRecordings.push(record);
+			}
+
+			return result;
 		};
 
 		this.skipSnapshot = () => {
 			if (options.updateSnapshots) {
 				this.addFailedAssertion(new Error('Snapshot assertions cannot be skipped when updating snapshots'));
 			} else {
-				this.snapshotInvocationCount++;
+				this.nextSnapshotIndex++;
+				this.snapshotCount++;
 				this.countPassedAssertion();
 			}
 		};
 
+		this.runAttempt = async (title, fn) => {
+			if (this.finishing) {
+				this.saveFirstError(new Error('Running a `t.try()`, but the test has already finished'));
+			}
+
+			this.attemptCount++;
+			this.pendingAttemptCount++;
+
+			const {contextRef, snapshotBelongsTo, nextSnapshotIndex, snapshotCount: startingSnapshotCount} = this;
+			const attempt = new Test({
+				...options,
+				fn,
+				metadata: {...options.metadata, callback: false, failing: false, inline: true},
+				contextRef: contextRef.copy(),
+				snapshotBelongsTo,
+				nextSnapshotIndex,
+				title
+			});
+
+			const {deferredSnapshotRecordings, error, logs, passed, assertCount, snapshotCount} = await attempt.run();
+			const errors = error ? [error] : [];
+			return {assertCount, deferredSnapshotRecordings, errors, logs, passed, snapshotCount, startingSnapshotCount};
+		};
+
 		this.assertCount = 0;
 		this.assertError = undefined;
+		this.attemptCount = 0;
 		this.calledEnd = false;
 		this.duration = null;
 		this.endCallbackFinisher = null;
@@ -134,24 +265,29 @@ class Test {
 		this.finishDueToTimeout = null;
 		this.finishing = false;
 		this.pendingAssertionCount = 0;
+		this.pendingAttemptCount = 0;
 		this.pendingThrowsAssertion = null;
 		this.planCount = null;
 		this.startedAt = 0;
-		this.timeoutTimer = null;
 		this.timeoutMs = 0;
+		this.timeoutTimer = null;
 	}
 
 	bindEndCallback() {
 		if (this.metadata.callback) {
-			return (error, stack) => {
-				this.endCallback(error, stack);
+			return (error, savedError) => {
+				this.endCallback(error, savedError);
 			};
 		}
 
-		throw new Error('`t.end()`` is not supported in this context. To use `t.end()` as a callback, you must use "callback mode" via `test.cb(testName, fn)`');
+		if (this.metadata.inline) {
+			throw new Error('`t.end()` is not supported inside `t.try()`');
+		} else {
+			throw new Error('`t.end()` is not supported in this context. To use `t.end()` as a callback, you must use "callback mode" via `test.cb(testName, fn)`');
+		}
 	}
 
-	endCallback(error, stack) {
+	endCallback(error, savedError) {
 		if (this.calledEnd) {
 			this.saveFirstError(new Error('`t.end()` called more than once'));
 			return;
@@ -163,7 +299,7 @@ class Test {
 			this.saveFirstError(new assert.AssertionError({
 				actual: error,
 				message: 'Callback called with an error',
-				stack,
+				savedError,
 				values: [formatErrorValue('Callback called with an error:', error)]
 			}));
 		}
@@ -182,6 +318,10 @@ class Test {
 			this.saveFirstError(new Error('Assertion passed, but test has already finished'));
 		}
 
+		if (this.pendingAttemptCount > 0) {
+			this.saveFirstError(new Error('Assertion passed, but an attempt is pending. Use the attempt’s assertions instead'));
+		}
+
 		this.assertCount++;
 		this.refreshTimeout();
 	}
@@ -192,7 +332,11 @@ class Test {
 
 	addPendingAssertion(promise) {
 		if (this.finishing) {
-			this.saveFirstError(new Error('Assertion passed, but test has already finished'));
+			this.saveFirstError(new Error('Assertion started, but test has already finished'));
+		}
+
+		if (this.pendingAttemptCount > 0) {
+			this.saveFirstError(new Error('Assertion started, but an attempt is pending. Use the attempt’s assertions instead'));
 		}
 
 		this.assertCount++;
@@ -212,18 +356,60 @@ class Test {
 			this.saveFirstError(new Error('Assertion failed, but test has already finished'));
 		}
 
+		if (this.pendingAttemptCount > 0) {
+			this.saveFirstError(new Error('Assertion failed, but an attempt is pending. Use the attempt’s assertions instead'));
+		}
+
 		this.assertCount++;
 		this.refreshTimeout();
 		this.saveFirstError(error);
 	}
 
+	finishAttempt({commit, deferredSnapshotRecordings, errors, logs, passed, retainLogs, snapshotCount, startingSnapshotCount}) {
+		if (this.finishing) {
+			if (commit) {
+				this.saveFirstError(new Error('`t.try()` result was committed, but the test has already finished'));
+			} else {
+				this.saveFirstError(new Error('`t.try()` result was discarded, but the test has already finished'));
+			}
+		}
+
+		if (commit) {
+			this.assertCount++;
+
+			if (startingSnapshotCount === this.snapshotCount) {
+				this.snapshotCount += snapshotCount;
+				this.nextSnapshotIndex += snapshotCount;
+				for (const record of deferredSnapshotRecordings) {
+					record();
+				}
+			} else {
+				this.saveFirstError(new Error('Cannot commit `t.try()` result. Do not run concurrent snapshot assertions when using `t.try()`'));
+			}
+		}
+
+		this.pendingAttemptCount--;
+
+		if (commit && !passed) {
+			this.saveFirstError(errors[0]);
+		}
+
+		if (retainLogs) {
+			for (const log of logs) {
+				this.addLog(log);
+			}
+		}
+
+		this.refreshTimeout();
+	}
+
 	saveFirstError(error) {
 		if (!this.assertError) {
 			this.assertError = error;
 		}
 	}
 
-	plan(count, planStack) {
+	plan(count, planError) {
 		if (typeof count !== 'number') {
 			throw new TypeError('Expected a number');
 		}
@@ -232,7 +418,7 @@ class Test {
 
 		// In case the `planCount` doesn't match `assertCount, we need the stack of
 		// this function to throw with a useful stack.
-		this.planStack = planStack;
+		this.planError = planError;
 	}
 
 	timeout(ms) {
@@ -274,17 +460,33 @@ class Test {
 				assertion: 'plan',
 				message: `Planned for ${this.planCount} ${plur('assertion', this.planCount)}, but got ${this.assertCount}.`,
 				operator: '===',
-				stack: this.planStack
+				savedError: this.planError
 			}));
 		}
 	}
 
 	verifyAssertions() {
-		if (!this.assertError) {
-			if (this.failWithoutAssertions && !this.calledEnd && this.planCount === null && this.assertCount === 0) {
+		if (this.assertError) {
+			return;
+		}
+
+		if (this.pendingAttemptCount > 0) {
+			this.saveFirstError(new Error('Test finished, but not all attempts were committed or discarded'));
+			return;
+		}
+
+		if (this.pendingAssertionCount > 0) {
+			this.saveFirstError(new Error('Test finished, but an assertion is still pending'));
+			return;
+		}
+
+		if (this.failWithoutAssertions) {
+			if (this.planCount !== null) {
+				return; // `verifyPlan()` will report an error already.
+			}
+
+			if (this.assertCount === 0 && !this.calledEnd) {
 				this.saveFirstError(new Error('Test finished without running any assertions'));
-			} else if (this.pendingAssertionCount > 0) {
-				this.saveFirstError(new Error('Test finished, but an assertion is still pending'));
 			}
 		}
 	}
@@ -311,7 +513,7 @@ class Test {
 			fixedSource: {file: pending.file, line: pending.line},
 			improperUsage: true,
 			message: `Improper usage of \`t.${pending.assertion}()\` detected`,
-			stack: error instanceof Error && error.stack,
+			savedError: error instanceof Error && error,
 			values
 		}));
 		return true;
@@ -365,7 +567,7 @@ class Test {
 			if (!this.detectImproperThrows(result.error)) {
 				this.saveFirstError(new assert.AssertionError({
 					message: 'Error thrown in test',
-					stack: result.error instanceof Error && result.error.stack,
+					savedError: result.error instanceof Error && result.error,
 					values: [formatErrorValue('Error thrown in test:', result.error)]
 				}));
 			}
@@ -438,7 +640,7 @@ class Test {
 						if (!this.detectImproperThrows(error)) {
 							this.saveFirstError(new assert.AssertionError({
 								message: 'Rejected promise returned by test',
-								stack: error instanceof Error && error.stack,
+								savedError: error instanceof Error && error,
 								values: [formatErrorValue('Rejected promise returned by test. Reason:', error)]
 							}));
 						}
@@ -477,11 +679,14 @@ class Test {
 		}
 
 		return {
+			deferredSnapshotRecordings: this.deferredSnapshotRecordings,
 			duration: this.duration,
 			error,
 			logs: this.logs,
 			metadata: this.metadata,
 			passed,
+			snapshotCount: this.snapshotCount,
+			assertCount: this.assertCount,
 			title: this.title
 		};
 	}

package/lib/watcher.js

@@ -162,7 +162,7 @@ class Watcher {
 		}).on('all', (event, path) => {
 			if (event === 'add' || event === 'change' || event === 'unlink') {
 				debug('Detected %s of %s', event, path);
-				this.dirtyStates[path] = event;
+				this.dirtyStates[nodePath.join(this.globs.cwd, path)] = event;
 				this.debouncer.debounce();
 			}
 		});
@@ -180,7 +180,7 @@ class Watcher {
 				const dependencies = evt.dependencies.map(x => relative(x)).filter(filePath => {
 					const {isHelper, isSource} = globs.classify(filePath, this.globs);
 					return isHelper || isSource;
-				});
+				}).map(x => nodePath.join(this.globs.cwd, x));
 				this.updateTestDependencies(evt.testFile, dependencies);
 			});
 		});
@@ -215,7 +215,7 @@ class Watcher {
 				}
 
 				for (const file of evt.files) {
-					this.touchedFiles.add(nodePath.relative(process.cwd(), file));
+					this.touchedFiles.add(file);
 				}
 			});
 		});
@@ -229,7 +229,8 @@ class Watcher {
 				}
 
 				const fileStats = plan.status.stats.byFile.get(evt.testFile);
-				this.updateExclusivity(evt.testFile, fileStats.declaredTests > fileStats.selectedTests);
+				const ranExclusiveTests = fileStats.selectedTests > 0 && fileStats.declaredTests > fileStats.selectedTests;
+				this.updateExclusivity(evt.testFile, ranExclusiveTests);
 			});
 		});
 	}

package/lib/worker/fake-tty-has-colors.js

@@ -0,0 +1,19 @@
+'use strict';
+const tty = require('tty');
+
+// Call original method to ensure the correct errors are thrown.
+const assertHasColorsArguments = count => {
+	tty.WriteStream.prototype.hasColors(count);
+};
+
+const makeHasColors = colorDepth => (count = 16, env) => {
+	// `count` is optional too, so make sure it's not an env object.
+	if (env === undefined && typeof count === 'object' && count !== null) {
+		count = 16;
+	}
+
+	assertHasColorsArguments(count);
+	return count <= 2 ** colorDepth;
+};
+
+module.exports = makeHasColors;

package/lib/worker/fake-tty.js

@@ -2,39 +2,85 @@
 const tty = require('tty');
 const ansiEscapes = require('ansi-escapes');
 const options = require('./options').get();
+const makeHasColors = require('./fake-tty-has-colors');
 
 const fakeTTYs = new Set();
 
 const {isatty} = tty;
 tty.isatty = fd => fakeTTYs.has(fd) || isatty(fd);
 
-const simulateTTY = (stream, {colorDepth, columns, rows}) => {
-	Object.assign(stream, {isTTY: true, columns, rows});
+const takesCallbackAndReturnWriteResult = tty.WriteStream.prototype.clearLine.length === 1;
+
+const assertCallback = callback => {
+	// FIXME: Better replicate Node.js' internal errors.
+	if (callback !== undefined && typeof callback !== 'function') {
+		const error = new TypeError('Callback must be a function');
+		error.code = 'ERR_INVALID_CALLBACK';
+		throw error;
+	}
+};
+
+const fakeWriters = {
+	clearLine(dir, callback) {
+		assertCallback(callback);
 
-	stream.clearLine = dir => {
 		switch (dir) {
 			case -1:
-				stream.write(ansiEscapes.eraseStartLine);
-				break;
+				return this.write(ansiEscapes.eraseStartLine, callback);
 			case 1:
-				stream.write(ansiEscapes.eraseEndLine);
-				break;
+				return this.write(ansiEscapes.eraseEndLine, callback);
 			default:
-				stream.write(ansiEscapes.eraseLine);
+				return this.write(ansiEscapes.eraseLine, callback);
 		}
-	};
+	},
 
-	stream.clearScreenDown = () => stream.write(ansiEscapes.eraseDown);
+	clearScreenDown(callback) {
+		assertCallback(callback);
 
-	stream.cursorTo = (x, y) => stream.write(ansiEscapes.cursorTo(x, y));
+		return this.write(ansiEscapes.eraseDown, callback);
+	},
 
-	stream.getWindowSize = () => [80, 24];
+	cursorTo(x, y, callback) {
+		assertCallback(callback);
+		return this.write(ansiEscapes.cursorTo(x, y), callback);
+	},
 
-	stream.moveCursor = (x, y) => stream.write(ansiEscapes.cursorMove(x, y));
+	moveCursor(x, y, callback) {
+		assertCallback(callback);
+		return this.write(ansiEscapes.cursorMove(x, y), callback);
+	}
+};
 
+const simulateTTY = (stream, {colorDepth, hasColors, columns, rows}) => {
+	Object.assign(stream, {isTTY: true, columns, rows});
+
+	if (takesCallbackAndReturnWriteResult) {
+		Object.assign(stream, fakeWriters);
+	} else {
+		Object.assign(stream, {
+			clearLine(dir) {
+				fakeWriters.clearLine.call(this, dir);
+			},
+			clearScreenDown() {
+				fakeWriters.clearScreenDown.call(this);
+			},
+			cursorTo(x, y) {
+				fakeWriters.cursorTo.call(this, x, y);
+			},
+			moveCursor(x, y) {
+				fakeWriters.moveCursor.call(this, x, y);
+			}
+		});
+	}
+
+	stream.getWindowSize = () => [80, 24];
 	if (colorDepth !== undefined) {
 		stream.getColorDepth = () => colorDepth;
 	}
+
+	if (hasColors) {
+		stream.hasColors = makeHasColors(colorDepth);
+	}
 };
 
 if (options.tty.stderr) {

package/lib/worker/subprocess.js

@@ -31,6 +31,7 @@ ipc.options.then(options => {
 	}
 
 	const runner = new Runner({
+		experiments: options.experiments,
 		failFast: options.failFast,
 		failWithoutAssertions: options.failWithoutAssertions,
 		file: options.file,