no-unknown-modifiers: Forbid .always without after/afterEach

Fixes #139

Author: sindresorhus

docs/rules/no-unknown-modifiers.md

@@ -20,11 +20,17 @@ import test from 'ava';
 test.onlu(t => {}); // ❌
 test.only(t => {}); // ✅
 
-test.seril(t => {}); // ❌
+test.seril(t => {});  // ❌
 test.serial(t => {}); // ✅
 
 test.beforeeach(t => {}); // ❌
 test.beforeEach(t => {}); // ✅
 
 test.unknown(t => {}); // ❌
+
+test.always(t => {});       // ❌ `.always` requires `after` or `afterEach`
+test.after.always(t => {}); // ✅
+
+test.before.always(t => {});    // ❌ `.always` requires `after` or `afterEach`
+test.afterEach.always(t => {}); // ✅
 ```

rules/no-unknown-modifiers.js

@@ -4,8 +4,10 @@ import createAvaRule from '../create-ava-rule.js';
 
 const MESSAGE_ID = 'no-unknown-modifiers';
 const MESSAGE_ID_SUGGESTION = 'no-unknown-modifiers-suggestion';
+const MESSAGE_ID_ALWAYS = 'always-without-after';
+const MESSAGE_ID_ALWAYS_SUGGESTION = 'always-without-after-suggestion';
 
-const modifiers = new Set([
+const knownModifiers = new Set([
 	'after',
 	'afterEach',
 	'always',
@@ -20,9 +22,6 @@ const modifiers = new Set([
 	'macro',
 ]);
 
-const unknownModifiers = node => util.getTestModifiers(node)
-	.filter(modifier => !modifiers.has(modifier.name));
-
 const create = context => {
 	const ava = createAvaRule();
 
@@ -31,16 +30,37 @@ const create = context => {
 			ava.isInTestFile,
 			ava.isTestNode,
 		])(node => {
-			for (const modifier of unknownModifiers(node)) {
+			const testModifiers = util.getTestModifiers(node);
+
+			for (const modifier of testModifiers) {
+				if (!knownModifiers.has(modifier.name)) {
+					context.report({
+						node: modifier,
+						messageId: MESSAGE_ID,
+						data: {name: modifier.name},
+						suggest: [{
+							messageId: MESSAGE_ID_SUGGESTION,
+							data: {name: modifier.name},
+							fix: fixer => fixer.replaceTextRange(...util.removeTestModifier({
+								modifier: modifier.name,
+								node,
+								context,
+							})),
+						}],
+					});
+				}
+			}
+
+			const alwaysModifier = testModifiers.find(modifier => modifier.name === 'always');
+
+			if (alwaysModifier && !testModifiers.some(modifier => modifier.name === 'after' || modifier.name === 'afterEach')) {
 				context.report({
-					node: modifier,
-					messageId: MESSAGE_ID,
-					data: {name: modifier.name},
+					node: alwaysModifier,
+					messageId: MESSAGE_ID_ALWAYS,
 					suggest: [{
-						messageId: MESSAGE_ID_SUGGESTION,
-						data: {name: modifier.name},
+						messageId: MESSAGE_ID_ALWAYS_SUGGESTION,
 						fix: fixer => fixer.replaceTextRange(...util.removeTestModifier({
-							modifier: modifier.name,
+							modifier: 'always',
 							node,
 							context,
 						})),
@@ -65,6 +85,8 @@ export default {
 		messages: {
 			[MESSAGE_ID]: 'Unknown test modifier `.{{name}}`.',
 			[MESSAGE_ID_SUGGESTION]: 'Remove the `.{{name}}` modifier.',
+			[MESSAGE_ID_ALWAYS]: 'The `.always` modifier can only be used with `after` and `afterEach` hooks.',
+			[MESSAGE_ID_ALWAYS_SUGGESTION]: 'Remove the `.always` modifier.',
 		},
 	},
 };

test/no-unknown-modifiers.js

@@ -28,6 +28,7 @@ ruleTester.run('no-unknown-modifiers', rule, {
 		`${header}test.todo(t => {});`,
 		`${header}test.after.always(t => {});`,
 		`${header}test.afterEach.always(t => {});`,
+		`${header}test.after.always.skip(t => {});`,
 		`${header}test.failing(t => {});`,
 		`${header}test.macro(t => {});`,
 		// Shouldn't be triggered since it's not a test file
@@ -120,5 +121,64 @@ ruleTester.run('no-unknown-modifiers', rule, {
 				}],
 			}],
 		},
+		{
+			code: `${header}test.always(t => {});`,
+			errors: [{
+				messageId: 'always-without-after',
+				suggestions: [{
+					messageId: 'always-without-after-suggestion',
+					output: `${header}test(t => {});`,
+				}],
+			}],
+		},
+		{
+			code: `${header}test.before.always(t => {});`,
+			errors: [{
+				messageId: 'always-without-after',
+				suggestions: [{
+					messageId: 'always-without-after-suggestion',
+					output: `${header}test.before(t => {});`,
+				}],
+			}],
+		},
+		{
+			code: `${header}test.beforeEach.always(t => {});`,
+			errors: [{
+				messageId: 'always-without-after',
+				suggestions: [{
+					messageId: 'always-without-after-suggestion',
+					output: `${header}test.beforeEach(t => {});`,
+				}],
+			}],
+		},
+		{
+			code: `${header}test.serial.always(t => {});`,
+			errors: [{
+				messageId: 'always-without-after',
+				suggestions: [{
+					messageId: 'always-without-after-suggestion',
+					output: `${header}test.serial(t => {});`,
+				}],
+			}],
+		},
+		{
+			code: `${header}test.foo.always(t => {});`,
+			errors: [
+				{
+					messageId: 'no-unknown-modifiers',
+					suggestions: [{
+						messageId: 'no-unknown-modifiers-suggestion',
+						output: `${header}test.always(t => {});`,
+					}],
+				},
+				{
+					messageId: 'always-without-after',
+					suggestions: [{
+						messageId: 'always-without-after-suggestion',
+						output: `${header}test.foo(t => {});`,
+					}],
+				},
+			],
+		},
 	],
 });