eslint-plugin-playwright 1.1.2 → 1.2.0

package/dist/index.mjs

@@ -33,9 +33,12 @@ function isStringNode(node) {
 function isPropertyAccessor(node, name) {
   return getStringValue(node.property) === name;
 }
-function isTestIdentifier(context, node) {
+function getTestNames(context) {
   const aliases = context.settings.playwright?.globalAliases?.test ?? [];
-  const testNames = ["test", ...aliases];
+  return ["test", ...aliases];
+}
+function isTestIdentifier(context, node) {
+  const testNames = getTestNames(context);
   const regex = new RegExp(`^(${testNames.join("|")})$`);
   return isIdentifier(node, regex) || node.type === "MemberExpression" && isIdentifier(node.object, regex);
 }
@@ -58,9 +61,7 @@ function findParent(node, type) {
   return node.parent.type === type ? node.parent : findParent(node.parent, type);
 }
 function isTestCall(context, node, modifiers) {
-  return isTestIdentifier(context, node.callee) && !isDescribeCall(node) && (node.callee.type !== "MemberExpression" || !modifiers || modifiers?.includes(getStringValue(node.callee.property))) && node.arguments.length === 2 && ["ArrowFunctionExpression", "FunctionExpression"].includes(
-    node.arguments[1].type
-  );
+  return isTestIdentifier(context, node.callee) && !isDescribeCall(node) && (node.callee.type !== "MemberExpression" || !modifiers || modifiers?.includes(getStringValue(node.callee.property))) && node.arguments.length === 2 && isFunction(node.arguments[1]);
 }
 function isTestHook(context, node) {
   return node.callee.type === "MemberExpression" && isTestIdentifier(context, node.callee.object) && testHooks.has(getStringValue(node.callee.property));
@@ -186,6 +187,76 @@ var init_expect_expect = __esm({
   }
 });
 
+// src/rules/max-expects.ts
+var max_expects_default;
+var init_max_expects = __esm({
+  "src/rules/max-expects.ts"() {
+    "use strict";
+    init_ast();
+    max_expects_default = {
+      create(context) {
+        const options = {
+          max: 5,
+          ...context.options?.[0] ?? {}
+        };
+        let count = 0;
+        const maybeResetCount = (node) => {
+          const parent = getParent(node);
+          const isTestFn = parent?.type !== "CallExpression" || isTestCall(context, parent);
+          if (isTestFn) {
+            count = 0;
+          }
+        };
+        return {
+          ArrowFunctionExpression: maybeResetCount,
+          "ArrowFunctionExpression:exit": maybeResetCount,
+          CallExpression(node) {
+            if (!getExpectType(context, node))
+              return;
+            count += 1;
+            if (count > options.max) {
+              context.report({
+                data: {
+                  count: count.toString(),
+                  max: options.max.toString()
+                },
+                messageId: "exceededMaxAssertion",
+                node
+              });
+            }
+          },
+          FunctionExpression: maybeResetCount,
+          "FunctionExpression:exit": maybeResetCount
+        };
+      },
+      meta: {
+        docs: {
+          category: "Best Practices",
+          description: "Enforces a maximum number assertion calls in a test body",
+          recommended: false,
+          url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/max-expects.md"
+        },
+        messages: {
+          exceededMaxAssertion: "Too many assertion calls ({{ count }}) - maximum allowed is {{ max }}"
+        },
+        schema: [
+          {
+            additionalProperties: false,
+            properties: {
+              max: {
+                minimum: 1,
+                type: "integer"
+              }
+            },
+            type: "object"
+          }
+        ],
+        type: "suggestion"
+      }
+    };
+  }
+});
+
 // src/rules/max-nested-describe.ts
 var max_nested_describe_default;
 var init_max_nested_describe = __esm({
@@ -407,6 +478,146 @@ var init_missing_playwright_await = __esm({
   }
 });
 
+// src/rules/no-commented-out-tests.ts
+function hasTests(context, node) {
+  const testNames = getTestNames(context);
+  const names = testNames.join("|");
+  const regex = new RegExp(
+    `^\\s*(${names}|describe)(\\.\\w+|\\[['"]\\w+['"]\\])?\\s*\\(`,
+    "mu"
+  );
+  return regex.test(node.value);
+}
+var no_commented_out_tests_default;
+var init_no_commented_out_tests = __esm({
+  "src/rules/no-commented-out-tests.ts"() {
+    "use strict";
+    init_ast();
+    no_commented_out_tests_default = {
+      create(context) {
+        function checkNode(node) {
+          if (!hasTests(context, node))
+            return;
+          context.report({
+            messageId: "commentedTests",
+            node
+          });
+        }
+        return {
+          Program() {
+            context.sourceCode.getAllComments().forEach(checkNode);
+          }
+        };
+      },
+      meta: {
+        docs: {
+          category: "Best Practices",
+          description: "Disallow commented out tests",
+          recommended: true,
+          url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-commented-out-tests.md"
+        },
+        messages: {
+          commentedTests: "Some tests seem to be commented"
+        },
+        type: "problem"
+      }
+    };
+  }
+});
+
+// src/rules/no-conditional-expect.ts
+var isCatchCall, getTestCallExpressionsFromDeclaredVariables, no_conditional_expect_default;
+var init_no_conditional_expect = __esm({
+  "src/rules/no-conditional-expect.ts"() {
+    "use strict";
+    init_ast();
+    isCatchCall = (node) => node.callee.type === "MemberExpression" && isPropertyAccessor(node.callee, "catch");
+    getTestCallExpressionsFromDeclaredVariables = (context, declaredVariables) => {
+      return declaredVariables.reduce(
+        (acc, { references }) => [
+          ...acc,
+          ...references.map(({ identifier }) => getParent(identifier)).filter(
+            (node) => node?.type === "CallExpression" && isTestCall(context, node)
+          )
+        ],
+        []
+      );
+    };
+    no_conditional_expect_default = {
+      create(context) {
+        let conditionalDepth = 0;
+        let inTestCase = false;
+        let inPromiseCatch = false;
+        const increaseConditionalDepth = () => inTestCase && conditionalDepth++;
+        const decreaseConditionalDepth = () => inTestCase && conditionalDepth--;
+        return {
+          CallExpression(node) {
+            if (isTestCall(context, node)) {
+              inTestCase = true;
+            }
+            if (isCatchCall(node)) {
+              inPromiseCatch = true;
+            }
+            const expectType = getExpectType(context, node);
+            if (inTestCase && expectType && conditionalDepth > 0) {
+              context.report({
+                messageId: "conditionalExpect",
+                node
+              });
+            }
+            if (inPromiseCatch && expectType) {
+              context.report({
+                messageId: "conditionalExpect",
+                node
+              });
+            }
+          },
+          "CallExpression:exit"(node) {
+            if (isTestCall(context, node)) {
+              inTestCase = false;
+            }
+            if (isCatchCall(node)) {
+              inPromiseCatch = false;
+            }
+          },
+          CatchClause: increaseConditionalDepth,
+          "CatchClause:exit": decreaseConditionalDepth,
+          ConditionalExpression: increaseConditionalDepth,
+          "ConditionalExpression:exit": decreaseConditionalDepth,
+          FunctionDeclaration(node) {
+            const declaredVariables = context.sourceCode.getDeclaredVariables(node);
+            const testCallExpressions = getTestCallExpressionsFromDeclaredVariables(
+              context,
+              declaredVariables
+            );
+            if (testCallExpressions.length > 0) {
+              inTestCase = true;
+            }
+          },
+          IfStatement: increaseConditionalDepth,
+          "IfStatement:exit": decreaseConditionalDepth,
+          LogicalExpression: increaseConditionalDepth,
+          "LogicalExpression:exit": decreaseConditionalDepth,
+          SwitchStatement: increaseConditionalDepth,
+          "SwitchStatement:exit": decreaseConditionalDepth
+        };
+      },
+      meta: {
+        docs: {
+          category: "Best Practices",
+          description: "Disallow calling `expect` conditionally",
+          recommended: true,
+          url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-conditional-expect.md"
+        },
+        messages: {
+          conditionalExpect: "Avoid calling `expect` conditionally`"
+        },
+        type: "problem"
+      }
+    };
+  }
+});
+
 // src/rules/no-conditional-in-test.ts
 var no_conditional_in_test_default;
 var init_no_conditional_in_test = __esm({
@@ -445,6 +656,58 @@ var init_no_conditional_in_test = __esm({
   }
 });
 
+// src/rules/no-duplicate-hooks.ts
+var no_duplicate_hooks_default;
+var init_no_duplicate_hooks = __esm({
+  "src/rules/no-duplicate-hooks.ts"() {
+    "use strict";
+    init_ast();
+    no_duplicate_hooks_default = {
+      create(context) {
+        const hookContexts = [{}];
+        return {
+          CallExpression(node) {
+            if (isDescribeCall(node)) {
+              hookContexts.push({});
+            }
+            if (!isTestHook(context, node)) {
+              return;
+            }
+            const currentLayer = hookContexts[hookContexts.length - 1];
+            const name = node.callee.type === "MemberExpression" ? getStringValue(node.callee.property) : "";
+            currentLayer[name] || (currentLayer[name] = 0);
+            currentLayer[name] += 1;
+            if (currentLayer[name] > 1) {
+              context.report({
+                data: { hook: name },
+                messageId: "noDuplicateHook",
+                node
+              });
+            }
+          },
+          "CallExpression:exit"(node) {
+            if (isDescribeCall(node)) {
+              hookContexts.pop();
+            }
+          }
+        };
+      },
+      meta: {
+        docs: {
+          category: "Best Practices",
+          description: "Disallow duplicate setup and teardown hooks",
+          recommended: false,
+          url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-duplicate-hooks.md"
+        },
+        messages: {
+          noDuplicateHook: "Duplicate {{ hook }} in describe block"
+        },
+        type: "suggestion"
+      }
+    };
+  }
+});
+
 // src/rules/no-element-handle.ts
 function getPropertyRange(node) {
   return node.type === "Identifier" ? node.range : [node.range[0] + 1, node.range[1] - 1];
@@ -1104,6 +1367,102 @@ var init_no_skipped_test = __esm({
   }
 });
 
+// src/rules/no-standalone-expect.ts
+var getBlockType, no_standalone_expect_default;
+var init_no_standalone_expect = __esm({
+  "src/rules/no-standalone-expect.ts"() {
+    "use strict";
+    init_ast();
+    getBlockType = (statement) => {
+      const func = getParent(statement);
+      if (!func) {
+        throw new Error(
+          `Unexpected BlockStatement. No parent defined. - please file a github issue at https://github.com/jest-community/eslint-plugin-jest`
+        );
+      }
+      if (func.type === "FunctionDeclaration") {
+        return "function";
+      }
+      if (isFunction(func) && func.parent) {
+        const expr = func.parent;
+        if (expr.type === "VariableDeclarator") {
+          return "function";
+        }
+        if (expr.type === "CallExpression" && isDescribeCall(expr)) {
+          return "describe";
+        }
+      }
+      return null;
+    };
+    no_standalone_expect_default = {
+      create(context) {
+        const callStack = [];
+        return {
+          ArrowFunctionExpression(node) {
+            if (node.parent?.type !== "CallExpression") {
+              callStack.push("arrow");
+            }
+          },
+          "ArrowFunctionExpression:exit"() {
+            if (callStack[callStack.length - 1] === "arrow") {
+              callStack.pop();
+            }
+          },
+          BlockStatement(statement) {
+            const blockType = getBlockType(statement);
+            if (blockType) {
+              callStack.push(blockType);
+            }
+          },
+          "BlockStatement:exit"(statement) {
+            if (callStack[callStack.length - 1] === getBlockType(statement)) {
+              callStack.pop();
+            }
+          },
+          CallExpression(node) {
+            if (getExpectType(context, node)) {
+              const parent = callStack.at(-1);
+              if (!parent || parent === "describe") {
+                const root = findParent(node, "CallExpression");
+                context.report({
+                  messageId: "unexpectedExpect",
+                  node: root ?? node
+                });
+              }
+              return;
+            }
+            if (isTestCall(context, node)) {
+              callStack.push("test");
+            }
+            if (node.callee.type === "TaggedTemplateExpression") {
+              callStack.push("template");
+            }
+          },
+          "CallExpression:exit"(node) {
+            const top = callStack[callStack.length - 1];
+            if (top === "test" && isTestCall(context, node) && node.callee.type !== "MemberExpression" || top === "template" && node.callee.type === "TaggedTemplateExpression") {
+              callStack.pop();
+            }
+          }
+        };
+      },
+      meta: {
+        docs: {
+          category: "Best Practices",
+          description: "Disallow using `expect` outside of `test` blocks",
+          recommended: false,
+          url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-contain.md"
+        },
+        fixable: "code",
+        messages: {
+          unexpectedExpect: "Expect must be inside of a test block"
+        },
+        type: "suggestion"
+      }
+    };
+  }
+});
+
 // src/utils/misc.ts
 var getAmountData, truthy;
 var init_misc = __esm({
@@ -1476,6 +1835,111 @@ var init_no_wait_for_timeout = __esm({
   }
 });
 
+// src/rules/prefer-hooks-in-order.ts
+var HooksOrder, prefer_hooks_in_order_default;
+var init_prefer_hooks_in_order = __esm({
+  "src/rules/prefer-hooks-in-order.ts"() {
+    "use strict";
+    init_ast();
+    HooksOrder = ["beforeAll", "beforeEach", "afterEach", "afterAll"];
+    prefer_hooks_in_order_default = {
+      create(context) {
+        let previousHookIndex = -1;
+        let inHook = false;
+        return {
+          CallExpression(node) {
+            if (inHook)
+              return;
+            if (!isTestHook(context, node)) {
+              previousHookIndex = -1;
+              return;
+            }
+            inHook = true;
+            const currentHook = node.callee.type === "MemberExpression" ? getStringValue(node.callee.property) : "";
+            const currentHookIndex = HooksOrder.indexOf(currentHook);
+            if (currentHookIndex < previousHookIndex) {
+              return context.report({
+                data: {
+                  currentHook,
+                  previousHook: HooksOrder[previousHookIndex]
+                },
+                messageId: "reorderHooks",
+                node
+              });
+            }
+            previousHookIndex = currentHookIndex;
+          },
+          "CallExpression:exit"(node) {
+            if (isTestHook(context, node)) {
+              inHook = false;
+              return;
+            }
+            if (inHook) {
+              return;
+            }
+            previousHookIndex = -1;
+          }
+        };
+      },
+      meta: {
+        docs: {
+          category: "Best Practices",
+          description: "Prefer having hooks in a consistent order",
+          recommended: false,
+          url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-in-order.md"
+        },
+        messages: {
+          reorderHooks: "`{{ currentHook }}` hooks should be before any `{{ previousHook }}` hooks"
+        },
+        type: "suggestion"
+      }
+    };
+  }
+});
+
+// src/rules/prefer-hooks-on-top.ts
+var prefer_hooks_on_top_default;
+var init_prefer_hooks_on_top = __esm({
+  "src/rules/prefer-hooks-on-top.ts"() {
+    "use strict";
+    init_ast();
+    prefer_hooks_on_top_default = {
+      create(context) {
+        const stack = [false];
+        return {
+          CallExpression(node) {
+            if (isTestCall(context, node)) {
+              stack[stack.length - 1] = true;
+            }
+            if (stack.at(-1) && isTestHook(context, node)) {
+              context.report({
+                messageId: "noHookOnTop",
+                node
+              });
+            }
+            stack.push(false);
+          },
+          "CallExpression:exit"() {
+            stack.pop();
+          }
+        };
+      },
+      meta: {
+        docs: {
+          category: "Best Practices",
+          description: "Suggest having hooks before any test cases",
+          recommended: false,
+          url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-on-top.md"
+        },
+        messages: {
+          noHookOnTop: "Hooks should come before test cases"
+        },
+        type: "suggestion"
+      }
+    };
+  }
+});
+
 // src/rules/prefer-lowercase-title.ts
 var prefer_lowercase_title_default;
 var init_prefer_lowercase_title = __esm({
@@ -2519,9 +2983,13 @@ import globals from "globals";
 var require_src = __commonJS({
   "src/index.ts"(exports, module) {
     init_expect_expect();
+    init_max_expects();
     init_max_nested_describe();
     init_missing_playwright_await();
+    init_no_commented_out_tests();
+    init_no_conditional_expect();
     init_no_conditional_in_test();
+    init_no_duplicate_hooks();
     init_no_element_handle();
     init_no_eval();
     init_no_focused_test();
@@ -2534,11 +3002,14 @@ var require_src = __commonJS({
     init_no_raw_locators();
     init_no_restricted_matchers();
     init_no_skipped_test();
+    init_no_standalone_expect();
     init_no_unsafe_references();
     init_no_useless_await();
     init_no_useless_not();
     init_no_wait_for_selector();
     init_no_wait_for_timeout();
+    init_prefer_hooks_in_order();
+    init_prefer_hooks_on_top();
     init_prefer_lowercase_title();
     init_prefer_strict_equal();
     init_prefer_to_be();
@@ -2554,9 +3025,13 @@ var require_src = __commonJS({
       configs: {},
       rules: {
         "expect-expect": expect_expect_default,
+        "max-expects": max_expects_default,
         "max-nested-describe": max_nested_describe_default,
         "missing-playwright-await": missing_playwright_await_default,
+        "no-commented-out-tests": no_commented_out_tests_default,
+        "no-conditional-expect": no_conditional_expect_default,
         "no-conditional-in-test": no_conditional_in_test_default,
+        "no-duplicate-hooks": no_duplicate_hooks_default,
         "no-element-handle": no_element_handle_default,
         "no-eval": no_eval_default,
         "no-focused-test": no_focused_test_default,
@@ -2569,11 +3044,14 @@ var require_src = __commonJS({
         "no-raw-locators": no_raw_locators_default,
         "no-restricted-matchers": no_restricted_matchers_default,
         "no-skipped-test": no_skipped_test_default,
+        "no-standalone-expect": no_standalone_expect_default,
         "no-unsafe-references": no_unsafe_references_default,
         "no-useless-await": no_useless_await_default,
         "no-useless-not": no_useless_not_default,
         "no-wait-for-selector": no_wait_for_selector_default,
         "no-wait-for-timeout": no_wait_for_timeout_default,
+        "prefer-hooks-in-order": prefer_hooks_in_order_default,
+        "prefer-hooks-on-top": prefer_hooks_on_top_default,
         "prefer-lowercase-title": prefer_lowercase_title_default,
         "prefer-strict-equal": prefer_strict_equal_default,
         "prefer-to-be": prefer_to_be_default,
@@ -2593,6 +3071,7 @@ var require_src = __commonJS({
         "playwright/expect-expect": "warn",
         "playwright/max-nested-describe": "warn",
         "playwright/missing-playwright-await": "error",
+        "playwright/no-conditional-expect": "warn",
         "playwright/no-conditional-in-test": "warn",
         "playwright/no-element-handle": "warn",
         "playwright/no-eval": "warn",
@@ -2602,6 +3081,7 @@ var require_src = __commonJS({
         "playwright/no-networkidle": "error",
         "playwright/no-page-pause": "warn",
         "playwright/no-skipped-test": "warn",
+        "playwright/no-standalone-expect": "error",
         "playwright/no-unsafe-references": "error",
         "playwright/no-useless-await": "warn",
         "playwright/no-useless-not": "warn",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-playwright",
   "description": "ESLint plugin for Playwright testing.",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "repository": "https://github.com/playwright-community/eslint-plugin-playwright",
   "author": "Mark Skelton <mark@mskelton.dev>",
   "packageManager": "pnpm@8.12.0",