Add new "noFocusedTest" rule (playwright-community#44)

* rule: add new noElementHandle rule

* chore: move end range to const

* fix: getRange method for non-awaiting statements

* test: add additional tests for the noElementHandle rule

* chore: improve noElementHandle rule

* docs: update the wording of noElementHandle rule

* rule: update message to match with other rule naming conventions

* rule: change noElementHandle to warn level

* rule: noElementHandle change fixable to suggestion

* test: add valid tests for noElementHandle rule

* rule: change type for noElementHandle to suggestion

* rule: update noElementHandle rule's message for suggestions

* rule: update noElementHandle with getRange method

* feat: add new noFocusedTest rule

* chore: remove unneeded function in test. change DS for isTestGroup function

* chore: remove valid function

Author: elaichenkov

README.md

@@ -143,3 +143,50 @@ await page.locator('button').evaluate(node => node.innerText);
 
 await page.locator('div').evaluateAll((divs, min) => divs.length >= min, 10);
 ```
+
+### `no-focused-test`
+
+Disallow usage of `.only()` annotation
+
+Examples of **incorrect** code for this rule:
+
+```js
+test.only('focus this test', async ({ page }) => {});
+
+test.describe.only('focus two tests', () => {
+  test('one', async ({ page }) => {});
+  test('two', async ({ page }) => {});
+});
+
+test.describe.parallel.only('focus two tests in parallel mode', () => {
+  test('one', async ({ page }) => {});
+  test('two', async ({ page }) => {});
+});
+
+test.describe.serial.only('focus two tests in serial mode', () => {
+  test('one', async ({ page }) => {});
+  test('two', async ({ page }) => {});
+});
+
+```
+
+Examples of **correct** code for this rule:
+
+```js
+test('this test', async ({ page }) => {});
+
+test.describe('two tests', () => {
+  test('one', async ({ page }) => {});
+  test('two', async ({ page }) => {});
+});
+
+test.describe.parallel('two tests in parallel mode', () => {
+  test('one', async ({ page }) => {});
+  test('two', async ({ page }) => {});
+});
+
+test.describe.serial('two tests in serial mode', () => {
+  test('one', async ({ page }) => {});
+  test('two', async ({ page }) => {});
+});
+```

lib/index.js

@@ -2,6 +2,7 @@ const missingPlaywrightAwait = require("./rules/missing-playwright-await");
 const noPagePause = require("./rules/no-page-pause");
 const noElementHandle = require("./rules/no-element-handle");
 const noEval = require("./rules/no-eval");
+const noFocusedTest = require("./rules/no-focused-test");
 
 module.exports = {
   configs: {
@@ -16,6 +17,7 @@ module.exports = {
         "playwright/no-page-pause": "warn",
         "playwright/no-element-handle": "warn",
         "playwright/no-eval": "warn",
+        "playwright/no-focused-test": "error",
       },
     },
     "jest-playwright": {
@@ -56,5 +58,6 @@ module.exports = {
     "no-page-pause": noPagePause,
     "no-element-handle": noElementHandle,
     "no-eval": noEval,
+    "no-focused-test": noFocusedTest,
   },
 };

lib/rules/no-focused-test.js

@@ -0,0 +1,49 @@
+const { isTestIdentifier, hasAnnotation } = require('../utils/ast');
+
+function isTestGroup(node) {
+  const testGroups = new Set(['describe', 'parallel', 'serial']);
+
+  return (
+    node.object &&
+    node.object.type === 'MemberExpression' &&
+    node.object.property.type === 'Identifier' &&
+    testGroups.has(node.object.property.name)
+  );
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  create(context) {
+    return {
+      MemberExpression(node) {
+        if ((isTestIdentifier(node) || isTestGroup(node)) && hasAnnotation(node, 'only')) {
+          context.report({
+            messageId: 'noFocusedTest',
+            suggest: [
+              {
+                messageId: 'removeFocusedTestAnnotation',
+                // - 1 to remove the `.only` annotation with dot notation
+                fix: (fixer) => fixer.removeRange([node.property.range[0] - 1, node.property.range[1]]),
+              },
+            ],
+            node,
+          });
+        }
+      },
+    };
+  },
+  meta: {
+    docs: {
+      category: 'Possible Errors',
+      description: 'Prevent usage of `.only()` focus test annotation',
+      recommended: true,
+      url: 'https://github.com/playwright-community/eslint-plugin-playwright#no-focused-test',
+    },
+    hasSuggestions: true,
+    messages: {
+      noFocusedTest: 'Unexpected use of .only() annotation.',
+      removeFocusedTestAnnotation: 'Remove .only() annotation',
+    },
+    type: 'problem',
+  },
+};

lib/utils/ast.js

@@ -16,7 +16,21 @@ function isCalleeProperty({ callee }, name) {
   );
 }
 
+function isTestIdentifier(node) {
+  return node.object && node.object.type === 'Identifier' && node.object.name === 'test';
+}
+
+function hasAnnotation(node, annotation) {
+  return (
+    node.property &&
+    node.property.type === 'Identifier' &&
+    node.property.name === annotation
+  );
+}
+
 module.exports = {
   isPageIdentifier,
   isCalleeProperty,
+  isTestIdentifier,
+  hasAnnotation,
 };

test/no-focused-test.spec.js

@@ -0,0 +1,52 @@
+const { RuleTester } = require('eslint');
+const rule = require('../lib/rules/no-focused-test');
+
+RuleTester.setDefaultConfig({
+  parserOptions: {
+    ecmaVersion: 2018,
+  },
+});
+
+const invalid = (code, output) => ({
+  code,
+  errors: [
+    {
+      messageId: 'noFocusedTest',
+      suggestions: [{ messageId: 'removeFocusedTestAnnotation', output }],
+    },
+  ],
+});
+
+new RuleTester().run('no-focused-test', rule, {
+  invalid: [
+    invalid(
+      'test.describe.only("skip this describe", () => {});',
+      'test.describe("skip this describe", () => {});'
+    ),
+
+    invalid(
+      'test.describe.parallel.only("skip this describe", () => {});',
+      'test.describe.parallel("skip this describe", () => {});'
+    ),
+
+    invalid(
+      'test.describe.serial.only("skip this describe", () => {});',
+      'test.describe.serial("skip this describe", () => {});'
+    ),
+
+    invalid(
+      'test.only("skip this test", async ({ page }) => {});',
+      'test("skip this test", async ({ page }) => {});'
+    ),
+  ],
+  valid: [
+    'test.describe("describe tests", () => {});',
+    'test.describe.skip("describe tests", () => {});',
+    'test("one", async ({ page }) => {});',
+    'test.fixme(isMobile, "Settings page does not work in mobile yet");',
+    'test.slow();',
+    'const only = true;',
+    'function only() { return null };',
+    'this.only();',
+  ],
+});