Add no-networkidle rule (#134)

* Shell

* Tests

* Finish rule

Author: mskelton

docs/rules/no-networkidle.md

@@ -0,0 +1,14 @@
+# Disallow usage of the `networkidle` option (`no-networkidle`)
+
+Using `networkidle` is discouraged in favor of using
+[web first assertions](https://playwright.dev/docs/best-practices#use-web-first-assertions).
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```javascript
+await page.waitForLoadState('networkidle');
+await page.waitForURL('...', { waitUntil: 'networkidle' });
+await page.goto('...', { waitUntil: 'networkidle' });
+```

src/index.ts

@@ -5,6 +5,7 @@ import noElementHandle from './rules/no-element-handle';
 import noEval from './rules/no-eval';
 import noFocusedTest from './rules/no-focused-test';
 import noForceOption from './rules/no-force-option';
+import noNetworkidle from './rules/no-networkidle';
 import noPagePause from './rules/no-page-pause';
 import noRestrictedMatchers from './rules/no-restricted-matchers';
 import noSkippedTest from './rules/no-skipped-test';
@@ -33,6 +34,7 @@ const recommended = {
     'playwright/no-eval': 'warn',
     'playwright/no-focused-test': 'error',
     'playwright/no-force-option': 'warn',
+    'playwright/no-networkidle': 'error',
     'playwright/no-page-pause': 'warn',
     'playwright/no-skipped-test': 'warn',
     'playwright/no-useless-not': 'warn',
@@ -87,6 +89,7 @@ export = {
     'no-eval': noEval,
     'no-focused-test': noFocusedTest,
     'no-force-option': noForceOption,
+    'no-networkidle': noNetworkidle,
     'no-page-pause': noPagePause,
     'no-restricted-matchers': noRestrictedMatchers,
     'no-skipped-test': noSkippedTest,

src/rules/no-networkidle.ts

@@ -0,0 +1,63 @@
+import { Rule } from 'eslint';
+import * as ESTree from 'estree';
+import { getStringValue, isStringLiteral } from '../utils/ast';
+
+const messageId = 'noNetworkidle';
+const methods = new Set([
+  'goBack',
+  'goForward',
+  'goto',
+  'reload',
+  'setContent',
+  'waitForLoadState',
+  'waitForURL',
+]);
+
+export default {
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== 'MemberExpression') return;
+
+        const methodName = getStringValue(node.callee.property);
+        if (!methods.has(methodName)) return;
+
+        // waitForLoadState has a single string argument
+        if (methodName === 'waitForLoadState') {
+          const arg = node.arguments[0];
+
+          if (isStringLiteral(arg, 'networkidle')) {
+            context.report({ messageId, node: arg });
+          }
+
+          return;
+        }
+
+        // All other methods have an options object
+        if (node.arguments.length >= 2) {
+          const [_, arg] = node.arguments;
+          if (arg.type !== 'ObjectExpression') return;
+
+          const property = arg.properties
+            .filter((p): p is ESTree.Property => p.type === 'Property')
+            .find((p) => isStringLiteral(p.value, 'networkidle'));
+
+          if (property) {
+            context.report({ messageId, node: property.value });
+          }
+        }
+      },
+    };
+  },
+  meta: {
+    docs: {
+      category: 'Possible Errors',
+      description: 'Prevent usage of the networkidle option',
+      recommended: true,
+    },
+    messages: {
+      noNetworkidle: 'Unexpected use of networkidle.',
+    },
+    type: 'problem',
+  },
+} as Rule.RuleModule;

test/spec/no-networkidle.spec.ts

@@ -0,0 +1,59 @@
+import rule from '../../src/rules/no-networkidle';
+import { runRuleTester } from '../utils/rule-tester';
+
+const messageId = 'noNetworkidle';
+
+runRuleTester('no-networkidle', rule, {
+  invalid: [
+    {
+      code: 'page.waitForLoadState("networkidle")',
+      errors: [{ column: 23, endColumn: 36, line: 1, messageId }],
+    },
+    {
+      code: 'page.waitForURL(url, { waitUntil: "networkidle" })',
+      errors: [{ column: 35, endColumn: 48, line: 1, messageId }],
+    },
+    {
+      code: 'page["waitForURL"](url, { waitUntil: "networkidle" })',
+      errors: [{ column: 38, endColumn: 51, line: 1, messageId }],
+    },
+    {
+      code: 'page[`waitForURL`](url, { waitUntil: "networkidle" })',
+      errors: [{ column: 38, endColumn: 51, line: 1, messageId }],
+    },
+    {
+      code: 'page.goto(url, { waitUntil: "networkidle" })',
+      errors: [{ column: 29, endColumn: 42, line: 1, messageId }],
+    },
+    {
+      code: 'page.reload(url, { waitUntil: "networkidle" })',
+      errors: [{ column: 31, endColumn: 44, line: 1, messageId }],
+    },
+    {
+      code: 'page.setContent(url, { waitUntil: "networkidle" })',
+      errors: [{ column: 35, endColumn: 48, line: 1, messageId }],
+    },
+    {
+      code: 'page.goBack(url, { waitUntil: "networkidle" })',
+      errors: [{ column: 31, endColumn: 44, line: 1, messageId }],
+    },
+    {
+      code: 'page.goForward(url, { waitUntil: "networkidle" })',
+      errors: [{ column: 34, endColumn: 47, line: 1, messageId }],
+    },
+  ],
+  valid: [
+    'foo("networkidle")',
+    'foo(url, { waitUntil: "networkidle" })',
+    'foo.bar("networkidle")',
+    'foo.bar(url, { waitUntil: "networkidle" })',
+    'page.hi("networkidle")',
+    'page.hi(url, { waitUntil: "networkidle" })',
+    'frame.hi("networkidle")',
+    'frame.hi(url, { waitUntil: "networkidle" })',
+
+    // Other options are valid
+    'page.waitForLoadState({ waitUntil: "load" })',
+    'page.waitForUrl(url, { waitUntil: "load" })',
+  ],
+});