Add prefer-t-throws rule

docs/rules/prefer-t-throws.md

@@ -0,0 +1,56 @@
+# Prefer using `t.throws()` or `t.throwsAsync()` over try/catch
+
+This rule will enforce the use of `t.throws()` or `t.throwsAsync()` when possible.
+
+## Fail
+
+```js
+const test = require('ava');
+
+test('some test', async t => {
+	try {
+		await throwingFunction();
+		t.fail();
+	} catch (error) {
+		t.is(error.message, 'Unicorn overload');
+	}
+});
+```
+
+```js
+const test = require('ava');
+
+test('some test', async t => {
+	try {
+		await potentiallyThrowingFunction();
+		await anotherPromise;
+		await timeout(100, 'Unicorn timeout');
+		t.fail();
+	} catch (error) {
+		t.ok(error.message.startsWith('Unicorn'));
+	}
+});
+```
+
+```js
+const test = require('ava');
+
+test('some test', async t => {
+	try {
+		synchronousThrowingFunction();
+		t.fail();
+	} catch (error) {
+		t.is(error.message, 'Missing Unicorn argument');
+	}
+});
+```
+
+## Pass
+
+```js
+const test = require('ava');
+
+test('some test', async t => {
+	await t.throwsAsync(asyncThrowingFunction(), {message: 'Unicorn overload'});
+});
+```

index.js

