ava 3.15.0 → 4.0.0

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);
@@ -15,13 +15,13 @@ function formatErrorValue(label, error) {
 const captureSavedError = () => {
 	const limitBefore = Error.stackTraceLimit;
 	Error.stackTraceLimit = 1;
-	const err = new Error();
+	const error = new Error(); // eslint-disable-line unicorn/error-message
 	Error.stackTraceLimit = limitBefore;
-	return err;
+	return error;
 };
 
 const testMap = new WeakMap();
-class ExecutionContext extends assert.Assertions {
+class ExecutionContext extends Assertions {
 	constructor(test) {
 		super({
 			pass: () => {
@@ -30,18 +30,15 @@ class ExecutionContext extends assert.Assertions {
 			pending: promise => {
 				test.addPendingAssertion(promise);
 			},
-			fail: err => {
-				test.addFailedAssertion(err);
+			fail: error => {
+				test.addFailedAssertion(error);
 			},
 			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,97 +76,87 @@ 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;
 					}
-				};
-			});
 
-			const results = await Promise.all(attemptPromises);
-			return receivedImplementationArray ? results : results[0];
-		};
-	}
+					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;
+					}
 
-	get end() {
-		const end = testMap.get(this).bindEndCallback();
-		const endFn = error => end(error, captureSavedError());
-		return endFn;
+					if (discarded) {
+						return;
+					}
+
+					discarded = true;
+					test.finishAttempt({
+						assertCount: 0,
+						commit: false,
+						deferredSnapshotRecordings,
+						errors,
+						logs,
+						passed,
+						retainLogs,
+						snapshotCount,
+						startingSnapshotCount,
+					});
+				},
+			};
+		};
 	}
 
 	get title() {
@@ -190,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 || {};
@@ -208,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;
@@ -222,24 +199,20 @@ class Test {
 
 		const deferRecording = this.metadata.inline;
 		this.deferredSnapshotRecordings = [];
-		this.compareWithSnapshot = ({expected, id, message}) => {
+		this.compareWithSnapshot = ({expected, 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 belongsTo = snapshotBelongsTo;
+			const index = this.nextSnapshotIndex++;
+			const label = message;
 
-			const {taskIndex, associatedTaskIndex} = this.metadata;
 			const {record, ...result} = options.compareTestSnapshot({
 				belongsTo,
 				deferRecording,
 				expected,
 				index,
 				label,
-				taskIndex,
-				snapIndex: this.snapshotCount,
-				associatedTaskIndex
+				taskIndex: this.metadata.taskIndex,
 			});
 			if (record) {
 				this.deferredSnapshotRecordings.push(record);
@@ -250,16 +223,20 @@ class Test {
 
 		this.skipSnapshot = () => {
 			if (typeof options.skipSnapshot === 'function') {
-				options.skipSnapshot();
+				const record = options.skipSnapshot({
+					belongsTo: snapshotBelongsTo,
+					index: this.nextSnapshotIndex,
+					deferRecording,
+					taskIndex: this.metadata.taskIndex,
+				});
+				if (record) {
+					this.deferredSnapshotRecordings.push(record);
+				}
 			}
 
-			if (options.updateSnapshots) {
-				this.addFailedAssertion(new Error('Snapshot assertions cannot be skipped when updating snapshots'));
-			} else {
-				this.nextSnapshotIndex++;
-				this.snapshotCount++;
-				this.countPassedAssertion();
-			}
+			this.nextSnapshotIndex++;
+			this.snapshotCount++;
+			this.countPassedAssertion();
 		};
 
 		this.runAttempt = async (title, fn) => {
@@ -274,11 +251,11 @@ class Test {
 			const attempt = new Test({
 				...options,
 				fn,
-				metadata: {...options.metadata, callback: false, failing: false, inline: true},
+				metadata: {...options.metadata, failing: false, inline: true},
 				contextRef: contextRef.copy(),
 				snapshotBelongsTo,
 				nextSnapshotIndex,
-				title
+				title,
 			});
 
 			const {deferredSnapshotRecordings, error, logs, passed, assertCount, snapshotCount} = await attempt.run();
@@ -291,53 +268,17 @@ class Test {
 		this.attemptCount = 0;
 		this.calledEnd = false;
 		this.duration = null;
-		this.endCallbackFinisher = 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;
 		this.timeoutTimer = null;
 	}
 
-	bindEndCallback() {
-		if (this.metadata.callback) {
-			return (error, savedError) => {
-				this.endCallback(error, savedError);
-			};
-		}
-
-		const error_ = this.metadata.inline ? new Error('`t.end()` is not supported inside `t.try()`') : 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)`');
-		throw error_;
-	}
-
-	endCallback(error, savedError) {
-		if (this.calledEnd) {
-			this.saveFirstError(new Error('`t.end()` called more than once'));
-			return;
-		}
-
-		this.calledEnd = true;
-
-		if (error) {
-			this.saveFirstError(new assert.AssertionError({
-				actual: error,
-				message: 'Callback called with an error',
-				savedError,
-				values: [formatErrorValue('Callback called with an error:', error)]
-			}));
-		}
-
-		if (this.endCallbackFinisher) {
-			this.endCallbackFinisher();
-		}
-	}
-
 	createExecutionContext() {
 		return new ExecutionContext(this);
 	}
@@ -374,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();
 			});
@@ -451,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.
@@ -471,6 +412,8 @@ class Test {
 				this.finishDueToTimeout();
 			}
 		}, ms);
+
+		this.notifyTimeoutUpdate(this.timeoutMs);
 	}
 
 	refreshTimeout() {
@@ -509,11 +452,7 @@ class Test {
 	}
 
 	async runTeardowns() {
-		const teardowns = [...this.teardowns];
-
-		if (this.experiments.reverseTeardowns) {
-			teardowns.reverse();
-		}
+		const teardowns = [...this.teardowns].reverse();
 
 		for (const teardown of teardowns) {
 			try {
@@ -526,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,
 			}));
 		}
 	}
@@ -561,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,
 			};
 		}
 	}
@@ -634,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();
 		}
@@ -653,7 +536,7 @@ class Test {
 			promise = new Promise((resolve, reject) => {
 				result.retval.subscribe({
 					error: reject,
-					complete: () => resolve()
+					complete: () => resolve(),
 				});
 			});
 		} else if (returnedPromise) {
@@ -661,37 +544,6 @@ class Test {
 			promise = Promise.resolve(result.retval);
 		}
 
-		if (this.metadata.callback) {
-			if (returnedObservable || returnedPromise) {
-				const asyncType = returnedObservable ? 'observables' : 'promises';
-				this.saveFirstError(new Error(`Do not return ${asyncType} from tests declared via \`test.cb(…)\`. Use \`test.cb(…)\` for legacy callback APIs. When using promises, observables or async functions, use \`test(…)\`.`));
-				return this.finish();
-			}
-
-			if (this.calledEnd) {
-				return this.finish();
-			}
-
-			return new Promise(resolve => {
-				this.endCallbackFinisher = () => {
-					resolve(this.finish());
-				};
-
-				this.finishDueToAttributedError = () => {
-					resolve(this.finish());
-				};
-
-				this.finishDueToTimeout = () => {
-					resolve(this.finish());
-				};
-
-				this.finishDueToInactivity = () => {
-					this.saveFirstError(new Error('`t.end()` was never called'));
-					resolve(this.finish());
-				};
-			});
-		}
-
 		if (promise) {
 			return new Promise(resolve => {
 				this.finishDueToAttributedError = () => {
@@ -703,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()));
 			});
 		}
 
@@ -730,10 +580,6 @@ class Test {
 	async finish() {
 		this.finishing = true;
 
-		if (!this.assertError && this.pendingThrowsAssertion) {
-			return this.waitForPendingThrowsAssertion();
-		}
-
 		this.clearTimeout();
 		this.verifyPlan();
 		this.verifyAssertions();
@@ -759,9 +605,7 @@ class Test {
 			passed,
 			snapshotCount: this.snapshotCount,
 			assertCount: this.assertCount,
-			title: this.title
+			title: this.title,
 		};
 	}
 }
-
-module.exports = Test;