eslint-plugin-playwright 1.1.2 → 1.2.0

package/dist/index.js

@@ -54,9 +54,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);
 }
@@ -86,9 +89,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]);
 }
 var testHooks = /* @__PURE__ */ new Set(["afterAll", "afterEach", "beforeAll", "beforeEach"]);
 function isTestHook(context, node) {
@@ -192,6 +193,69 @@ var expect_expect_default = {
   }
 };
 
+// src/rules/max-expects.ts
+var 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 = {
   create(context) {
@@ -399,6 +463,132 @@ var missing_playwright_await_default = {
   }
 };
 
+// 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 = {
+  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 = (node) => node.callee.type === "MemberExpression" && isPropertyAccessor(node.callee, "catch");
+var getTestCallExpressionsFromDeclaredVariables = (context, declaredVariables) => {
+  return declaredVariables.reduce(
+    (acc, { references }) => [
+      ...acc,
+      ...references.map(({ identifier }) => getParent(identifier)).filter(
+        (node) => node?.type === "CallExpression" && isTestCall(context, node)
+      )
+    ],
+    []
+  );
+};
+var 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 = {
   create(context) {
@@ -430,6 +620,51 @@ var no_conditional_in_test_default = {
   }
 };
 
+// src/rules/no-duplicate-hooks.ts
+var 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];
@@ -997,6 +1232,95 @@ var no_skipped_test_default = {
   }
 };
 
+// src/rules/no-standalone-expect.ts
+var 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;
+};
+var 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 = (amount) => ({
   amount: amount.toString(),
@@ -1319,6 +1643,97 @@ var no_wait_for_timeout_default = {
   }
 };
 
+// src/rules/prefer-hooks-in-order.ts
+var HooksOrder = ["beforeAll", "beforeEach", "afterEach", "afterAll"];
+var 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 = {
+  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 = {
   create(context) {
@@ -2273,9 +2688,13 @@ var index = {
   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,
@@ -2288,11 +2707,14 @@ var index = {
     "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,
@@ -2312,6 +2734,7 @@ var sharedConfig = {
     "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",
@@ -2321,6 +2744,7 @@ var sharedConfig = {
     "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",