eslint-plugin-playwright 2.9.0 → 2.10.0

package/dist/index.cjs

@@ -861,6 +861,105 @@ var waitForMethods = [
   "waitForWebSocket"
 ];
 var waitForMethodsRegex = new RegExp(`^(${waitForMethods.join("|")})$`);
+var pageMethods = /* @__PURE__ */ new Set([
+  "addInitScript",
+  "addScriptTag",
+  "addStyleTag",
+  "bringToFront",
+  "check",
+  "click",
+  "close",
+  "dblclick",
+  "dispatchEvent",
+  "dragAndDrop",
+  "emulateMedia",
+  "evaluate",
+  "evaluateHandle",
+  "exposeBinding",
+  "exposeFunction",
+  "fill",
+  "focus",
+  "getAttribute",
+  "goBack",
+  "goForward",
+  "goto",
+  "hover",
+  "innerHTML",
+  "innerText",
+  "inputValue",
+  "isChecked",
+  "isDisabled",
+  "isEditable",
+  "isEnabled",
+  "isHidden",
+  "isVisible",
+  "pdf",
+  "press",
+  "reload",
+  "route",
+  "routeFromHAR",
+  "screenshot",
+  "selectOption",
+  "setBypassCSP",
+  "setContent",
+  "setChecked",
+  "setExtraHTTPHeaders",
+  "setInputFiles",
+  "setViewportSize",
+  "tap",
+  "textContent",
+  "title",
+  "type",
+  "uncheck",
+  "unroute",
+  "unrouteAll",
+  "waitForLoadState",
+  "waitForTimeout",
+  "waitForURL"
+]);
+var locatorMethods = /* @__PURE__ */ new Set([
+  "all",
+  "allInnerTexts",
+  "allTextContents",
+  "blur",
+  "boundingBox",
+  "check",
+  "clear",
+  "click",
+  "count",
+  "dblclick",
+  "dispatchEvent",
+  "dragTo",
+  "evaluate",
+  "evaluateAll",
+  "evaluateHandle",
+  "fill",
+  "focus",
+  "getAttribute",
+  "hover",
+  "innerHTML",
+  "innerText",
+  "inputValue",
+  "isChecked",
+  "isDisabled",
+  "isEditable",
+  "isEnabled",
+  "isHidden",
+  "isVisible",
+  "press",
+  "pressSequentially",
+  "screenshot",
+  "scrollIntoViewIfNeeded",
+  "selectOption",
+  "selectText",
+  "setChecked",
+  "setInputFiles",
+  "tap",
+  "textContent",
+  "type",
+  "uncheck",
+  "waitFor"
+]);
 var expectPlaywrightMatchers = [
   "toBeChecked",
   "toBeDisabled",
@@ -916,14 +1015,18 @@ function getReportNode(node) {
 }
 function getCallType(call, awaitableMatchers) {
   if (call.type === "step") {
-    return { messageId: "testStep", node: call.head.node };
+    return {
+      data: { name: "test.step" },
+      messageId: "missingAwait",
+      node: call.head.node
+    };
   }
   if (call.type === "expect") {
     const isPoll = call.modifiers.some((m) => getStringValue(m) === "poll");
     if (isPoll || awaitableMatchers.has(call.matcherName)) {
       return {
-        data: { matcherName: call.matcherName },
-        messageId: isPoll ? "expectPoll" : "expect",
+        data: { name: isPoll ? "expect.poll" : call.matcherName },
+        messageId: "missingAwait",
         node: call.head.node
       };
     }
@@ -932,6 +1035,7 @@ function getCallType(call, awaitableMatchers) {
 var missing_playwright_await_default = createRule({
   create(context) {
     const options = context.options[0] || {};
+    const includePageLocatorMethods = !!options.includePageLocatorMethods;
     const awaitableMatchers = /* @__PURE__ */ new Set([
       ...expectPlaywrightMatchers,
       ...playwrightTestMatchers,
@@ -992,9 +1096,18 @@ var missing_playwright_await_default = createRule({
       if (parent.type === "SpreadElement") {
         return checkValidity(parent, visited);
       }
-      if (parent.type === "CallExpression" && parent.callee.type === "MemberExpression" && isIdentifier(parent.callee.object, "Promise") && isIdentifier(parent.callee.property, "all")) {
+      if (parent.type === "CallExpression" && parent.callee.type === "MemberExpression" && isIdentifier(parent.callee.object, "Promise") && isIdentifier(parent.callee.property, /^(all|allSettled|race|any)$/)) {
         return true;
       }
+      if (parent.type === "MemberExpression" && parent.object === node && getStringValue(parent.property) === "resolves" && node.type === "CallExpression" && isIdentifier(node.callee, "expect")) {
+        return checkValidity(parent, visited);
+      }
+      if (parent.type === "MemberExpression" && parent.object === node) {
+        return checkValidity(parent, visited);
+      }
+      if (parent.type === "CallExpression" && parent.callee === node) {
+        return checkValidity(parent, visited);
+      }
       if (parent.type === "VariableDeclarator") {
         return isVariableConsumed(parent, checkValidity, validTypes, visited);
       }
@@ -1006,13 +1119,27 @@ var missing_playwright_await_default = createRule({
           if (!checkValidity(node, /* @__PURE__ */ new Set())) {
             const methodName = getStringValue(node.callee.property);
             context.report({
-              data: { methodName },
-              messageId: "waitFor",
+              data: { name: methodName },
+              messageId: "missingAwait",
               node
             });
           }
           return;
         }
+        if (includePageLocatorMethods && node.callee.type === "MemberExpression") {
+          const methodName = getStringValue(node.callee.property);
+          const isPlaywrightMethod = locatorMethods.has(methodName) || pageMethods.has(methodName) && isPageMethod(node, methodName);
+          if (isPlaywrightMethod) {
+            if (!checkValidity(node, /* @__PURE__ */ new Set())) {
+              context.report({
+                data: { name: methodName },
+                messageId: "missingAwait",
+                node
+              });
+            }
+            return;
+          }
+        }
         const call = parseFnCall(context, node);
         if (call?.type !== "step" && call?.type !== "expect") {
           return;
@@ -1038,10 +1165,7 @@ var missing_playwright_await_default = createRule({
     },
     fixable: "code",
     messages: {
-      expect: "'{{matcherName}}' must be awaited or returned.",
-      expectPoll: "'expect.poll' matchers must be awaited or returned.",
-      testStep: "'test.step' must be awaited or returned.",
-      waitFor: "'{{methodName}}' must be awaited or returned."
+      missingAwait: "'{{name}}' must be awaited or returned."
     },
     schema: [
       {
@@ -1050,6 +1174,9 @@ var missing_playwright_await_default = createRule({
           customMatchers: {
             items: { type: "string" },
             type: "array"
+          },
+          includePageLocatorMethods: {
+            type: "boolean"
           }
         },
         type: "object"
@@ -1962,11 +2089,15 @@ var no_skipped_test_default = createRule({
       CallExpression(node) {
         const options = context.options[0] || {};
         const allowConditional = !!options.allowConditional;
+        const disallowFixme = !!options.disallowFixme;
         const call = parseFnCall(context, node);
         if (call?.group !== "test" && call?.group !== "describe" && call?.group !== "step") {
           return;
         }
-        const skipNode = call.members.find((s) => getStringValue(s) === "skip");
+        const skipNode = call.members.find((member) => {
+          const value = getStringValue(member);
+          return value === "skip" || disallowFixme && value === "fixme";
+        });
         if (!skipNode) {
           return;
         }
@@ -1974,18 +2105,21 @@ var no_skipped_test_default = createRule({
         if (isStandalone && allowConditional && (node.arguments.length !== 0 || findParent(node, "BlockStatement")?.parent?.type === "IfStatement" || findParent(node, "SwitchCase") !== void 0)) {
           return;
         }
+        const annotation = getStringValue(skipNode);
         context.report({
+          data: { annotation },
           messageId: "noSkippedTest",
           node: isStandalone ? node : skipNode,
           suggest: [
             {
+              data: { annotation: getStringValue(skipNode) },
               fix: (fixer) => {
                 return isStandalone ? fixer.remove(node.parent) : fixer.removeRange([
                   skipNode.range[0] - 1,
                   skipNode.range[1] + Number(skipNode.type !== "Identifier")
                 ]);
               },
-              messageId: "removeSkippedTestAnnotation"
+              messageId: "removeAnnotation"
             }
           ]
         });
@@ -2000,8 +2134,8 @@ var no_skipped_test_default = createRule({
     },
     hasSuggestions: true,
     messages: {
-      noSkippedTest: "Unexpected use of the `.skip()` annotation.",
-      removeSkippedTestAnnotation: "Remove the `.skip()` annotation."
+      noSkippedTest: "Unexpected use of the `.{{annotation}}()` annotation.",
+      removeAnnotation: "Remove the `.{{annotation}}()` annotation."
     },
     schema: [
       {
@@ -2010,6 +2144,10 @@ var no_skipped_test_default = createRule({
           allowConditional: {
             default: false,
             type: "boolean"
+          },
+          disallowFixme: {
+            default: false,
+            type: "boolean"
           }
         },
         type: "object"
@@ -2306,7 +2444,7 @@ var no_unused_locators_default = createRule({
 });
 
 // src/rules/no-useless-await.ts
-var locatorMethods = /* @__PURE__ */ new Set([
+var locatorMethods2 = /* @__PURE__ */ new Set([
   "and",
   "first",
   "getByAltText",
@@ -2321,7 +2459,7 @@ var locatorMethods = /* @__PURE__ */ new Set([
   "nth",
   "or"
 ]);
-var pageMethods = /* @__PURE__ */ new Set([
+var pageMethods2 = /* @__PURE__ */ new Set([
   "childFrames",
   "frame",
   "frameLocator",
@@ -2370,7 +2508,7 @@ function isSupportedMethod(node) {
     return false;
   }
   const name = getStringValue(node.callee.property);
-  return locatorMethods.has(name) || pageMethods.has(name) && isPageMethod(node, name);
+  return locatorMethods2.has(name) || pageMethods2.has(name) && isPageMethod(node, name);
 }
 var no_useless_await_default = createRule({
   create(context) {
@@ -2881,7 +3019,7 @@ var prefer_hooks_on_top_default = createRule({
 });
 
 // src/rules/prefer-locator.ts
-var pageMethods2 = /* @__PURE__ */ new Set([
+var pageMethods3 = /* @__PURE__ */ new Set([
   "click",
   "dblclick",
   "dispatchEvent",
@@ -2911,7 +3049,7 @@ function isSupportedMethod2(node) {
     return false;
   }
   const name = getStringValue(node.callee.property);
-  return pageMethods2.has(name) && isPageMethod(node, name);
+  return pageMethods3.has(name) && isPageMethod(node, name);
 }
 var prefer_locator_default = createRule({
   create(context) {
@@ -4015,7 +4153,7 @@ var isPromiseMethodThatUsesValue = (node, identifier) => {
   }
   if (node.argument.type === "CallExpression" && node.argument.arguments.length > 0) {
     const nodeName = getNodeName(node.argument);
-    if (["Promise.all", "Promise.allSettled"].includes(nodeName)) {
+    if (/^Promise\.(all|allSettled|race|any)$/.test(nodeName)) {
       const [firstArg] = node.argument.arguments;
       if (firstArg.type === "ArrayExpression" && firstArg.elements.some((nod) => nod && isIdentifier(nod, name))) {
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-playwright",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "description": "ESLint plugin for Playwright testing.",
   "license": "MIT",
   "author": "Mark Skelton <mark@mskelton.dev>",