Add support for test.step in missing-playwright-await rule.

README.md

@@ -43,25 +43,33 @@ This plugin bundles two configurations to work with both `@playwright/test` or `
 
 ### `missing-playwright-await` 🔧
 
-Enforce Playwright expect statements to be awaited.
+Identify false positives when async Playwright APIs are not properly awaited.
 
 #### Example
 
 Example of **incorrect** code for this rule:
 
 ```js
 expect(page).toMatchText("text");
+
+test.step("clicks the button", async () => {
+  await page.click("button");
+});
 ```
 
 Example of **correct** code for this rule:
 
 ```js
 await expect(page).toMatchText("text");
+
+await test.step("clicks the button", async () => {
+  await page.click("button");
+});
 ```
 
 #### Options
 
-The rule accepts a non-required option which can be used to specify custom matchers which this rule should also warn about. This is useful when creating your own async matchers.
+The rule accepts a non-required option which can be used to specify custom matchers which this rule should also warn about. This is useful when creating your own async `expect` matchers.
 
 ```json
 {

lib/rules/missing-playwright-await.js

@@ -1,18 +1,25 @@
-function getPromiseMemberExpressionNode(node, matchers) {
-  if (node.property.type === "Identifier" && matchers.has(node.property.name)) {
-    return node;
+function getMemberPartName(node, part) {
+  return node[part].type === "Identifier" ? node[part].name : undefined;
+}
+
+function getMemberExpressionNode(node, matchers) {
+  const propertyName = getMemberPartName(node, "property");
+
+  if (getMemberPartName(node, "object") === "test") {
+    return propertyName === "step" ? { node, type: "testStep" } : undefined;
   }
+
+  return matchers.has(propertyName) ? { node, type: "expect" } : undefined;
 }
 
-function isValidExpect(node) {
-  const parentType =
+function isValid(node) {
+  const grandparentType =
     node.parent && node.parent.parent && node.parent.parent.type;
 
-  // Don't report on nodes which are already awaited or returned
   return (
-    parentType === "AwaitExpression" ||
-    parentType === "ReturnStatement" ||
-    parentType === "ArrowFunctionExpression"
+    grandparentType === "AwaitExpression" ||
+    grandparentType === "ReturnStatement" ||
+    grandparentType === "ArrowFunctionExpression"
   );
 }
 
@@ -70,28 +77,28 @@ module.exports = {
 
     return {
       MemberExpression(statement) {
-        const node = getPromiseMemberExpressionNode(statement, matchers);
-        if (!node || isValidExpect(node)) return;
+        const result = getMemberExpressionNode(statement, matchers);
 
-        context.report({
-          fix(fixer) {
-            return fixer.insertTextBefore(node, "await ");
-          },
-          messageId: "missingAwait",
-          node,
-        });
+        if (result && !isValid(result.node)) {
+          context.report({
+            fix: (fixer) => fixer.insertTextBefore(result.node, "await "),
+            messageId: result.type,
+            node: result.node,
+          });
+        }
       },
     };
   },
   meta: {
     docs: {
       category: "Possible Errors",
-      description: "Enforce expect-playwright matchers to be awaited.",
+      description: `Identify false positives when async Playwright APIs are not properly awaited.`,
       recommended: true,
     },
     fixable: "code",
     messages: {
-      missingAwait: "expect-playwright matchers must be awaited or returned.",
+      expect: "'expect' matchers must be awaited or returned.",
+      testStep: "'test.step' must be awaited or returned.",
     },
     schema: [
       {

test/missing-playwright-await.spec.js

@@ -9,9 +9,9 @@ RuleTester.setDefaultConfig({
 
 const wrapInTest = (input) => `test('a', async () => { ${input} })`;
 
-const invalid = (code, output, options = []) => ({
+const invalid = (messageId, code, output, options = []) => ({
   code: wrapInTest(code),
-  errors: [{ messageId: "missingAwait" }],
+  errors: [{ messageId }],
   options,
   output: wrapInTest(output),
 });
@@ -25,32 +25,46 @@ const options = [{ customMatchers: ["toBeCustomThing"] }];
 
 new RuleTester().run("missing-playwright-await", rule, {
   invalid: [
-    invalid(`expect(page).toBeChecked()`, `await expect(page).toBeChecked()`),
     invalid(
-      `expect(page).not.toBeEnabled()`,
-      `await expect(page).not.toBeEnabled()`
+      "expect",
+      "expect(page).toBeChecked()",
+      "await expect(page).toBeChecked()"
+    ),
+    invalid(
+      "expect",
+      "expect(page).not.toBeEnabled()",
+      "await expect(page).not.toBeEnabled()"
     ),
 
     // Custom matchers
     invalid(
-      `expect(page).toBeCustomThing(false)`,
-      `await expect(page).toBeCustomThing(false)`,
+      "expect",
+      "expect(page).toBeCustomThing(false)",
+      "await expect(page).toBeCustomThing(false)",
       options
     ),
     invalid(
-      `expect(page).not.toBeCustomThing(true)`,
-      `await expect(page).not.toBeCustomThing(true)`,
+      "expect",
+      "expect(page).not.toBeCustomThing(true)",
+      "await expect(page).not.toBeCustomThing(true)",
       options
     ),
+
+    // test.step
+    invalid(
+      "testStep",
+      "test.step('foo', async () => {})",
+      "await test.step('foo', async () => {})"
+    ),
   ],
   valid: [
-    valid(`await expect(page).toEqualTitle("text")`),
-    valid(`await expect(page).not.toHaveText("text")`),
+    valid('await expect(page).toEqualTitle("text")'),
+    valid('await expect(page).not.toHaveText("text")'),
 
     // Doesn't require an await when returning
-    valid(`return expect(page).toHaveText("text")`),
+    valid('return expect(page).toHaveText("text")'),
     {
-      code: `const a = () => expect(page).toHaveText("text")`,
+      code: 'const a = () => expect(page).toHaveText("text")',
       options,
     },
 
@@ -60,5 +74,8 @@ new RuleTester().run("missing-playwright-await", rule, {
     valid("await expect(page).toBeCustomThing(true)", options),
     valid("await expect(page).toBeCustomThing(true)"),
     valid("expect(page).toBeCustomThing(true)"),
+
+    // test.step
+    valid("await test.step('foo', async () => {})"),
   ],
 });