Remove support for passing multiple test implementations

This affects test() and t.try().

Supporting multiple implementations made both the implementation and the
type definitions needlessly complex. Using for/of syntax it's easy
enough to declare tests (or t.try() attempts) with the same arguments.

Author: novemberborn

docs/01-writing-tests.md

@@ -319,21 +319,4 @@ test('providedTitle', macro, '3 * 3', 9);
 
 The `providedTitle` argument defaults to `undefined` if the user does not supply a string title. This means you can use a parameter assignment to set the default value. The example above uses the empty string as the default.
 
-You can also pass arrays of macro functions:
-
-```js
-const safeEval = require('safe-eval');
-
-function evalMacro(t, input, expected) {
-	t.is(eval(input), expected);
-}
-
-function safeEvalMacro(t, input, expected) {
-	t.is(safeEval(input), expected);
-}
-
-test([evalMacro, safeEvalMacro], '2 + 2', 4);
-test([evalMacro, safeEvalMacro], '2 * 3', 6);
-```
-
 We encourage you to use macros instead of building your own test generators ([here is an example](https://github.com/avajs/ava-codemods/blob/47073b5b58aa6f3fb24f98757be5d3f56218d160/test/ok-to-truthy.js#L7-L9) of code that should be replaced with a macro). Macros are designed to perform static analysis of your code, which can lead to better performance, IDE integration, and linter rules.

docs/03-assertions.md

@@ -330,7 +330,7 @@ AVA 3 supports an  `options` object that lets you select a specific snapshot, fo
 
 In AVA 3, you cannot update snapshots while using `t.snapshot.skip()`.
 
-### `.try(title?, implementation | macro | macro[], ...args?)`
+### `.try(title?, implementation | macro, ...args?)`
 
 `.try()` allows you to *try* assertions without causing the test to fail.
 

index.d.ts

@@ -409,24 +409,11 @@ export interface TryFn<Context = unknown> {
 	 */
 	<Args extends any[]>(title: string, fn: EitherMacro<Args, Context>, ...args: Args): Promise<TryResult>;
 
-	/**
-	 * 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>, ...Array<EitherMacro<Args, Context>>], ...args: Args): Promise<TryResult[]>;
-
 	/**
 	 * 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>;
-
-	/**
-	 * 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>, ...Array<EitherMacro<Args, Context>>], ...args: Args): Promise<TryResult[]>;
 }
 
 export interface AssertionError extends Error {}
@@ -483,18 +470,15 @@ export type Macro<Args extends any[], Context = unknown> = UntitledMacro<Args, C
 
 export type EitherMacro<Args extends any[], Context> = Macro<Args, Context> | UntitledMacro<Args, Context>;
 
-/** Alias for a single macro, or an array of macros. */
-export type OneOrMoreMacros<Args extends any[], Context> = EitherMacro<Args, Context> | [EitherMacro<Args, Context>, ...Array<EitherMacro<Args, Context>>];
-
 export interface TestInterface<Context = unknown> {
 	/** Declare a concurrent test. */
 	(title: string, implementation: Implementation<Context>): void;
 
-	/** Declare a concurrent test that uses one or more macros. Additional arguments are passed to the macro. */
-	<T extends any[]>(title: string, macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	/** Declare a concurrent test that uses a macro. Additional arguments are passed to the macro. */
+	<T extends any[]>(title: string, macro: EitherMacro<T, Context>, ...rest: T): void;
 
-	/** Declare a concurrent test that uses one or more macros. The macro is responsible for generating a unique test title. */
-	<T extends any[]>(macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	/** Declare a concurrent test that uses a macro. The macro is responsible for generating a unique test title. */
+	<T extends any[]>(macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	/** Declare a hook that is run once, after all tests have passed. */
 	after: AfterInterface<Context>;
@@ -528,10 +512,10 @@ export interface AfterInterface<Context = unknown> {
 	(title: string, implementation: Implementation<Context>): void;
 
 	/** Declare a hook that is run once, after all tests have passed. Additional arguments are passed to the macro. */
-	<T extends any[]>(title: string, macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(title: string, macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	/** Declare a hook that is run once, after all tests have passed. */
-	<T extends any[]>(macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	/** Declare a hook that is run once, after all tests are done. */
 	always: AlwaysInterface<Context>;
@@ -547,10 +531,10 @@ export interface AlwaysInterface<Context = unknown> {
 	(title: string, implementation: Implementation<Context>): void;
 
 	/** Declare a hook that is run once, after all tests are done. Additional arguments are passed to the macro. */
-	<T extends any[]>(title: string, macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(title: string, macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	/** Declare a hook that is run once, after all tests are done. */
-	<T extends any[]>(macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	skip: HookSkipInterface<Context>;
 }
@@ -563,10 +547,10 @@ export interface BeforeInterface<Context = unknown> {
 	(title: string, implementation: Implementation<Context>): void;
 
 	/** Declare a hook that is run once, before all tests. Additional arguments are passed to the macro. */
-	<T extends any[]>(title: string, macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(title: string, macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	/** Declare a hook that is run once, before all tests. */
-	<T extends any[]>(macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	skip: HookSkipInterface<Context>;
 }
@@ -576,16 +560,16 @@ export interface FailingInterface<Context = unknown> {
 	(title: string, implementation: Implementation<Context>): void;
 
 	/**
-	 * Declare a concurrent test that uses one or more macros. Additional arguments are passed to the macro.
+	 * Declare a concurrent test that uses a macro. Additional arguments are passed to the macro.
 	 * The test is expected to fail.
 	 */
-	<T extends any[]>(title: string, macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(title: string, macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	/**
-	 * Declare a concurrent test that uses one or more macros. The macro is responsible for generating a unique test title.
+	 * Declare a concurrent test that uses a macro. The macro is responsible for generating a unique test title.
 	 * The test is expected to fail.
 	 */
-	<T extends any[]>(macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	only: OnlyInterface<Context>;
 	skip: SkipInterface<Context>;
@@ -599,40 +583,40 @@ export interface HookSkipInterface<Context = unknown> {
 	(title: string, implementation: Implementation<Context>): void;
 
 	/** Skip this hook. */
-	<T extends any[]>(title: string, macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(title: string, macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	/** Skip this hook. */
-	<T extends any[]>(macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(macro: EitherMacro<T, Context>, ...rest: T): void;
 }
 
 export interface OnlyInterface<Context = unknown> {
 	/** Declare a test. Only this test and others declared with `.only()` are run. */
 	(title: string, implementation: Implementation<Context>): void;
 
 	/**
-	 * Declare a test that uses one or more macros. Additional arguments are passed to the macro.
+	 * Declare a test that uses a macro. Additional arguments are passed to the macro.
 	 * Only this test and others declared with `.only()` are run.
 	 */
-	<T extends any[]>(title: string, macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(title: string, macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	/**
-	 * Declare a test that uses one or more macros. The macro is responsible for generating a unique test title.
+	 * Declare a test that uses a macro. The macro is responsible for generating a unique test title.
 	 * Only this test and others declared with `.only()` are run.
 	 */
-	<T extends any[]>(macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(macro: EitherMacro<T, Context>, ...rest: T): void;
 }
 
 export interface SerialInterface<Context = unknown> {
 	/** Declare a serial test. */
 	(title: string, implementation: Implementation<Context>): void;
 
-	/** Declare a serial test that uses one or more macros. Additional arguments are passed to the macro. */
-	<T extends any[]>(title: string, macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	/** Declare a serial test that uses a macro. Additional arguments are passed to the macro. */
+	<T extends any[]>(title: string, macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	/**
-	 * Declare a serial test that uses one or more macros. The macro is responsible for generating a unique test title.
+	 * Declare a serial test that uses a macro. The macro is responsible for generating a unique test title.
 	 */
-	<T extends any[]>(macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	/** Declare a serial hook that is run once, after all tests have passed. */
 	after: AfterInterface<Context>;
@@ -659,10 +643,10 @@ export interface SkipInterface<Context = unknown> {
 	(title: string, implementation: Implementation<Context>): void;
 
 	/** Skip this test. */
-	<T extends any[]>(title: string, macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(title: string, macro: EitherMacro<T, Context>, ...rest: T): void;
 
 	/** Skip this test. */
-	<T extends any[]>(macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
+	<T extends any[]>(macro: EitherMacro<T, Context>, ...rest: T): void;
 }
 
 export interface TodoDeclaration {

lib/parse-test-args.js

@@ -1,14 +1,26 @@
-const normalize = title => typeof title === 'string' ? title.trim().replace(/\s+/g, ' ') : title;
+const buildTitle = (raw, implementation, args) => {
+	let value = implementation && implementation.title ? implementation.title(raw, ...args) : raw;
+	const isValid = typeof value === 'string';
+	if (isValid) {
+		value = value.trim().replace(/\s+/g, ' ');
+	}
+
+	return {
+		raw,
+		value,
+		isSet: value !== undefined,
+		isValid,
+		isEmpty: !isValid || value === ''
+	};
+};
 
 export default 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 implementation = args.shift();
 
-	const buildTitle = implementation => {
-		const title = normalize(implementation.title ? implementation.title(rawTitle, ...args) : rawTitle);
-		return {title, isSet: typeof title !== 'undefined', isValid: typeof title === 'string', isEmpty: !title};
+	return {
+		args,
+		implementation,
+		title: buildTitle(rawTitle, implementation, args)
 	};
-
-	return {args, buildTitle, implementations, rawTitle, receivedImplementationArray};
 }

lib/runner.js

@@ -100,94 +100,95 @@ export default class Runner extends Emittery {
 
 			metadata.taskIndex = this.nextTaskIndex++;
 
-			const {args, buildTitle, implementations, rawTitle} = parseTestArgs(testArgs);
+			const {args, implementation, title} = parseTestArgs(testArgs);
 
 			if (this.checkSelectedByLineNumbers) {
 				metadata.selected = this.checkSelectedByLineNumbers();
 			}
 
 			if (metadata.todo) {
-				if (implementations.length > 0) {
+				if (implementation) {
 					throw new TypeError('`todo` tests are not allowed to have an implementation. Use `test.skip()` for tests with an implementation.');
 				}
 
-				if (!rawTitle) { // Either undefined or a string.
+				if (!title.raw) { // Either undefined or a string.
 					throw new TypeError('`todo` tests require a title');
 				}
 
-				if (!this.registerUniqueTitle(rawTitle)) {
-					throw new Error(`Duplicate test title: ${rawTitle}`);
+				if (!this.registerUniqueTitle(title.value)) {
+					throw new Error(`Duplicate test title: ${title.value}`);
 				}
 
 				// --match selects TODO tests.
-				if (this.match.length > 0 && matcher([rawTitle], this.match).length === 1) {
+				if (this.match.length > 0 && matcher([title.value], this.match).length === 1) {
 					metadata.exclusive = true;
 					this.runOnlyExclusive = true;
 				}
 
-				this.tasks.todo.push({title: rawTitle, metadata});
+				this.tasks.todo.push({title: title.value, metadata});
 				this.emit('stateChange', {
 					type: 'declared-test',
-					title: rawTitle,
+					title: title.value,
 					knownFailing: false,
 					todo: true
 				});
 			} else {
-				if (implementations.length === 0) {
+				if (!implementation) {
 					throw new TypeError('Expected an implementation. Use `test.todo()` for tests without an implementation.');
 				}
 
-				for (const implementation of implementations) {
-					let {title, isSet, isValid, isEmpty} = buildTitle(implementation);
+				if (Array.isArray(implementation)) {
+					throw new TypeError('AVA 4 no longer supports multiple implementations.');
+				}
+
+				if (title.isSet && !title.isValid) {
+					throw new TypeError('Test & hook titles must be strings');
+				}
 
-					if (isSet && !isValid) {
-						throw new TypeError('Test & hook titles must be strings');
+				let fallbackTitle = title.value;
+				if (title.isEmpty) {
+					if (metadata.type === 'test') {
+						throw new TypeError('Tests must have a title');
+					} else if (metadata.always) {
+						fallbackTitle = `${metadata.type}.always hook`;
+					} else {
+						fallbackTitle = `${metadata.type} hook`;
 					}
+				}
 
-					if (isEmpty) {
-						if (metadata.type === 'test') {
-							throw new TypeError('Tests must have a title');
-						} else if (metadata.always) {
-							title = `${metadata.type}.always hook`;
-						} else {
-							title = `${metadata.type} hook`;
-						}
+				if (metadata.type === 'test' && !this.registerUniqueTitle(title.value)) {
+					throw new Error(`Duplicate test title: ${title.value}`);
+				}
+
+				const task = {
+					title: title.value || fallbackTitle,
+					implementation,
+					args,
+					metadata: {...metadata}
+				};
+
+				if (metadata.type === 'test') {
+					if (this.match.length > 0) {
+						// --match overrides .only()
+						task.metadata.exclusive = matcher([title.value], this.match).length === 1;
 					}
 
-					if (metadata.type === 'test' && !this.registerUniqueTitle(title)) {
-						throw new Error(`Duplicate test title: ${title}`);
+					if (task.metadata.exclusive) {
+						this.runOnlyExclusive = true;
 					}
 
-					const task = {
-						title,
-						implementation,
-						args,
-						metadata: {...metadata}
-					};
+					this.tasks[metadata.serial ? 'serial' : 'concurrent'].push(task);
 
-					if (metadata.type === 'test') {
-						if (this.match.length > 0) {
-							// --match overrides .only()
-							task.metadata.exclusive = matcher([title], this.match).length === 1;
-						}
-
-						if (task.metadata.exclusive) {
-							this.runOnlyExclusive = true;
-						}
-
-						this.tasks[metadata.serial ? 'serial' : 'concurrent'].push(task);
-
-						this.snapshots.touch(title, metadata.taskIndex);
-
-						this.emit('stateChange', {
-							type: 'declared-test',
-							title,
-							knownFailing: metadata.failing,
-							todo: false
-						});
-					} else if (!metadata.skipped) {
-						this.tasks[metadata.type + (metadata.always ? 'Always' : '')].push(task);
-					}
+					this.snapshots.touch(title.value, metadata.taskIndex);
+
+					this.emit('stateChange', {
+						type: 'declared-test',
+						title: title.value,
+						knownFailing: metadata.failing,
+						todo: false
+					});
+				} else if (!metadata.skipped) {
+					this.tasks[metadata.type + (metadata.always ? 'Always' : '')].push(task);
 				}
 			}
 		}, {