eslint-plugin-playwright 0.9.0 → 0.10.0

package/README.md

@@ -50,20 +50,20 @@ Identify false positives when async Playwright APIs are not properly awaited.
 Example of **incorrect** code for this rule:
 
 ```js
-expect(page).toMatchText("text");
+expect(page).toMatchText('text');
 
-test.step("clicks the button", async () => {
-  await page.click("button");
+test.step('clicks the button', async () => {
+  await page.click('button');
 });
 ```
 
 Example of **correct** code for this rule:
 
 ```js
-await expect(page).toMatchText("text");
+await expect(page).toMatchText('text');
 
-await test.step("clicks the button", async () => {
-  await page.click("button");
+await test.step('clicks the button', async () => {
+  await page.click('button');
 });
 ```
 
@@ -79,6 +79,7 @@ The rule accepts a non-required option which can be used to specify custom match
   ]
 }
 ```
+
 ### `no-page-pause`
 
 Prevent usage of `page.pause()`.
@@ -127,19 +128,23 @@ Disallow usage of `page.$eval` and `page.$$eval`.
 Examples of **incorrect** code for this rule:
 
 ```js
-const searchValue = await page.$eval('#search', el => el.value);
+const searchValue = await page.$eval('#search', (el) => el.value);
 
-const divCounts = await page.$$eval('div', (divs, min) => divs.length >= min, 10);
+const divCounts = await page.$$eval(
+  'div',
+  (divs, min) => divs.length >= min,
+  10
+);
 
-await page.$eval('#search', el => el.value);
+await page.$eval('#search', (el) => el.value);
 
-await page.$$eval('#search', el => el.value);
+await page.$$eval('#search', (el) => el.value);
 ```
 
 Example of **correct** code for this rule:
 
 ```js
-await page.locator('button').evaluate(node => node.innerText);
+await page.locator('button').evaluate((node) => node.innerText);
 
 await page.locator('div').evaluateAll((divs, min) => divs.length >= min, 10);
 ```
@@ -167,7 +172,6 @@ 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:
@@ -233,7 +237,6 @@ test.describe('skip test inside describe', () => {
 test.describe('skip test conditionally', async ({ browserName }) => {
   test.skip(browserName === 'firefox', 'Working on it');
 });
-
 ```
 
 Examples of **correct** code for this rule:
