feat: Add prefer-to-have-count rule

README.md

@@ -105,6 +105,7 @@ command line option.\
 |     | 🔧  |     | [prefer-lowercase-title](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-lowercase-title.md)           | Enforce lowercase test names                                      |
 |     | 🔧  |     | [prefer-to-be](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-be.md)                               | Suggest using `toBe()`                                            |
 |     | 🔧  |     | [prefer-to-contain](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-contain.md)                     | Suggest using `toContain()`                                       |
+|     | 🔧  |     | [prefer-to-have-count](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-count.md)               | Suggest using `toHaveCount()`                                     |
 |     | 🔧  |     | [prefer-to-have-length](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-length.md)             | Suggest using `toHaveLength()`                                    |
 | ✔  | 🔧  |     | [prefer-web-first-assertions](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-web-first-assertions.md) | Suggest using web first assertions                                |
 |     |     |     | [require-top-level-describe](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-top-level-describe.md)   | Require test cases and hooks to be inside a `test.describe` block |

docs/rules/prefer-to-have-count.md

@@ -0,0 +1,23 @@
+# Suggest using `toHaveCount()` (`prefer-to-have-count`)
+
+In order to have a better failure message, `toHaveCount()` should be used upon
+asserting expectations on locators `count()` method.
+
+## Rule details
+
+This rule triggers a warning if `toBe()`, `toEqual()` or `toStrictEqual()` is
+used to assert locators `count()` method.
+
+The following patterns are considered warnings:
+
+```javascript
+expect(await files.count()).toBe(1);
+expect(await files.count()).toEqual(1);
+expect(await files.count()).toStrictEqual(1);
+```
+
+The following pattern is **not** a warning:
+
+```javascript
+await expect(files).toHaveCount(1);
+```

src/index.ts

@@ -20,6 +20,7 @@ import preferLowercaseTitle from './rules/prefer-lowercase-title';
 import preferStrictEqual from './rules/prefer-strict-equal';
 import preferToBe from './rules/prefer-to-be';
 import preferToContain from './rules/prefer-to-contain';
+import preferToHaveCount from './rules/prefer-to-have-count';
 import preferToHaveLength from './rules/prefer-to-have-length';
 import preferWebFirstAssertions from './rules/prefer-web-first-assertions';
 import requireSoftAssertions from './rules/require-soft-assertions';
@@ -113,6 +114,7 @@ export = {
     'prefer-strict-equal': preferStrictEqual,
     'prefer-to-be': preferToBe,
     'prefer-to-contain': preferToContain,
+    'prefer-to-have-count': preferToHaveCount,
     'prefer-to-have-length': preferToHaveLength,
     'prefer-web-first-assertions': preferWebFirstAssertions,
     'require-soft-assertions': requireSoftAssertions,

src/rules/prefer-to-have-count.ts

@@ -0,0 +1,65 @@
+import { Rule } from 'eslint';
+import { replaceAccessorFixer } from '../utils/fixer';
+import { parseExpectCall } from '../utils/parseExpectCall';
+
+const matchers = new Set(['toBe', 'toEqual', 'toStrictEqual']);
+
+export default {
+  create(context) {
+    return {
+      CallExpression(node) {
+        const expectCall = parseExpectCall(node);
+        if (!expectCall || !matchers.has(expectCall.matcherName)) {
+          return;
+        }
+
+        const [argument] = node.arguments;
+        if (
+          argument.type !== 'AwaitExpression' ||
+          argument.argument.type !== 'CallExpression' ||
+          argument.argument.callee.type !== 'MemberExpression'
+        ) {
+          return;
+        }
+
+        const callee = argument.argument.callee;
+        context.report({
+          fix(fixer) {
+            return [
+              // remove the "await" expression
+              fixer.removeRange([
+                argument.range![0],
+                argument.range![0] + 'await'.length + 1,
+              ]),
+              // remove the "count()" method accessor
+              fixer.removeRange([
+                callee.property.range![0] - 1,
+                argument.argument.range![1],
+              ]),
+              // replace the current matcher with "toHaveCount"
+              replaceAccessorFixer(fixer, expectCall.matcher, 'toHaveCount'),
+              // insert "await" to before "expect()"
+              fixer.insertTextBefore(node, 'await '),
+            ];
+          },
+          messageId: 'useToHaveCount',
+          node: expectCall.matcher,
+        });
+      },
+    };
+  },
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Suggest using `toHaveCount()`',
+      recommended: false,
+      url: 'https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-count.md',
+    },
+    fixable: 'code',
+    messages: {
+      useToHaveCount: 'Use toHaveCount() instead',
+    },
+    schema: [],
+    type: 'suggestion',
+  },
+} as Rule.RuleModule;

test/spec/prefer-to-have-count.spec.ts

@@ -0,0 +1,66 @@
+import rule from '../../src/rules/prefer-to-have-count';
+import { runRuleTester } from '../utils/rule-tester';
+
+runRuleTester('prefer-to-have-count', rule, {
+  invalid: [
+    {
+      code: 'expect(await files.count()).toBe(1)',
+      errors: [
+        { column: 29, endColumn: 33, line: 1, messageId: 'useToHaveCount' },
+      ],
+      output: 'await expect(files).toHaveCount(1)',
+    },
+    {
+      code: 'expect(await files.count()).not.toBe(1)',
+      errors: [
+        { column: 33, endColumn: 37, line: 1, messageId: 'useToHaveCount' },
+      ],
+      output: 'await expect(files).not.toHaveCount(1)',
+    },
+    {
+      code: 'expect.soft(await files["count"]()).not.toBe(1)',
+      errors: [
+        { column: 41, endColumn: 45, line: 1, messageId: 'useToHaveCount' },
+      ],
+      output: 'await expect.soft(files).not.toHaveCount(1)',
+    },
+    {
+      code: 'expect(await files["count"]()).not["toBe"](1)',
+      errors: [
+        { column: 36, endColumn: 42, line: 1, messageId: 'useToHaveCount' },
+      ],
+      output: 'await expect(files).not["toHaveCount"](1)',
+    },
+    {
+      code: 'expect(await files.count())[`toEqual`](1)',
+      errors: [
+        { column: 29, endColumn: 38, line: 1, messageId: 'useToHaveCount' },
+      ],
+      output: 'await expect(files)[`toHaveCount`](1)',
+    },
+    {
+      code: 'expect(await files.count()).toStrictEqual(1)',
+      errors: [
+        { column: 29, endColumn: 42, line: 1, messageId: 'useToHaveCount' },
+      ],
+      output: 'await expect(files).toHaveCount(1)',
+    },
+    {
+      code: 'expect(await files.count()).not.toStrictEqual(1)',
+      errors: [
+        { column: 33, endColumn: 46, line: 1, messageId: 'useToHaveCount' },
+      ],
+      output: 'await expect(files).not.toHaveCount(1)',
+    },
+  ],
+  valid: [
+    'await expect(files).toHaveCount(1)',
+    "expect(files.name).toBe('file')",
+    "expect(files['name']).toBe('file')",
+    "expect(files[`name`]).toBe('file')",
+    'expect(result).toBe(true)',
+    `expect(user.getUserName(5)).not.toEqual('Paul')`,
+    `expect(user.getUserName(5)).not.toEqual('Paul')`,
+    'expect(a)',
+  ],
+});