Add new "noWaitForTimeout" rule (playwright-community#46)

* 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

* feature: add noWaitForTimeout rule

Author: elaichenkov

README.md

@@ -190,3 +190,24 @@ test.describe.serial('two tests in serial mode', () => {
   test('two', async ({ page }) => {});
 });
 ```
+
+### `no-wait-for-timeout`
+
+Disallow usage of `page.waitForTimeout()`.
+
+Example of **incorrect** code for this rule:
+
+```js
+await page.waitForTimeout(5000);
+```
+
+Examples of **correct** code for this rule:
+
+```js
+// Use signals such as network events, selectors becoming visible and others instead.
+await page.waitForLoadState();
+
+await page.waitForUrl('/home');
+
+await page.waitForFunction(() => window.innerWidth < 100);
+```

lib/index.js

@@ -3,6 +3,7 @@ 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 noWaitForTimeout = require("./rules/no-wait-for-timeout");
 
 module.exports = {
   configs: {
@@ -18,6 +19,7 @@ module.exports = {
         "playwright/no-element-handle": "warn",
         "playwright/no-eval": "warn",
         "playwright/no-focused-test": "error",
+        "playwright/no-wait-for-timeout": "warn",
       },
     },
     "jest-playwright": {
@@ -59,5 +61,6 @@ module.exports = {
     "no-element-handle": noElementHandle,
     "no-eval": noEval,
     "no-focused-test": noFocusedTest,
+    "no-wait-for-timeout": noWaitForTimeout,
   },
 };

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

@@ -0,0 +1,40 @@
+const { isPageIdentifier, isCalleeProperty } = require('../utils/ast');
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (isPageIdentifier(node) && isCalleeProperty(node, 'waitForTimeout')) {
+          context.report({
+            messageId: 'noWaitForTimeout',
+            suggest: [
+              {
+                messageId: 'removeWaitForTimeout',
+                fix: (fixer) =>
+                  fixer.remove(
+                    node.parent && node.parent.type !== 'AwaitExpression' ? node.parent : node.parent.parent
+                  ),
+              },
+            ],
+            node,
+          });
+        }
+      },
+    };
+  },
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description: 'Prevent usage of page.waitForTimeout()',
+      recommended: true,
+      url: 'https://github.com/playwright-community/eslint-plugin-playwright#no-wait-for-timeout',
+    },
+    hasSuggestions: true,
+    messages: {
+      noWaitForTimeout: 'Unexpected use of page.waitForTimeout().',
+      removeWaitForTimeout: 'Remove the page.waitForTimeout() method.',
+    },
+    type: 'suggestion',
+  },
+};

test/no-wait-for-timeout.spec.js

@@ -0,0 +1,35 @@
+const { RuleTester } = require('eslint');
+const rule = require('../lib/rules/no-wait-for-timeout');
+
+RuleTester.setDefaultConfig({
+  parserOptions: {
+    ecmaVersion: 2018,
+  },
+});
+
+const invalid = (code, output) => ({
+  code,
+  errors: [
+    {
+      messageId: 'noWaitForTimeout',
+      suggestions: [{ messageId: 'removeWaitForTimeout', output }],
+    },
+  ],
+});
+
+new RuleTester().run('no-wait-for-timeout', rule, {
+  invalid: [
+    invalid(`async function fn() { await page.waitForTimeout(1000) }`, 'async function fn() {  }'),
+    invalid('async function fn() { return page.waitForTimeout(1000); }', 'async function fn() {  }'),
+    invalid('async function fn() { page.waitForTimeout(1000); }', 'async function fn() {  }'),
+    invalid('(async function() { await page.waitForTimeout(500); })();', '(async function() {  })();'),
+    invalid('page.waitForTimeout(1000);', ''),
+    invalid('page.waitForTimeout(2000)', ''),
+  ],
+  valid: [
+    'function waitForTimeout() {}',
+    'async function fn() { await waitForTimeout(4343); }',
+    '(async function() { await page.waitForSelector("#foo"); })();',
+    'page.waitForSelector("#foo");',
+  ],
+});