ava 2.3.0 → 2.4.0

package/index.d.ts

@@ -25,6 +25,13 @@ export type ThrowsExpectation = {
 	name?: string;
 };
 
+export type CommitDiscardOptions = {
+	/**
+	 * Whether the logs should be included in those of the parent test.
+	 */
+	retainLogs?: boolean
+}
+
 /** Options that can be passed to the `t.snapshot()` assertion. */
 export type SnapshotOptions = {
 	/** If provided and not an empty string, used to select the snapshot to compare the `expected` value against. */
@@ -363,6 +370,7 @@ export interface ExecutionContext<Context = unknown> extends Assertions {
 	log: LogFn;
 	plan: PlanFn;
 	timeout: TimeoutFn;
+	try: TryFn<Context>;
 }
 
 export interface LogFn {
@@ -392,6 +400,69 @@ export interface TimeoutFn {
 	(ms: number): void;
 }
 
+export interface TryFn<Context = unknown> {
+	/**
+	 * Requires opt-in. Attempt to run some assertions. The result must be explicitly committed or discarded or else
+	 * the test will fail. A macro may be provided. The title may help distinguish attempts from
+	 * one another.
+	 */
+	<Args extends any[]>(title: string, fn: EitherMacro<Args, Context>, ...args: Args): Promise<TryResult>;
+
+	/**
+	* Requires opt-in. Attempt to run some assertions. The result must be explicitly committed or discarded or else
+	 * the test will fail. A macro may be provided. The title may help distinguish attempts from
+	 * one another.
+	 */
+	<Args extends any[]>(title: string, fn: [EitherMacro<Args, Context>, ...EitherMacro<Args, Context>[]], ...args: Args): Promise<TryResult[]>;
+
+	/**
+	* Requires opt-in. Attempt to run some assertions. The result must be explicitly committed or discarded or else
+	* the test will fail. A macro may be provided.
+	*/
+	<Args extends any[]>(fn: EitherMacro<Args, Context>, ...args: Args): Promise<TryResult>;
+
+	/**
+	* Requires opt-in. Attempt to run some assertions. The result must be explicitly committed or discarded or else
+	* the test will fail. A macro may be provided.
+	*/
+	<Args extends any[]>(fn: [EitherMacro<Args, Context>, ...EitherMacro<Args, Context>[]], ...args: Args): Promise<TryResult[]>;
+}
+
+export interface AssertionError extends Error {}
+
+export interface TryResult {
+	/**
+	* Title of the attempt, helping you tell attempts aparts.
+	*/
+	title: string;
+
+	/**
+	* Indicates whether all assertions passed, or at least one failed.
+	*/
+	passed: boolean;
+
+	/**
+	* Errors raised for each failed assertion.
+	*/
+	errors: AssertionError[];
+
+	/**
+	 * Logs created during the attempt using `t.log()`. Contains formatted values.
+	 */
+	logs: string[];
+
+	/**
+	 * Commit the attempt. Counts as one assertion for the plan count. If the
+	 * attempt failed, calling this will also cause your test to fail.
+	 */
+	commit(options?: CommitDiscardOptions): void;
+
+	/**
+	 * Discard the attempt.
+	 */
+	discard(options?: CommitDiscardOptions): void;
+}
+
 /** The `t` value passed to implementations for tests & hooks declared with the `.cb` modifier. */
 export interface CbExecutionContext<Context = unknown> extends ExecutionContext<Context> {
 	/**

package/lib/api.js

@@ -149,6 +149,7 @@ class Api extends Emittery {
 
 			await this.emit('run', {
 				clearLogOnNextRun: runtimeOptions.clearLogOnNextRun === true,
+				experiments: Object.keys(apiOptions.experiments),
 				failFastEnabled: failFast,
 				filePathPrefix: commonPathPrefix(files),
 				files,
@@ -323,7 +324,7 @@ class Api extends Emittery {
 		const forkExecArgv = execArgv.slice();
 		let flagName = '--inspect';
 		const oldValue = forkExecArgv[inspectArgIndex];
-		if (oldValue.indexOf('brk') > 0) {
+		if (oldValue.includes('brk')) {
 			flagName += '-brk';
 		}
 

package/lib/cli.js

@@ -238,6 +238,7 @@ exports.run = async () => { // eslint-disable-line complexity
 		color: conf.color,
 		compileEnhancements: conf.compileEnhancements !== false,
 		concurrency: conf.concurrency ? parseInt(conf.concurrency, 10) : 0,
+		experiments: conf.nonSemVerExperiments,
 		extensions,
 		failFast: conf.failFast,
 		failWithoutAssertions: conf.failWithoutAssertions !== false,

package/lib/load-config.js

@@ -6,6 +6,7 @@ const pkgConf = require('pkg-conf');
 
 const NO_SUCH_FILE = Symbol('no ava.config.js file');
 const MISSING_DEFAULT_EXPORT = Symbol('missing default export');
+const EXPERIMENTS = new Set(['tryAssertion']);
 
 function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {}} = {}) { // eslint-disable-line complexity
 	let packageConf = pkgConf.sync('ava', {cwd: resolveFrom});
@@ -82,7 +83,20 @@ function loadConfig({configFile, resolveFrom = process.cwd(), defaults = {}} = {
 		}
 	}
 
-	return {...defaults, ...fileConf, ...packageConf, projectDir};
+	const config = {...defaults, nonSemVerExperiments: {}, ...fileConf, ...packageConf, projectDir};
+
+	const {nonSemVerExperiments: experiments} = config;
+	if (!isPlainObject(experiments)) {
+		throw new Error(`nonSemVerExperiments from ${fileForErrorMessage} must be an object`);
+	}
+
+	for (const key of Object.keys(experiments)) {
+		if (!EXPERIMENTS.has(key)) {
+			throw new Error(`nonSemVerExperiments.${key} from ${fileForErrorMessage} is not a supported experiment`);
+		}
+	}
+
+	return config;
 }
 
 module.exports = loadConfig;

package/lib/parse-test-args.js

@@ -0,0 +1,15 @@
+'use strict';
+function parseTestArgs(args) {
+	const rawTitle = typeof args[0] === 'string' ? args.shift() : undefined;
+	const receivedImplementationArray = Array.isArray(args[0]);
+	const implementations = receivedImplementationArray ? args.shift() : args.splice(0, 1);
+
+	const buildTitle = implementation => {
+		const title = implementation.title ? implementation.title(rawTitle, ...args) : rawTitle;
+		return {title, isSet: typeof title !== 'undefined', isValid: typeof title === 'string', isEmpty: !title};
+	};
+
+	return {args, buildTitle, implementations, rawTitle, receivedImplementationArray};
+}
+
+module.exports = parseTestArgs;

package/lib/reporters/mini.js

@@ -135,6 +135,11 @@ class MiniReporter {
 
 		cliCursor.hide(this.reportStream);
 		this.lineWriter.writeLine();
+
+		if (plan.experiments.length > 0) {
+			this.lineWriter.writeLine(colors.information(`${figures.warning} Experiments are enabled. These are unsupported and may change or be be removed at any time.`));
+		}
+
 		this.spinner.start();
 	}
 

package/lib/reporters/verbose.js

@@ -97,6 +97,9 @@ class VerboseReporter {
 		}
 
 		this.lineWriter.writeLine();
+		if (plan.experiments.length > 0) {
+			this.lineWriter.writeLine(colors.information(`${figures.warning} Experiments are enabled. These are unsupported and may change or be removed at any time.${os.EOL}`));
+		}
 	}
 
 	consumeStateChange(evt) { // eslint-disable-line complexity

package/lib/runner.js

@@ -3,6 +3,7 @@ const Emittery = require('emittery');
 const matcher = require('matcher');
 const ContextRef = require('./context-ref');
 const createChain = require('./create-chain');
+const parseTestArgs = require('./parse-test-args');
 const snapshotManager = require('./snapshot-manager');
 const serializeError = require('./serialize-error');
 const Runnable = require('./test');
@@ -11,6 +12,7 @@ class Runner extends Emittery {
 	constructor(options = {}) {
 		super();
 
+		this.experiments = options.experiments || {};
 		this.failFast = options.failFast === true;
 		this.failWithoutAssertions = options.failWithoutAssertions !== false;
 		this.file = options.file;
@@ -39,12 +41,21 @@ class Runner extends Emittery {
 		};
 
 		const uniqueTestTitles = new Set();
+		this.registerUniqueTitle = title => {
+			if (uniqueTestTitles.has(title)) {
+				return false;
+			}
+
+			uniqueTestTitles.add(title);
+			return true;
+		};
+
 		let hasStarted = false;
 		let scheduledStart = false;
 		const meta = Object.freeze({
 			file: options.file
 		});
-		this.chain = createChain((metadata, args) => { // eslint-disable-line complexity
+		this.chain = createChain((metadata, testArgs) => { // eslint-disable-line complexity
 			if (hasStarted) {
 				throw new Error('All tests and hooks must be declared synchronously in your test file, and cannot be nested within other tests or hooks.');
 			}
@@ -57,40 +68,33 @@ class Runner extends Emittery {
 				});
 			}
 
-			const specifiedTitle = typeof args[0] === 'string' ?
-				args.shift() :
-				undefined;
-			const implementations = Array.isArray(args[0]) ?
-				args.shift() :
-				args.splice(0, 1);
+			const {args, buildTitle, implementations, rawTitle} = parseTestArgs(testArgs);
 
 			if (metadata.todo) {
 				if (implementations.length > 0) {
 					throw new TypeError('`todo` tests are not allowed to have an implementation. Use `test.skip()` for tests with an implementation.');
 				}
 
-				if (specifiedTitle === undefined || specifiedTitle === '') {
+				if (!rawTitle) { // Either undefined or a string.
 					throw new TypeError('`todo` tests require a title');
 				}
 
-				if (uniqueTestTitles.has(specifiedTitle)) {
-					throw new Error(`Duplicate test title: ${specifiedTitle}`);
-				} else {
-					uniqueTestTitles.add(specifiedTitle);
+				if (!this.registerUniqueTitle(rawTitle)) {
+					throw new Error(`Duplicate test title: ${rawTitle}`);
 				}
 
 				if (this.match.length > 0) {
 					// --match selects TODO tests.
-					if (matcher([specifiedTitle], this.match).length === 1) {
+					if (matcher([rawTitle], this.match).length === 1) {
 						metadata.exclusive = true;
 						this.runOnlyExclusive = true;
 					}
 				}
 
-				this.tasks.todo.push({title: specifiedTitle, metadata});
+				this.tasks.todo.push({title: rawTitle, metadata});
 				this.emit('stateChange', {
 					type: 'declared-test',
-					title: specifiedTitle,
+					title: rawTitle,
 					knownFailing: false,
 					todo: true
 				});
@@ -100,15 +104,13 @@ class Runner extends Emittery {
 				}
 
 				for (const implementation of implementations) {
-					let title = implementation.title ?
-						implementation.title(specifiedTitle, ...args) :
-						specifiedTitle;
+					let {title, isSet, isValid, isEmpty} = buildTitle(implementation);
 
-					if (title !== undefined && typeof title !== 'string') {
+					if (isSet && !isValid) {
 						throw new TypeError('Test & hook titles must be strings');
 					}
 
-					if (title === undefined || title === '') {
+					if (isEmpty) {
 						if (metadata.type === 'test') {
 							throw new TypeError('Tests must have a title');
 						} else if (metadata.always) {
@@ -118,12 +120,8 @@ class Runner extends Emittery {
 						}
 					}
 
-					if (metadata.type === 'test') {
-						if (uniqueTestTitles.has(title)) {
-							throw new Error(`Duplicate test title: ${title}`);
-						} else {
-							uniqueTestTitles.add(title);
-						}
+					if (metadata.type === 'test' && !this.registerUniqueTitle(title)) {
+						throw new Error(`Duplicate test title: ${title}`);
 					}
 
 					const task = {
@@ -162,6 +160,7 @@ class Runner extends Emittery {
 			todo: false,
 			failing: false,
 			callback: false,
+			inline: false, // Set for attempt metadata created by `t.try()`
 			always: false
 		}, meta);
 	}
@@ -269,6 +268,7 @@ class Runner extends Emittery {
 	async runHooks(tasks, contextRef, titleSuffix) {
 		const hooks = tasks.map(task => new Runnable({
 			contextRef,
+			experiments: this.experiments,
 			failWithoutAssertions: false,
 			fn: task.args.length === 0 ?
 				task.implementation :
@@ -309,6 +309,7 @@ class Runner extends Emittery {
 			// Only run the test if all `beforeEach` hooks passed.
 			const test = new Runnable({
 				contextRef,
+				experiments: this.experiments,
 				failWithoutAssertions: this.failWithoutAssertions,
 				fn: task.args.length === 0 ?
 					task.implementation :
@@ -316,7 +317,8 @@ class Runner extends Emittery {
 				compareTestSnapshot: this.boundCompareTestSnapshot,
 				updateSnapshots: this.updateSnapshots,
 				metadata: task.metadata,
-				title: task.title
+				title: task.title,
+				registerUniqueTitle: this.registerUniqueTitle
 			});
 
 			const result = await this.runSingle(test);

package/lib/serialize-error.js

@@ -39,7 +39,8 @@ function buildSource(source) {
 	const file = path.resolve(projectDir, source.file.trim());
 	const rel = path.relative(projectDir, file);
 
-	const isWithinProject = rel.split(path.sep)[0] !== '..';
+	const [segment] = rel.split(path.sep);
+	const isWithinProject = segment !== '..' && (process.platform !== 'win32' || !segment.includes(':'));
 	const isDependency = isWithinProject && path.dirname(rel).split(path.sep).includes('node_modules');
 
 	return {

package/lib/snapshot-manager.js

@@ -305,45 +305,64 @@ class Manager {
 	compare(options) {
 		const hash = md5Hex(options.belongsTo);
 		const entries = this.snapshotsByHash.get(hash) || [];
-		if (options.index > entries.length) {
-			throw new RangeError(`Cannot record snapshot ${options.index} for ${JSON.stringify(options.belongsTo)}, exceeds expected index of ${entries.length}`);
-		}
+		const snapshotBuffer = entries[options.index];
 
-		if (options.index === entries.length) {
+		if (!snapshotBuffer) {
 			if (!this.recordNewSnapshots) {
 				return {pass: false};
 			}
 
+			if (options.deferRecording) {
+				const record = this.deferRecord(hash, options);
+				return {pass: true, record};
+			}
+
 			this.record(hash, options);
 			return {pass: true};
 		}
 
-		const snapshotBuffer = entries[options.index];
 		const actual = concordance.deserialize(snapshotBuffer, concordanceOptions);
-
 		const expected = concordance.describe(options.expected, concordanceOptions);
 		const pass = concordance.compareDescriptors(actual, expected);
 
 		return {actual, expected, pass};
 	}
 
-	record(hash, options) {
+	deferRecord(hash, options) {
 		const descriptor = concordance.describe(options.expected, concordanceOptions);
-
-		this.hasChanges = true;
 		const snapshot = concordance.serialize(descriptor);
-		if (this.snapshotsByHash.has(hash)) {
-			this.snapshotsByHash.get(hash).push(snapshot);
-		} else {
-			this.snapshotsByHash.set(hash, [snapshot]);
-		}
-
 		const entry = formatEntry(options.label, descriptor);
-		if (this.reportEntries.has(options.belongsTo)) {
-			this.reportEntries.get(options.belongsTo).push(entry);
-		} else {
-			this.reportEntries.set(options.belongsTo, [entry]);
-		}
+
+		return () => { // Must be called in order!
+			this.hasChanges = true;
+
+			let snapshots = this.snapshotsByHash.get(hash);
+			if (!snapshots) {
+				snapshots = [];
+				this.snapshotsByHash.set(hash, snapshots);
+			}
+
+			if (options.index > snapshots.length) {
+				throw new RangeError(`Cannot record snapshot ${options.index} for ${JSON.stringify(options.belongsTo)}, exceeds expected index of ${snapshots.length}`);
+			}
+
+			if (options.index < snapshots.length) {
+				throw new RangeError(`Cannot record snapshot ${options.index} for ${JSON.stringify(options.belongsTo)}, already exists`);
+			}
+
+			snapshots.push(snapshot);
+
+			if (this.reportEntries.has(options.belongsTo)) {
+				this.reportEntries.get(options.belongsTo).push(entry);
+			} else {
+				this.reportEntries.set(options.belongsTo, [entry]);
+			}
+		};
+	}
+
+	record(hash, options) {
+		const record = this.deferRecord(hash, options);
+		record();
 	}
 
 	save() {

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) {
@@ -67,6 +68,95 @@ 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() {
@@ -99,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;
@@ -133,11 +265,12 @@ 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() {
@@ -147,7 +280,11 @@ class Test {
 			};
 		}
 
-		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, savedError) {
@@ -181,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();
 	}
@@ -191,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++;
@@ -211,11 +356,53 @@ 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;
@@ -279,11 +466,27 @@ class Test {
 	}
 
 	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'));
 			}
 		}
 	}
@@ -476,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/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,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ava",
-	"version": "2.3.0",
+	"version": "2.4.0",
 	"description": "Testing can be a drag. AVA helps you get it done.",
 	"license": "MIT",
 	"repository": "avajs/ava",
@@ -11,7 +11,7 @@
 	},
 	"scripts": {
 		"lint": "xo",
-		"test:tap": "tap --no-esm",
+		"test:tap": "tap",
 		"test:typescript": "tsc --noEmit -p test/ts-types",
 		"test": "npm run lint && npm run test:typescript && npm run test:tap"
 	},
@@ -59,11 +59,11 @@
 	"dependencies": {
 		"@ava/babel-preset-stage-4": "^4.0.0",
 		"@ava/babel-preset-transform-test-files": "^6.0.0",
-		"@babel/core": "^7.5.5",
-		"@babel/generator": "^7.5.5",
+		"@babel/core": "^7.6.0",
+		"@babel/generator": "^7.6.0",
 		"@concordance/react": "^2.0.0",
 		"ansi-escapes": "^4.2.1",
-		"ansi-styles": "^4.0.0",
+		"ansi-styles": "^4.1.0",
 		"arr-flatten": "^1.1.0",
 		"array-union": "^2.1.0",
 		"array-uniq": "^2.1.0",
@@ -132,27 +132,26 @@
 		"write-file-atomic": "^3.0.0"
 	},
 	"devDependencies": {
-		"@types/node": "^10.14.15",
+		"@types/node": "^10.14.18",
 		"cli-table3": "^0.5.1",
-		"codecov": "^3.5.0",
 		"delay": "^4.3.0",
-		"execa": "^2.0.3",
+		"execa": "^2.0.4",
 		"get-stream": "^5.1.0",
 		"git-branch": "^2.0.1",
-		"has-ansi": "^3.0.0",
+		"has-ansi": "^4.0.0",
 		"lolex": "^4.2.0",
-		"proxyquire": "^2.1.2",
+		"proxyquire": "^2.1.3",
 		"react": "^16.9.0",
 		"react-test-renderer": "^16.9.0",
 		"replace-string": "^3.0.0",
 		"signal-exit": "^3.0.0",
-		"sinon": "^7.4.1",
+		"sinon": "^7.4.2",
 		"source-map-fixtures": "^2.1.0",
-		"tap": "^14.6.1",
+		"tap": "^14.6.4",
 		"temp-write": "^4.0.0",
 		"touch": "^3.1.0",
 		"ts-node": "^8.3.0",
-		"typescript": "^3.5.3",
+		"typescript": "^3.6.3",
 		"xo": "^0.24.0",
 		"zen-observable": "^0.8.14"
 	},

package/profile.js

@@ -145,6 +145,7 @@ runStatus.observeWorker({
 }, file);
 
 reporter.startRun({
+	experiments: [],
 	failFastEnabled: false,
 	files: [file],
 	matching: false,

package/readme.md

@@ -216,6 +216,7 @@ It's the [Andromeda galaxy](https://simple.wikipedia.org/wiki/Andromeda_galaxy).
 - [AVA stickers, t-shirts, etc](https://www.redbubble.com/people/sindresorhus/works/30330590-ava-logo)
 - [Awesome list](https://github.com/avajs/awesome-ava)
 - [AVA Casts](http://avacasts.com)
+- [Do you like AVA? Donate here!](https://opencollective.com/ava)
 - [More…](https://github.com/avajs/awesome-ava)
 
 ## Team