Add no-useless-not rule

docs/rules/no-useless-not.md

@@ -0,0 +1,25 @@
+# Disallow usage of `not` matchers when a specific matcher exists (`no-useless-not`)
+
+Several Playwright matchers are complimentary such as `toBeVisible`/`toBeHidden`
+and `toBeEnabled`/`toBeDisabled`. While the `not` variants of each of these
+matchers can be used, it's preferred to use the complimentary matcher instead.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```javascript
+expect(locator).not.toBeVisible();
+expect(locator).not.toBeHidden();
+expect(locator).not.toBeEnabled();
+expect(locator).not.toBeDisabled();
+```
+
+Example of **correct** code for this rule:
+
+```javascript
+expect(locator).toBeHidden();
+expect(locator).toBeVisible();
+expect(locator).toBeDisabled();
+expect(locator).toBeEnabled();
+```

src/index.ts

@@ -8,6 +8,7 @@ import noWaitForTimeout from './rules/no-wait-for-timeout';
 import noForceOption from './rules/no-force-option';
 import maxNestedDescribe from './rules/max-nested-describe';
 import noConditionalInTest from './rules/no-conditional-in-test';
+import noUselessNot from './rules/no-useless-not';
 
 export = {
   configs: {
@@ -28,6 +29,7 @@ export = {
         'playwright/no-force-option': 'warn',
         'playwright/max-nested-describe': 'warn',
         'playwright/no-conditional-in-test': 'warn',
+        'playwright/no-useless-not': 'warn',
       },
     },
     'jest-playwright': {
@@ -74,5 +76,6 @@ export = {
     'no-force-option': noForceOption,
     'max-nested-describe': maxNestedDescribe,
     'no-conditional-in-test': noConditionalInTest,
+    'no-useless-not': noUselessNot,
   },
 };

src/rules/no-useless-not.ts

@@ -0,0 +1,58 @@
+import { Rule } from 'eslint';
+import { getNodeName, isIdentifier } from '../utils/ast';
+
+const matcherMap = {
+  toBeVisible: 'toBeHidden',
+  toBeHidden: 'toBeVisible',
+  toBeEnabled: 'toBeDisabled',
+  toBeDisabled: 'toBeEnabled',
+};
+
+export default {
+  create(context) {
+    return {
+      MemberExpression(node) {
+        if (
+          node.object.type === 'MemberExpression' &&
+          node.object.object.type === 'CallExpression' &&
+          isIdentifier(node.object.object.callee, 'expect') &&
+          isIdentifier(node.object.property, 'not')
+        ) {
+          const matcher = getNodeName(node.property) as
+            | keyof typeof matcherMap
+            | undefined;
+
+          if (matcher && matcher in matcherMap) {
+            const range = node.object.property.range!;
+
+            context.report({
+              fix: (fixer) => [
+                fixer.removeRange([range[0], range[1] + 1]),
+                fixer.replaceText(node.property, matcherMap[matcher]),
+              ],
+              messageId: 'noUselessNot',
+              node: node,
+              data: {
+                old: matcher,
+                new: matcherMap[matcher],
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: `Disallow usage of 'not' matchers when a more specific matcher exists`,
+      recommended: true,
+      url: 'https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-useless-not.md',
+    },
+    fixable: 'code',
+    messages: {
+      noUselessNot: 'Unexpected usage of not.{{old}}(). Use {{new}}() instead.',
+    },
+    type: 'problem',
+  },
+} as Rule.RuleModule;

test/spec/no-useless-not.spec.ts

@@ -0,0 +1,42 @@
+import { runRuleTester } from '../utils/rule-tester';
+import rule from '../../src/rules/no-useless-not';
+
+const invalid = (oldMatcher: string, newMatcher: string) => ({
+  code: `expect(locator).not.${oldMatcher}()`,
+  output: `expect(locator).${newMatcher}()`,
+  errors: [
+    {
+      messageId: 'noUselessNot',
+      data: { old: oldMatcher, new: newMatcher },
+    },
+  ],
+});
+
+runRuleTester('no-useless-not', rule, {
+  invalid: [
+    invalid('toBeVisible', 'toBeHidden'),
+    invalid('toBeHidden', 'toBeVisible'),
+    invalid('toBeEnabled', 'toBeDisabled'),
+    invalid('toBeDisabled', 'toBeEnabled'),
+    // Incomplete call expression
+    {
+      code: 'expect(locator).not.toBeHidden',
+      output: 'expect(locator).toBeVisible',
+      errors: [{ messageId: 'noUselessNot' }],
+    },
+  ],
+  valid: [
+    'expect(locator).toBeVisible()',
+    'expect(locator).toBeHidden()',
+    'expect(locator).toBeEnabled()',
+    'expect(locator).toBeDisabled()',
+    // Incomplete call expression
+    'expect(locator).toBeVisible',
+    'expect(locator).toBeEnabled',
+    // Doesn't impact non-complimentary matchers
+    "expect(locator).not.toHaveText('foo')",
+    'expect(locator).not.toBeChecked()',
+    'expect(locator).not.toBeChecked({ checked: false })',
+    'expect(locator).not.toBeFocused()',
+  ],
+});