Add no-useless-t-pass rule

Fixes #155

Author: sindresorhus

docs/rules/no-useless-t-pass.md

@@ -0,0 +1,33 @@
+# ava/no-useless-t-pass
+
+📝 Disallow useless `t.pass()`.
+
+💼 This rule is enabled in the ✅ `recommended` [config](https://github.com/avajs/eslint-plugin-ava#recommended-config).
+
+<!-- end auto-generated rule header -->
+
+`t.pass()` only increments the assertion counter. Without `t.plan()`, this counter is never checked, making `t.pass()` a no-op that gives a false sense of testing.
+
+If the intent is to verify code doesn't throw, use `t.notThrows()` or `t.notThrowsAsync()` instead.
+
+## Examples
+
+```js
+import test from 'ava';
+
+// ❌
+test('main', t => {
+	t.pass();
+});
+
+// ✅
+test('main', t => {
+	t.plan(1);
+	t.pass();
+});
+
+// ✅
+test('main', t => {
+	t.notThrows(() => foo());
+});
+```

index.js

@@ -21,6 +21,7 @@ import noSkipTest from './rules/no-skip-test.js';
 import noTodoImplementation from './rules/no-todo-implementation.js';
 import noTodoTest from './rules/no-todo-test.js';
 import noUnknownModifiers from './rules/no-unknown-modifiers.js';
+import noUselessTPass from './rules/no-useless-t-pass.js';
 import preferAsyncAwait from './rules/prefer-async-await.js';
 import preferPowerAssert from './rules/prefer-power-assert.js';
 import preferTRegex from './rules/prefer-t-regex.js';
@@ -57,6 +58,7 @@ const rules = {
 	'no-todo-implementation': noTodoImplementation,
 	'no-todo-test': noTodoTest,
 	'no-unknown-modifiers': noUnknownModifiers,
+	'no-useless-t-pass': noUselessTPass,
 	'prefer-async-await': preferAsyncAwait,
 	'prefer-power-assert': preferPowerAssert,
 	'prefer-t-regex': preferTRegex,
@@ -93,6 +95,7 @@ const recommendedRules = {
 	'ava/no-todo-implementation': 'error',
 	'ava/no-todo-test': 'warn',
 	'ava/no-unknown-modifiers': 'error',
+	'ava/no-useless-t-pass': 'error',
 	'ava/prefer-async-await': 'error',
 	'ava/prefer-power-assert': 'off',
 	'ava/prefer-t-regex': 'error',

readme.md

@@ -72,6 +72,7 @@ The rules will only activate in test files.
 | [no-todo-implementation](docs/rules/no-todo-implementation.md)       | Disallow giving `test.todo()` an implementation function.                                                      | ✅  |    |    |    | 💡 |
 | [no-todo-test](docs/rules/no-todo-test.md)                           | Disallow `test.todo()`.                                                                                        |    | ✅  |    |    | 💡 |
 | [no-unknown-modifiers](docs/rules/no-unknown-modifiers.md)           | Disallow unknown test modifiers.                                                                               | ✅  |    |    |    | 💡 |
+| [no-useless-t-pass](docs/rules/no-useless-t-pass.md)                 | Disallow useless `t.pass()`.                                                                                   | ✅  |    |    |    |    |
 | [prefer-async-await](docs/rules/prefer-async-await.md)               | Prefer async/await over returning a Promise.                                                                   | ✅  |    |    |    |    |
 | [prefer-power-assert](docs/rules/prefer-power-assert.md)             | Enforce using only assertions compatible with [power-assert](https://github.com/power-assert-js/power-assert). |    |    | ✅  |    |    |
 | [prefer-t-regex](docs/rules/prefer-t-regex.md)                       | Prefer `t.regex()` over `RegExp#test()` and `String#match()`.                                                  | ✅  |    |    | 🔧 |    |

rules/no-useless-t-pass.js

@@ -0,0 +1,69 @@
+import {visitIf} from 'enhance-visitors';
+import util from '../util.js';
+import createAvaRule from '../create-ava-rule.js';
+
+const MESSAGE_ID = 'no-useless-t-pass';
+
+const create = context => {
+	const ava = createAvaRule();
+	let hasPlan = false;
+	let passNodes = [];
+
+	return ava.merge({
+		CallExpression: visitIf([
+			ava.isInTestFile,
+			ava.isInTestNode,
+		])(node => {
+			const {callee} = node;
+
+			if (callee.type !== 'MemberExpression') {
+				return;
+			}
+
+			if (
+				!callee.property
+				|| !util.isTestObject(util.getNameOfRootNodeObject(callee))
+				|| util.isPropertyUnderContext(callee)
+			) {
+				return;
+			}
+
+			const firstNonSkipMember = util.getMembers(callee).find(name => name !== 'skip');
+
+			if (firstNonSkipMember === 'plan') {
+				hasPlan = true;
+			} else if (firstNonSkipMember === 'pass') {
+				passNodes.push(node);
+			}
+		}),
+		'CallExpression:exit': visitIf([ava.isTestNode])(() => {
+			if (!hasPlan) {
+				for (const node of passNodes) {
+					context.report({
+						node,
+						messageId: MESSAGE_ID,
+					});
+				}
+			}
+
+			hasPlan = false;
+			passNodes = [];
+		}),
+	});
+};
+
+export default {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow useless `t.pass()`.',
+			recommended: true,
+			url: util.getDocsUrl(import.meta.filename),
+		},
+		schema: [],
+		messages: {
+			[MESSAGE_ID]: '`t.pass()` is useless without `t.plan()`.',
+		},
+	},
+};

test/no-useless-t-pass.js

@@ -0,0 +1,117 @@
+import test from 'ava';
+import AvaRuleTester from 'eslint-ava-rule-tester';
+import rule from '../rules/no-useless-t-pass.js';
+
+const ruleTester = new AvaRuleTester(test, {
+	languageOptions: {
+		ecmaVersion: 'latest',
+	},
+});
+
+const header = 'const test = require(\'ava\');\n';
+
+const error = [{messageId: 'no-useless-t-pass'}];
+
+ruleTester.run('no-useless-t-pass', rule, {
+	valid: [
+		// Useful: t.pass() with t.plan()
+		`${header} test(t => { t.plan(1); t.pass(); });`,
+		// Multiple assertions including t.pass() with t.plan()
+		`${header} test(t => { t.plan(2); t.pass(); t.is(1, 1); });`,
+		// No t.pass() at all
+		`${header} test(t => { t.is(1, 1); });`,
+		// Not a test file
+		'test(t => { t.pass(); });',
+		// Reversed order: t.pass() before t.plan()
+		`${header} test(t => { t.pass(); t.plan(1); });`,
+		// Context usage is not an assertion
+		`${header} test(t => { t.context.pass(); });`,
+		// Test modifiers with t.plan()
+		`${header} test.serial(t => { t.plan(1); t.pass(); });`,
+		`${header} test.failing(t => { t.plan(1); t.pass(); });`,
+		// Skipped pass with t.plan()
+		`${header} test(t => { t.plan(1); t.skip.pass(); });`,
+		// Not a test object (foo.t.pass)
+		`${header} test(t => { ${'foo.t.pass(); '.repeat(2)}});`,
+		// ESM import
+		'import test from \'ava\';\n test(t => { t.plan(1); t.pass(); });',
+	],
+	invalid: [
+		{
+			code: `${header} test(t => { t.pass(); });`,
+			errors: error,
+		},
+		{
+			code: `${header} test(t => { t.pass('message'); });`,
+			errors: error,
+		},
+		{
+			code: `${header} test(t => { t.pass(); t.pass(); });`,
+			errors: [...error, ...error],
+		},
+		{
+			code: `${header} test(t => { t.pass(); t.is(1, 1); });`,
+			errors: error,
+		},
+		{
+			code: `${header} test(t => { t.skip.pass(); });`,
+			errors: error,
+		},
+		// Two tests: one valid (has t.plan), one invalid (no t.plan) - ensures state resets
+		{
+			code: `${header} test(t => { t.plan(1); t.pass(); }); test(t => { t.pass(); });`,
+			errors: error,
+		},
+		// Alternative test object name
+		{
+			code: `${header} test(t => { tt.pass(); });`,
+			errors: error,
+		},
+		// Hooks: t.plan() is not available, so t.pass() is always useless
+		{
+			code: `${header} test.before(t => { t.pass(); });`,
+			errors: error,
+		},
+		{
+			code: `${header} test.beforeEach(t => { t.pass(); });`,
+			errors: error,
+		},
+		{
+			code: `${header} test.after(t => { t.pass(); });`,
+			errors: error,
+		},
+		{
+			code: `${header} test.afterEach(t => { t.pass(); });`,
+			errors: error,
+		},
+		// Test modifiers without t.plan()
+		{
+			code: `${header} test.serial(t => { t.pass(); });`,
+			errors: error,
+		},
+		{
+			code: `${header} test.failing(t => { t.pass(); });`,
+			errors: error,
+		},
+		// State reset: invalid then valid
+		{
+			code: `${header} test(t => { t.pass(); }); test(t => { t.plan(1); t.pass(); });`,
+			errors: error,
+		},
+		// Nested callback with t.pass()
+		{
+			code: `${header} test(t => { setTimeout(() => { t.pass(); }, 0); });`,
+			errors: error,
+		},
+		// Async test
+		{
+			code: `${header} test(async t => { t.pass(); });`,
+			errors: error,
+		},
+		// ESM import
+		{
+			code: 'import test from \'ava\';\n test(t => { t.pass(); });',
+			errors: error,
+		},
+	],
+});