@@ -41,6 +41,7 @@ module.exports = {
 				'ava/prefer-async-await': 'error',
 				'ava/prefer-power-assert': 'off',
 				'ava/prefer-t-regex': 'error',
+				'ava/prefer-t-throws': 'error',
 				'ava/test-title': 'error',
 				'ava/test-title-format': 'off',
 				'ava/use-t-well': 'error',

readme.md

@@ -56,6 +56,7 @@ Configure it in `package.json`.
 			"ava/prefer-async-await": "error",
 			"ava/prefer-power-assert": "off",
 			"ava/prefer-t-regex": "error",
+			"ava/prefer-t-throws": "error",
 			"ava/test-title": "error",
 			"ava/test-title-format": "off",
 			"ava/use-t": "error",
@@ -92,6 +93,7 @@ The rules will only activate in test files.
 - [prefer-async-await](docs/rules/prefer-async-await.md) - Prefer using async/await instead of returning a Promise.
 - [prefer-power-assert](docs/rules/prefer-power-assert.md) - Allow only use of the asserts that have no [power-assert](https://github.com/power-assert-js/power-assert) alternative.
 - [prefer-t-regex](docs/rules/prefer-t-regex.md) - Prefer using `t.regex()` to test regular expressions. *(fixable)*
+- [prefer-t-throws](docs/rules/prefer-t-throws.md) - Prefer using `t.throws()` or `t.throwsAsync()` over try/catch.
 - [test-title](docs/rules/test-title.md) - Ensure tests have a title.
 - [test-title-format](docs/rules/test-title-format.md) - Ensure test titles have a certain format.
 - [use-t](docs/rules/use-t.md) - Ensure test functions use `t` as their parameter.

rules/prefer-t-throws.js

@@ -0,0 +1,140 @@
+'use strict';
+
+const {visitIf} = require('enhance-visitors');
+const createAvaRule = require('../create-ava-rule');
+const util = require('../util');
+
+// This function checks if there is an AwaitExpression, which is not inside another function.
+//
+// TODO: find a simpler way to do this
+function hasAwaitExpression(nodes) {
+	if (!nodes) {
+		return false;
+	}
+
+	for (const node of nodes) {
+		if (!node) {
+			continue;
+		}
+
+		if (node.type === 'ExpressionStatement' && hasAwaitExpression([node.expression])) {
+			return true;
+		}
+
+		if (node.type === 'AwaitExpression') {
+			return true;
+		}
+
+		if (node.expressions && hasAwaitExpression(node.expressions)) {
+			return true;
+		}
+
+		if (node.type === 'BlockStatement' && hasAwaitExpression(node.body)) {
+			return true;
+		}
+
+		if (node.type === 'MemberExpression' && hasAwaitExpression([node.object, node.property])) {
+			return true;
+		}
+
+		if ((node.type === 'CallExpression' || node.type === 'NewExpression')
+				&& hasAwaitExpression([...node.arguments, node.callee])) {
+			return true;
+		}
+
+		if (node.left && node.right && hasAwaitExpression([node.left, node.right])) {
+			return true;
+		}
+
+		if (node.type === 'SequenceExpression' && hasAwaitExpression(node.expressions)) {
+			return true;
+		}
+
+		if (node.type === 'VariableDeclaration'
+				&& hasAwaitExpression(node.declarations.map(declaration => declaration.init))) {
+			return true;
+		}
+
+		if (node.type === 'ThrowStatement' && hasAwaitExpression([node.argument])) {
+			return true;
+		}
+
+		if (node.type === 'IfStatement' && hasAwaitExpression([node.test, node.consequent, node.alternate])) {
+			return true;
+		}
+
+		if (node.type === 'SwitchStatement'
+				// eslint-disable-next-line unicorn/prefer-spread
+				&& hasAwaitExpression([node.discriminant, ...node.cases.flatMap(caseNode => [caseNode.test].concat(caseNode.consequent))])) {
+			return true;
+		}
+
+		if (node.type.endsWith('WhileStatement') && hasAwaitExpression([node.test, node.body])) {
+			return true;
+		}
+
+		if (node.type === 'ForStatement' && hasAwaitExpression([node.init, node.test, node.update, node.body])) {
+			return true;
+		}
+
+		if (node.type === 'ForInStatement' && hasAwaitExpression([node.right, node.body])) {
+			return true;
+		}
+
+		if (node.type === 'ForOfStatement' && (node.await || hasAwaitExpression([node.right, node.body]))) {
+			return true;
+		}
+
+		if (node.type === 'WithStatement' && hasAwaitExpression([node.object, node.body])) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+const create = context => {
+	const ava = createAvaRule();
+
+	return ava.merge({
+		TryStatement: visitIf([
+			ava.isInTestFile,
+			ava.isInTestNode,
+		])(node => {
+			const nodes = node.block.body;
+			if (nodes.length < 2) {
+				return;
+			}
+
+			const tFailIndex = [...nodes].reverse().findIndex(node => node.type === 'ExpressionStatement'
+				&& node.expression.type === 'CallExpression'
+				&& node.expression.callee.object
+				&& node.expression.callee.object.name === 't'
+				&& node.expression.callee.property
+				&& node.expression.callee.property.name === 'fail');
+
+			// Return if there is no t.fail() or if it's the first node
+			if (tFailIndex === -1 || tFailIndex === nodes.length - 1) {
+				return;
+			}
+
+			const beforeNodes = nodes.slice(0, nodes.length - 1 - tFailIndex);
+
+			context.report({
+				node,
+				message: `Prefer using the \`t.throws${hasAwaitExpression(beforeNodes) ? 'Async' : ''}()\` assertion.`,
+			});
+		}),
+	});
+};
+
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			url: util.getDocsUrl(__filename),
+		},
+		schema: [],
+	},
+};

test/prefer-t-throws.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const test = require('ava');
+const avaRuleTester = require('eslint-ava-rule-tester');
+const rule = require('../rules/prefer-t-throws');
+
+const ruleTester = avaRuleTester(test, {
+	parserOptions: {
+		ecmaVersion: 'latest',
+	},
+});
+
+const header = 'const test = require(\'ava\');\n';
+
+ruleTester.run('prefer-t-throws', rule, {
+	valid: [
+		`${header}test(async t => { const error = await t.throwsAsync(promise); t.is(error, 'error'); });`,
+		`${header}test(t => { const error = t.throws(fn()); t.is(error, 'error'); });`,
+		`${header}test(async t => { try { t.fail(); unicorn(); } catch (error) { t.is(error, 'error'); } });`,
+		`${header}test(async t => { try { await promise; } catch (error) { t.is(error, 'error'); } });`,
+	],
+	invalid: [
+		{
+			code: `${header}test(async t => { try { async function unicorn() { throw await Promise.resolve('error') }; unicorn(); t.fail(); } catch (error) { t.is(error, 'error'); } });`,
+			errors: [{message: 'Prefer using the `t.throws()` assertion.'}],
+		},
+		{
+			code: `${header}test(async t => { try { await Promise.reject('error'); t.fail(); } catch (error) { t.is(error, 'error'); } });`,
+			errors: [{message: 'Prefer using the `t.throwsAsync()` assertion.'}],
+		},
+		{
+			code: `${header}test(async t => { try { if (await promise); t.fail(); } catch (error) { t.is(error, 'error'); } });`,
+			errors: [{message: 'Prefer using the `t.throwsAsync()` assertion.'}],
+		},
+		{
+			code: `${header}test(async t => { try { (await 1) > 2; t.fail(); } catch (error) { t.is(error, 'error'); } });`,
+			errors: [{message: 'Prefer using the `t.throwsAsync()` assertion.'}],
+		},
+		{
+			code: `${header}test(async t => { try { (await getArray())[0]; t.fail(); } catch (error) { t.is(error, 'error'); } });`,
+			errors: [{message: 'Prefer using the `t.throwsAsync()` assertion.'}],
+		},
+		{
+			code: `${header}test(async t => { try { getArraySync(await 20)[0]; t.fail(); } catch (error) { t.is(error, 'error'); } });`,
+			errors: [{message: 'Prefer using the `t.throwsAsync()` assertion.'}],
+		},
+		{
+			code: `${header}test(async t => { try { getArraySync()[await 0]; t.fail(); } catch (error) { t.is(error, 'error'); } });`,
+			errors: [{message: 'Prefer using the `t.throwsAsync()` assertion.'}],
+		},
+		{
+			code: `${header}test(async t => { try { new (await cl())(1); t.fail(); } catch (error) { t.is(error, 'error'); } });`,
+			errors: [{message: 'Prefer using the `t.throwsAsync()` assertion.'}],
+		},
+		{
+			code: `${header}test(async t => { try { if (false) { await promise; }; t.fail(); } catch (error) { t.is(error, 'error'); } });`,
+			errors: [{message: 'Prefer using the `t.throwsAsync()` assertion.'}],
+		},
+		{
+			code: `${header}test(t => { try { undefined(); t.fail(); } catch (error) { t.ok(error instanceof TypeError); } });`,
+			errors: [{message: 'Prefer using the `t.throws()` assertion.'}],
+		},
+		{
+			code: `${header}test(async t => { try { undefined(); t.fail(); } catch (error) { t.ok(error instanceof TypeError); } });`,
+			errors: [{message: 'Prefer using the `t.throws()` assertion.'}],
+		},
+	],
+});