@@ -270,3 +273,126 @@ await page.locator('check').check();
 
 await page.locator('input').fill('something');
 ```
+
+### `max-nested-describe`
+
+Enforces a maximum depth to nested `.describe()` calls. Useful for improving readability and parallelization of tests.
+
+Uses a default max depth option of `{ "max": 5 }`.
+
+Examples of **incorrect** code for this rule (using defaults):
+
+```js
+test.describe('level 1', () => {
+  test.describe('level 2', () => {
+    test.describe('level 3', () => {
+      test.describe('level 4', () => {
+        test.describe('level 5', () => {
+          test.describe('level 6', () => {
+            test('this test', async ({ page }) => {});
+            test('that test', async ({ page }) => {});
+          });
+        });
+      });
+    });
+  });
+});
+```
+
+Examples of **correct** code for this rule (using defaults):
+
+```js
+test.describe('first level', () => {
+  test.describe('second level', () => {
+    test('this test', async ({ page }) => {});
+    test('that test', async ({ page }) => {});
+  });
+});
+```
+
+#### Options
+
+The rule accepts a non-required option to override the default maximum nested describe depth (5).
+
+```json
+{
+  "playwright/max-nested-describe": ["error", { "max": 3 }]
+}
+```
+
+### `no-conditional-in-test`
+
+Disallow conditional statements such as `if`, `switch`, and ternary expressions within tests.
+
+Examples of **incorrect** code for this rule:
+
+```js
+test('foo', async ({ page }) => {
+  if (someCondition) {
+    bar();
+  }
+});
+
+test('bar', async ({ page }) => {
+  switch (mode) {
+    case 'single':
+      generateOne();
+      break;
+    case 'double':
+      generateTwo();
+      break;
+    case 'multiple':
+      generateMany();
+      break;
+  }
+
+  await expect(page.locator('.my-image').count()).toBeGreaterThan(0);
+});
+
+test('baz', async ({ page }) => {
+  const hotkey =
+    process.platform === 'linux' ? ['Control', 'Alt', 'f'] : ['Alt', 'f'];
+  await Promise.all(hotkey.map((x) => page.keyboard.down(x)));
+
+  expect(actionIsPerformed()).toBe(true);
+});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+test.describe('my tests', () => {
+  if (someCondition) {
+    test('foo', async ({ page }) => {
+      bar();
+    });
+  }
+});
+
+beforeEach(() => {
+  switch (mode) {
+    case 'single':
+      generateOne();
+      break;
+    case 'double':
+      generateTwo();
+      break;
+    case 'multiple':
+      generateMany();
+      break;
+  }
+});
+
+test('bar', async ({ page }) => {
+  await expect(page.locator('.my-image').count()).toBeGreaterThan(0);
+});
+
+const hotkey =
+  process.platform === 'linux' ? ['Control', 'Alt', 'f'] : ['Alt', 'f'];
+
+test('baz', async ({ page }) => {
+  await Promise.all(hotkey.map((x) => page.keyboard.down(x)));
+
+  expect(actionIsPerformed()).toBe(true);
+});
+```

package/lib/index.js

@@ -1,50 +1,54 @@
-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");
-const noSkippedTest = require("./rules/no-skipped-test");
-const noWaitForTimeout = require("./rules/no-wait-for-timeout");
-const noForceOption = require("./rules/no-force-option");
+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');
+const noSkippedTest = require('./rules/no-skipped-test');
+const noWaitForTimeout = require('./rules/no-wait-for-timeout');
+const noForceOption = require('./rules/no-force-option');
+const maxNestedDescribe = require('./rules/max-nested-describe');
+const noConditionalInTest = require('./rules/no-conditional-in-test');
 
 module.exports = {
   configs: {
-    "playwright-test": {
-      plugins: ["playwright"],
+    'playwright-test': {
+      plugins: ['playwright'],
       env: {
-        "shared-node-browser": true,
+        'shared-node-browser': true,
       },
       rules: {
-        "no-empty-pattern": "off",
-        "playwright/missing-playwright-await": "error",
-        "playwright/no-page-pause": "warn",
-        "playwright/no-element-handle": "warn",
-        "playwright/no-eval": "warn",
-        "playwright/no-focused-test": "error",
-        "playwright/no-skipped-test": "warn",
-        "playwright/no-wait-for-timeout": "warn",
-        "playwright/no-force-option": "warn",
+        'no-empty-pattern': 'off',
+        'playwright/missing-playwright-await': 'error',
+        'playwright/no-page-pause': 'warn',
+        'playwright/no-element-handle': 'warn',
+        'playwright/no-eval': 'warn',
+        'playwright/no-focused-test': 'error',
+        'playwright/no-skipped-test': 'warn',
+        'playwright/no-wait-for-timeout': 'warn',
+        'playwright/no-force-option': 'warn',
+        'playwright/max-nested-describe': 'warn',
+        'playwright/no-conditional-in-test': 'warn',
       },
     },
-    "jest-playwright": {
-      plugins: ["jest", "playwright"],
+    'jest-playwright': {
+      plugins: ['jest', 'playwright'],
       env: {
-        "shared-node-browser": true,
+        'shared-node-browser': true,
         jest: true,
       },
       rules: {
-        "playwright/missing-playwright-await": "error",
-        "playwright/no-page-pause": "warn",
-        "jest/no-standalone-expect": [
-          "error",
+        'playwright/missing-playwright-await': 'error',
+        'playwright/no-page-pause': 'warn',
+        'jest/no-standalone-expect': [
+          'error',
           {
             additionalTestBlockFunctions: [
-              "test.jestPlaywrightDebug",
-              "it.jestPlaywrightDebug",
-              "test.jestPlaywrightSkip",
-              "it.jestPlaywrightSkip",
-              "test.jestPlaywrightConfig",
-              "it.jestPlaywrightConfig",
+              'test.jestPlaywrightDebug',
+              'it.jestPlaywrightDebug',
+              'test.jestPlaywrightSkip',
+              'it.jestPlaywrightSkip',
+              'test.jestPlaywrightConfig',
+              'it.jestPlaywrightConfig',
             ],
           },
         ],
@@ -60,13 +64,15 @@ module.exports = {
     },
   },
   rules: {
-    "missing-playwright-await": missingPlaywrightAwait,
-    "no-page-pause": noPagePause,
-    "no-element-handle": noElementHandle,
-    "no-eval": noEval,
-    "no-focused-test": noFocusedTest,
-    "no-skipped-test": noSkippedTest,
-    "no-wait-for-timeout": noWaitForTimeout,
-    "no-force-option": noForceOption,
+    'missing-playwright-await': missingPlaywrightAwait,
+    'no-page-pause': noPagePause,
+    'no-element-handle': noElementHandle,
+    'no-eval': noEval,
+    'no-focused-test': noFocusedTest,
+    'no-skipped-test': noSkippedTest,
+    'no-wait-for-timeout': noWaitForTimeout,
+    'no-force-option': noForceOption,
+    'max-nested-describe': maxNestedDescribe,
+    'no-conditional-in-test': noConditionalInTest,
   },
 };

package/lib/rules/max-nested-describe.js

@@ -0,0 +1,70 @@
+const { isCallExpression, isDescribeCall } = require('../utils/ast');
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  create(context) {
+    const { options } = context;
+    const defaultOptions = { max: 5 };
+    const { max } = options[0] || defaultOptions;
+    const describeCallbackStack = [];
+
+    function pushDescribeCallback(node) {
+      const { parent } = node;
+
+      if (!isCallExpression(parent) || !isDescribeCall(parent)) {
+        return;
+      }
+
+      describeCallbackStack.push(0);
+
+      if (describeCallbackStack.length > max) {
+        context.report({
+          node: parent,
+          messageId: 'exceededMaxDepth',
+          data: { depth: describeCallbackStack.length, max },
+        });
+      }
+    }
+
+    function popDescribeCallback(node) {
+      const { parent } = node;
+
+      if (isCallExpression(parent) && isDescribeCall(parent)) {
+        describeCallbackStack.pop();
+      }
+    }
+
+    return {
+      FunctionExpression: pushDescribeCallback,
+      'FunctionExpression:exit': popDescribeCallback,
+      ArrowFunctionExpression: pushDescribeCallback,
+      'ArrowFunctionExpression:exit': popDescribeCallback,
+    };
+  },
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Enforces a maximum depth to nested describe calls',
+      recommended: false,
+      url: 'https://github.com/playwright-community/eslint-plugin-playwright#max-nested-describe',
+    },
+    messages: {
+      exceededMaxDepth:
+        'Maximum describe call depth exceeded ({{ depth }}). Maximum allowed is {{ max }}.',
+    },
+    type: 'suggestion',
+    fixable: 'code',
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          max: {
+            type: 'integer',
+            minimum: 0,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+};

package/lib/rules/missing-playwright-await.js

@@ -1,68 +1,71 @@
 function getMemberPartName(node, part) {
-  return node[part].type === "Identifier" ? node[part].name : undefined;
+  return node[part].type === 'Identifier' ? node[part].name : undefined;
 }
 
 function getMemberExpressionNode(node, matchers) {
-  const propertyName = getMemberPartName(node, "property");
+  const propertyName = getMemberPartName(node, 'property');
 
-  if (getMemberPartName(node, "object") === "test") {
-    return propertyName === "step" ? { node, type: "testStep" } : undefined;
+  if (getMemberPartName(node, 'object') === 'test') {
+    return propertyName === 'step' ? { node, type: 'testStep' } : undefined;
   }
 
-  return matchers.has(propertyName) ? { node, type: "expect" } : undefined;
+  return matchers.has(propertyName) ? { node, type: 'expect' } : undefined;
 }
 
-function isValid(node) {
-  const grandparentType =
-    node.parent && node.parent.parent && node.parent.parent.type;
+const validTypes = new Set([
+  'AwaitExpression',
+  'ReturnStatement',
+  'ArrowFunctionExpression',
+]);
 
+function isValid(node) {
   return (
-    grandparentType === "AwaitExpression" ||
-    grandparentType === "ReturnStatement" ||
-    grandparentType === "ArrowFunctionExpression"
+    validTypes.has(node.parent?.type) ||
+    validTypes.has(node.parent?.parent?.type)
   );
 }
 
 const expectPlaywrightMatchers = [
-  "toBeChecked",
-  "toBeDisabled",
-  "toBeEnabled",
-  "toEqualText", // deprecated
-  "toEqualUrl",
-  "toEqualValue",
-  "toHaveFocus",
-  "toHaveSelector",
-  "toHaveSelectorCount",
-  "toHaveText", // deprecated
-  "toMatchAttribute",
-  "toMatchComputedStyle",
-  "toMatchText",
-  "toMatchTitle",
-  "toMatchURL",
-  "toMatchValue",
+  'toBeChecked',
+  'toBeDisabled',
+  'toBeEnabled',
+  'toEqualText', // deprecated
+  'toEqualUrl',
+  'toEqualValue',
+  'toHaveFocus',
+  'toHaveSelector',
+  'toHaveSelectorCount',
+  'toHaveText', // deprecated
+  'toMatchAttribute',
+  'toMatchComputedStyle',
+  'toMatchText',
+  'toMatchTitle',
+  'toMatchURL',
+  'toMatchValue',
 ];
 
 const playwrightTestMatchers = [
-  "toBeChecked",
-  "toBeDisabled",
-  "toBeEditable",
-  "toBeEmpty",
-  "toBeEnabled",
-  "toBeFocused",
-  "toBeHidden",
-  "toBeVisible",
-  "toContainText",
-  "toHaveAttribute",
-  "toHaveClass",
-  "toHaveCount",
-  "toHaveCSS",
-  "toHaveId",
-  "toHaveJSProperty",
-  "toBeOK",
-  "toHaveText",
-  "toHaveTitle",
-  "toHaveURL",
-  "toHaveValue",
+  'toBeChecked',
+  'toBeDisabled',
+  'toBeEditable',
+  'toBeEmpty',
+  'toBeEnabled',
+  'toBeFocused',
+  'toBeHidden',
+  'toBeVisible',
+  'toContainText',
+  'toHaveAttribute',
+  'toHaveClass',
+  'toHaveCount',
+  'toHaveCSS',
+  'toHaveId',
+  'toHaveJSProperty',
+  'toBeOK',
+  'toHaveScreenshot',
+  'toHaveText',
+  'toHaveTitle',
+  'toHaveURL',
+  'toHaveValue',
 ];
 
 module.exports = {
@@ -81,7 +84,7 @@ module.exports = {
 
         if (result && !isValid(result.node)) {
           context.report({
-            fix: (fixer) => fixer.insertTextBefore(result.node, "await "),
+            fix: (fixer) => fixer.insertTextBefore(result.node, 'await '),
             messageId: result.type,
             node: result.node,
           });
@@ -91,11 +94,11 @@ module.exports = {
   },
   meta: {
     docs: {
-      category: "Possible Errors",
+      category: 'Possible Errors',
       description: `Identify false positives when async Playwright APIs are not properly awaited.`,
       recommended: true,
     },
-    fixable: "code",
+    fixable: 'code',
     messages: {
       expect: "'expect' matchers must be awaited or returned.",
       testStep: "'test.step' must be awaited or returned.",
@@ -105,13 +108,13 @@ module.exports = {
         additionalProperties: false,
         properties: {
           customMatchers: {
-            items: { type: "string" },
-            type: "array",
+            items: { type: 'string' },
+            type: 'array',
           },
         },
-        type: "object",
+        type: 'object',
       },
     ],
-    type: "problem",
+    type: 'problem',
   },
 };

package/lib/rules/no-conditional-in-test.js

@@ -0,0 +1,61 @@
+const {
+  isTestIdentifier,
+  isDescribeCall,
+  isHookCall,
+} = require('../utils/ast');
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  create(context) {
+    let inTestCase = false;
+
+    function maybeReportConditional(node) {
+      if (inTestCase) {
+        context.report({
+          messageId: 'conditionalInTest',
+          node,
+        });
+      }
+    }
+
+    return {
+      CallExpression(node) {
+        const { callee } = node;
+        if (
+          isTestIdentifier(callee) &&
+          !isDescribeCall(node) &&
+          !isHookCall(node)
+        ) {
+          inTestCase = true;
+        }
+      },
+      'CallExpression:exit'(node) {
+        const { callee } = node;
+        if (
+          isTestIdentifier(callee) &&
+          !isDescribeCall(node) &&
+          !isHookCall(node)
+        ) {
+          inTestCase = false;
+        }
+      },
+      IfStatement: maybeReportConditional,
+      SwitchStatement: maybeReportConditional,
+      ConditionalExpression: maybeReportConditional,
+      LogicalExpression: maybeReportConditional,
+    };
+  },
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Disallow conditional logic in tests',
+      recommended: false,
+      url: 'https://github.com/playwright-community/eslint-plugin-playwright#no-conditional-in-test',
+    },
+    messages: {
+      conditionalInTest: 'Avoid having conditionals in tests',
+    },
+    type: 'problem',
+    schema: [],
+  },
+};

package/lib/rules/no-element-handle.js

@@ -1,9 +1,10 @@
 const { isObject, isCalleeProperty } = require('../utils/ast');
 
 function getRange(node) {
-  const start = node.parent && node.parent.type === 'AwaitExpression' 
-    ? node.parent.range[0]
-    : node.callee.object.range[0];
+  const start =
+    node.parent && node.parent.type === 'AwaitExpression'
+      ? node.parent.range[0]
+      : node.callee.object.range[0];
 
   return [start, node.callee.property.range[1]];
 }
@@ -12,7 +13,10 @@ module.exports = {
   create(context) {
     return {
       CallExpression(node) {
-        if (isObject(node, 'page') && (isCalleeProperty(node, '$') || isCalleeProperty(node, '$$'))) {
+        if (
+          isObject(node, 'page') &&
+          (isCalleeProperty(node, '$') || isCalleeProperty(node, '$$'))
+        ) {
           context.report({
             messageId: 'noElementHandle',
             suggest: [
@@ -20,7 +24,8 @@ module.exports = {
                 messageId: isCalleeProperty(node, '$')
                   ? 'replaceElementHandleWithLocator'
                   : 'replaceElementHandlesWithLocator',
-                fix: (fixer) => fixer.replaceTextRange(getRange(node), 'page.locator'),
+                fix: (fixer) =>
+                  fixer.replaceTextRange(getRange(node), 'page.locator'),
               },
             ],
             node,
@@ -32,7 +37,8 @@ module.exports = {
   meta: {
     docs: {
       category: 'Possible Errors',
-      description: 'The use of ElementHandle is discouraged, use Locator instead',
+      description:
+        'The use of ElementHandle is discouraged, use Locator instead',
       recommended: true,
       url: 'https://github.com/playwright-community/eslint-plugin-playwright#no-element-handle',
     },

package/lib/rules/no-eval.js

@@ -4,8 +4,14 @@ module.exports = {
   create(context) {
     return {
       CallExpression(node) {
-        if (isObject(node, 'page') && (isCalleeProperty(node, '$eval') || isCalleeProperty(node, '$$eval'))) {
-          context.report({ messageId: isCalleeProperty(node, '$eval') ? 'noEval' : 'noEvalAll', node });
+        if (
+          isObject(node, 'page') &&
+          (isCalleeProperty(node, '$eval') || isCalleeProperty(node, '$$eval'))
+        ) {
+          context.report({
+            messageId: isCalleeProperty(node, '$eval') ? 'noEval' : 'noEvalAll',
+            node,
+          });
         }
       },
     };

package/lib/rules/no-focused-test.js

@@ -16,14 +16,21 @@ module.exports = {
   create(context) {
     return {
       MemberExpression(node) {
-        if ((isTestIdentifier(node) || isTestGroup(node)) && hasAnnotation(node, 'only')) {
+        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]]),
+                fix: (fixer) =>
+                  fixer.removeRange([
+                    node.property.range[0] - 1,
+                    node.property.range[1],
+                  ]),
               },
             ],
             node,

package/lib/rules/no-force-option.js

@@ -6,7 +6,10 @@ function isForceOptionEnabled({ parent }) {
     parent.arguments.some(
       (argument) =>
         argument.type === 'ObjectExpression' &&
-        argument.properties.some(({ key, value }) => key && key.name === 'force' && value && value.value === true)
+        argument.properties.some(
+          ({ key, value }) =>
+            key && key.name === 'force' && value && value.value === true
+        )
     )
   );
 }
@@ -31,7 +34,11 @@ module.exports = {
   create(context) {
     return {
       MemberExpression(node) {
-        if (node.property && methodsWithForceOption.has(node.property.name) && isForceOptionEnabled(node)) {
+        if (
+          node.property &&
+          methodsWithForceOption.has(node.property.name) &&
+          isForceOptionEnabled(node)
+        ) {
           context.report({ messageId: 'noForceOption', node });
         }
       },

package/lib/rules/no-page-pause.js

@@ -5,20 +5,20 @@ module.exports = {
     return {
       CallExpression(node) {
         if (isObject(node, 'page') && isCalleeProperty(node, 'pause')) {
-          context.report({ messageId: "noPagePause", node });
+          context.report({ messageId: 'noPagePause', node });
         }
       },
     };
   },
   meta: {
     docs: {
-      category: "Possible Errors",
-      description: "Prevent usage of page.pause()",
+      category: 'Possible Errors',
+      description: 'Prevent usage of page.pause()',
       recommended: true,
     },
     messages: {
-      noPagePause: "Unexpected use of page.pause().",
+      noPagePause: 'Unexpected use of page.pause().',
     },
-    type: "problem",
+    type: 'problem',
   },
 };

package/lib/rules/no-skipped-test.js

@@ -24,9 +24,12 @@ function getSkipRange(node) {
 
   const isStandaloneSkip =
     !node.parent.arguments.length ||
-    ((isBinaryExpression(first) || isBooleanLiteral(first)) && isStringLiteral(second));
+    ((isBinaryExpression(first) || isBooleanLiteral(first)) &&
+      isStringLiteral(second));
 
-  return isStandaloneSkip ? node.parent.parent.range : [node.property.range[0] - 1, node.property.range[1]];
+  return isStandaloneSkip
+    ? node.parent.parent.range
+    : [node.property.range[0] - 1, node.property.range[1]];
 }
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -34,7 +37,10 @@ module.exports = {
   create(context) {
     return {
       MemberExpression(node) {
-        if ((isTestIdentifier(node) || isObjectProperty(node, 'describe')) && hasAnnotation(node, 'skip')) {
+        if (
+          (isTestIdentifier(node) || isObjectProperty(node, 'describe')) &&
+          hasAnnotation(node, 'skip')
+        ) {
           context.report({
             messageId: 'noSkippedTest',
             suggest: [

package/lib/rules/no-wait-for-timeout.js

@@ -5,7 +5,10 @@ module.exports = {
   create(context) {
     return {
       CallExpression(node) {
-        if (isObject(node, 'page') && isCalleeProperty(node, 'waitForTimeout')) {
+        if (
+          isObject(node, 'page') &&
+          isCalleeProperty(node, 'waitForTimeout')
+        ) {
           context.report({
             messageId: 'noWaitForTimeout',
             suggest: [
@@ -13,7 +16,9 @@ module.exports = {
                 messageId: 'removeWaitForTimeout',
                 fix: (fixer) =>
                   fixer.remove(
-                    node.parent && node.parent.type !== 'AwaitExpression' ? node.parent : node.parent.parent
+                    node.parent && node.parent.type !== 'AwaitExpression'
+                      ? node.parent
+                      : node.parent.parent
                   ),
               },
             ],

package/lib/utils/ast.js

@@ -16,8 +16,12 @@ function isCalleeProperty({ callee }, name) {
   );
 }
 
+function isTestObject({ object }) {
+  return object && isIdentifier(object, 'test');
+}
+
 function isTestIdentifier(node) {
-  return node.object && node.object.type === 'Identifier' && node.object.name === 'test';
+  return isIdentifier(node, 'test') || isTestObject(node);
 }
 
 function hasAnnotation(node, annotation) {
@@ -37,8 +41,13 @@ function isObjectProperty({ object }, name) {
   );
 }
 
-function isStringLiteral(node) {
-  return node && node.type === 'Literal' && typeof node.value === 'string';
+function isStringLiteral(node, value) {
+  return (
+    node &&
+    node.type === 'Literal' &&
+    typeof node.value === 'string' &&
+    (value === undefined || node.value === value)
+  );
 }
 
 function isBooleanLiteral(node) {
@@ -49,6 +58,66 @@ function isBinaryExpression(node) {
   return node && node.type === 'BinaryExpression';
 }
 
+function isCallExpression(node) {
+  return node && node.type === 'CallExpression';
+}
+
+function isMemberExpression(node) {
+  return node && node.type === 'MemberExpression';
+}
+
+function isIdentifier(node, name) {
+  return (
+    node &&
+    node.type === 'Identifier' &&
+    (name === undefined || node.name === name)
+  );
+}
+
+function isDescribeAlias(node) {
+  return isIdentifier(node, 'describe');
+}
+
+function isDescribeProperty(node) {
+  const describeProperties = ['parallel', 'serial', 'only', 'skip'];
+  return describeProperties.some((prop) => isIdentifier(node, prop));
+}
+
+function isDescribeCall(node) {
+  if (isDescribeAlias(node.callee)) {
+    return true;
+  }
+
+  const callee =
+    node.callee.type === 'TaggedTemplateExpression'
+      ? node.callee.tag
+      : node.callee.type === 'CallExpression'
+      ? node.callee.callee
+      : node.callee;
+
+  if (callee.type === 'MemberExpression' && isDescribeAlias(callee.property)) {
+    return true;
+  }
+
+  if (
+    callee.type === 'MemberExpression' &&
+    isDescribeProperty(callee.property)
+  ) {
+    return callee.object.type === 'MemberExpression'
+      ? callee.object.object.type === 'MemberExpression'
+        ? isDescribeAlias(callee.object.object.property)
+        : isDescribeAlias(callee.object.property)
+      : isDescribeAlias(callee.property) || isDescribeAlias(callee.object);
+  }
+
+  return false;
+}
+
+function isHookCall(node) {
+  const hooks = ['beforeAll', 'beforeEach', 'afterAll', 'afterEach'];
+  return hooks.some((hook) => isCalleeProperty(node, hook));
+}
+
 module.exports = {
   isObject,
   isCalleeProperty,
@@ -58,4 +127,8 @@ module.exports = {
   isStringLiteral,
   isBooleanLiteral,
   isBinaryExpression,
+  isCallExpression,
+  isMemberExpression,
+  isDescribeCall,
+  isHookCall,
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-playwright",
   "description": "ESLint plugin for Playwright testing.",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "main": "lib/index.js",
   "repository": "https://github.com/playwright-community/eslint-plugin-playwright",
   "author": "Max Schmitt <max@schmitt.mx>",
@@ -10,11 +10,13 @@
     "lib"
   ],
   "scripts": {
+    "format": "prettier --write .",
     "test": "jest"
   },
   "devDependencies": {
     "eslint": "^8.4.1",
-    "jest": "^27.4.5"
+    "jest": "^27.4.5",
+    "prettier": "^2.7.1"
   },
   "peerDependencies": {
     "eslint": ">=7",