Add no-nested-assertions rule

Fixes #150

Author: sindresorhus

docs/rules/no-nested-assertions.md

@@ -0,0 +1,40 @@
+# ava/no-nested-assertions
+
+📝 Disallow nested assertions.
+
+💼 This rule is enabled in the ✅ `recommended` [config](https://github.com/avajs/eslint-plugin-ava#recommended-config).
+
+<!-- end auto-generated rule header -->
+
+Disallow nesting assertions, such as using an assertion as an argument to another assertion or putting assertions inside a `t.throws()` callback.
+
+Nested assertions are confusing and error-prone. For example, assertions inside `t.throws()` will have their failures caught by `throws`, and assertions used as arguments make the code harder to read.
+
+## Examples
+
+```js
+import test from 'ava';
+
+// ❌
+test('main', t => {
+	t.is(t.throws(() => foo()).message, 'expected');
+});
+
+// ✅
+test('main', t => {
+	const error = t.throws(() => foo());
+	t.is(error.message, 'expected');
+});
+
+// ❌
+test('main', t => {
+	t.throws(() => {
+		t.is(1, 2);
+	});
+});
+
+// ✅
+test('main', t => {
+	t.throws(() => foo(), {message: 'expected'});
+});
+```

index.js

@@ -13,6 +13,7 @@ import noIgnoredTestFiles from './rules/no-ignored-test-files.js';
 import noImportTestFiles from './rules/no-import-test-files.js';
 import noIncorrectDeepEqual from './rules/no-incorrect-deep-equal.js';
 import noInlineAssertions from './rules/no-inline-assertions.js';
+import noNestedAssertions from './rules/no-nested-assertions.js';
 import noNestedTests from './rules/no-nested-tests.js';
 import noOnlyTest from './rules/no-only-test.js';
 import noSkipAssert from './rules/no-skip-assert.js';
@@ -48,6 +49,7 @@ const rules = {
 	'no-import-test-files': noImportTestFiles,
 	'no-incorrect-deep-equal': noIncorrectDeepEqual,
 	'no-inline-assertions': noInlineAssertions,
+	'no-nested-assertions': noNestedAssertions,
 	'no-nested-tests': noNestedTests,
 	'no-only-test': noOnlyTest,
 	'no-skip-assert': noSkipAssert,
@@ -83,6 +85,7 @@ const recommendedRules = {
 	'ava/no-import-test-files': 'error',
 	'ava/no-incorrect-deep-equal': 'error',
 	'ava/no-inline-assertions': 'error',
+	'ava/no-nested-assertions': 'error',
 	'ava/no-nested-tests': 'error',
 	'ava/no-only-test': 'error',
 	'ava/no-skip-assert': 'error',

readme.md

@@ -64,6 +64,7 @@ The rules will only activate in test files.
 | [no-import-test-files](docs/rules/no-import-test-files.md)           | Disallow importing test files.                                                                                 | ✅  |    |    |    |    |
 | [no-incorrect-deep-equal](docs/rules/no-incorrect-deep-equal.md)     | Disallow using `deepEqual` with primitives.                                                                    | ✅  |    |    | 🔧 |    |
 | [no-inline-assertions](docs/rules/no-inline-assertions.md)           | Disallow inline assertions.                                                                                    | ✅  |    |    | 🔧 |    |
+| [no-nested-assertions](docs/rules/no-nested-assertions.md)           | Disallow nested assertions.                                                                                    | ✅  |    |    |    |    |
 | [no-nested-tests](docs/rules/no-nested-tests.md)                     | Disallow nested tests.                                                                                         | ✅  |    |    |    |    |
 | [no-only-test](docs/rules/no-only-test.md)                           | Disallow `test.only()`.                                                                                        | ✅  |    |    |    | 💡 |
 | [no-skip-assert](docs/rules/no-skip-assert.md)                       | Disallow skipping assertions.                                                                                  | ✅  |    |    |    | 💡 |

rules/no-nested-assertions.js

@@ -0,0 +1,61 @@
+import {visitIf} from 'enhance-visitors';
+import createAvaRule from '../create-ava-rule.js';
+import util from '../util.js';
+
+const MESSAGE_ID = 'no-nested-assertions';
+
+const create = context => {
+	const ava = createAvaRule();
+	const assertionCallStack = [];
+
+	return ava.merge({
+		CallExpression: visitIf([
+			ava.isInTestFile,
+			ava.isInTestNode,
+		])(node => {
+			if (node.callee.type !== 'MemberExpression') {
+				return;
+			}
+
+			const rootName = util.getNameOfRootNodeObject(node.callee);
+			if (!util.isTestObject(rootName)) {
+				return;
+			}
+
+			const methodName = util.getMembers(node.callee)[0];
+			if (!util.assertionMethods.has(methodName)) {
+				return;
+			}
+
+			if (assertionCallStack.length > 0) {
+				context.report({node, messageId: MESSAGE_ID});
+			}
+
+			// Don't track `t.try()`, its callback is designed to contain assertions
+			if (methodName !== 'try') {
+				assertionCallStack.push(node);
+			}
+		}),
+		'CallExpression:exit'(node) {
+			if (assertionCallStack.length > 0 && assertionCallStack.at(-1) === node) {
+				assertionCallStack.pop();
+			}
+		},
+	});
+};
+
+export default {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow nested assertions.',
+			recommended: true,
+			url: util.getDocsUrl(import.meta.filename),
+		},
+		schema: [],
+		messages: {
+			[MESSAGE_ID]: 'Assertions should not be nested.',
+		},
+	},
+};

test/no-nested-assertions.js

@@ -0,0 +1,94 @@
+import test from 'ava';
+import AvaRuleTester from 'eslint-ava-rule-tester';
+import rule from '../rules/no-nested-assertions.js';
+
+const ruleTester = new AvaRuleTester(test, {
+	languageOptions: {
+		ecmaVersion: 'latest',
+	},
+});
+
+const header = 'const test = require(\'ava\');\n';
+const error = {
+	messageId: 'no-nested-assertions',
+};
+
+ruleTester.run('no-nested-assertions', rule, {
+	assertionOptions: {
+		requireMessage: true,
+	},
+	valid: [
+		// Sequential assertions
+		header + 'test(t => { t.is(1, 1); t.true(true); });',
+		// Assertions in t.try() callback are fine
+		header + 'test(t => { t.try(tt => { tt.is(1, 1); }); });',
+		// Multiple assertions in t.try() callback are fine
+		header + 'test(t => { t.try(tt => { tt.is(1, 1); tt.true(true); }); });',
+		// Non-assertion methods
+		header + 'test(t => { t.plan(1); t.is(1, 1); });',
+		// Not a test object
+		header + 'test(t => { foo.is(t.is(1, 1)); });',
+		// Shouldn't be triggered since it's not a test file
+		'test(t => { t.is(t.throws(fn).message, "expected"); });',
+	],
+	invalid: [
+		// Assertion as argument to another assertion
+		{
+			code: header + 'test(t => { t.is(t.throws(fn).message, "expected"); });',
+			errors: [error],
+		},
+		{
+			code: header + 'test(t => { t.true(t.throws(fn).message); });',
+			errors: [error],
+		},
+		{
+			code: header + 'test(t => { t.deepEqual(t.throws(fn), expected); });',
+			errors: [error],
+		},
+		// Assertion inside t.throws() callback
+		{
+			code: header + 'test(t => { t.throws(() => { t.is(1, 2); }); });',
+			errors: [error],
+		},
+		// Assertion inside t.throwsAsync() callback
+		{
+			code: header + 'test(t => { t.throwsAsync(() => { t.true(false); }); });',
+			errors: [error],
+		},
+		// Assertion inside t.notThrows() callback
+		{
+			code: header + 'test(t => { t.notThrows(() => { t.pass(); }); });',
+			errors: [error],
+		},
+		// Assertion inside t.notThrowsAsync() callback
+		{
+			code: header + 'test(t => { t.notThrowsAsync(() => { t.true(true); }); });',
+			errors: [error],
+		},
+		// Multiple assertions inside t.throws() callback
+		{
+			code: header + 'test(t => { t.throws(() => { t.is(1, 2); t.true(false); }); });',
+			errors: [error, error],
+		},
+		// Deeply nested
+		{
+			code: header + 'test(t => { t.is(t.throws(() => { t.pass(); }).message, "x"); });',
+			errors: [error, error],
+		},
+		// With .skip modifier
+		{
+			code: header + 'test(t => { t.is(t.throws.skip(fn).message, "expected"); });',
+			errors: [error],
+		},
+		// Nesting within t.try() callback is still caught
+		{
+			code: header + 'test(t => { t.try(tt => { tt.is(tt.throws(fn).message, "expected"); }); });',
+			errors: [error],
+		},
+		// Alternative test object names
+		{
+			code: header + 'test(t => { tt.is(tt.throws(fn).message, "expected"); });',
+			errors: [error],
+		},
+	],
+});