feat(expect-expect): Support regex patterns (#390)

* updated expect-expect to use regex. Added tests

* remove package.json

* Cleanup

* Cleanup

---------

Co-authored-by: Mark Skelton <[email protected]>

Author: jtgober

docs/rules/expect-expect.md

@@ -35,7 +35,8 @@ test('should work with callbacks/async', async () => {
   "playwright/expect-expect": [
     "error",
     {
-      "assertFunctionNames": ["assertCustomCondition"]
+      "assertFunctionNames": ["assertCustomCondition"],
+      "assertFunctionPatterns": ["^assert.*", "^verify.*"]
     }
   ]
 }
@@ -57,3 +58,30 @@ test('should scroll', async ({ page }) => {
   await assertScrolledToBottom(page)
 })
 ```
+
+### `assertFunctionPatterns`
+
+This array option specifies regular expression patterns that should match
+function names to be considered as asserting functions. This is useful when you
+have multiple assertion functions following a naming convention.
+
+```ts
+/* eslint playwright/expect-expect: ["error", { "assertFunctionPatterns": ["^assert.*", "^verify.*"] }] */
+
+function assertScrolledToBottom(page) {
+  // ...
+}
+
+function verifyPageLoaded(page) {
+  // ...
+}
+
+test('should scroll', async ({ page }) => {
+  await assertScrolledToBottom(page)
+  await verifyPageLoaded(page)
+})
+```
+
+You can use both `assertFunctionNames` and `assertFunctionPatterns` together.
+The rule will consider a function as an assertion if it matches either an exact
+name or a pattern.

src/rules/expect-expect.test.ts

@@ -29,6 +29,16 @@ runRuleTester('expect-expect', rule, {
       name: 'Custom assert function',
       options: [{ assertFunctionNames: ['wayComplexCustomCondition'] }],
     },
+    {
+      code: javascript`
+        test('should fail', async ({ page }) => {
+          await assertCustomCondition(page)
+        })
+      `,
+      errors: [{ messageId: 'noAssertions', type: 'Identifier' }],
+      name: 'Custom assert function pattern mismatch',
+      options: [{ assertFunctionPatterns: ['^verify.*', '^check.*'] }],
+    },
     {
       code: 'it("should pass", () => hi(true).toBeDefined())',
       errors: [{ messageId: 'noAssertions', type: 'Identifier' }],
@@ -110,6 +120,40 @@ runRuleTester('expect-expect', rule, {
       name: 'Custom assert class method',
       options: [{ assertFunctionNames: ['assertCustomCondition'] }],
     },
+    {
+      code: javascript`
+        test('should pass', async ({ page }) => {
+          await verifyElementVisible(page.locator('button'))
+        })
+      `,
+      name: 'Custom assert function matching regex pattern',
+      options: [{ assertFunctionPatterns: ['^verify.*'] }],
+    },
+    {
+      code: javascript`
+        test('should pass', async ({ page }) => {
+          await page.checkTextContent('Hello')
+          await validateUserLoggedIn(page)
+        })
+      `,
+      name: 'Multiple custom assert functions matching different regex patterns',
+      options: [{ assertFunctionPatterns: ['^check.*', '^validate.*'] }],
+    },
+    {
+      code: javascript`
+        test('should pass', async ({ page }) => {
+          await myCustomAssert(page)
+          await anotherAssertion(true)
+        })
+      `,
+      name: 'Mixed string and regex pattern matching',
+      options: [
+        {
+          assertFunctionNames: ['myCustomAssert'],
+          assertFunctionPatterns: ['.*Assertion$'],
+        },
+      ],
+    },
     {
       code: 'it("should pass", () => expect(true).toBeDefined())',
       name: 'Global alias - test',

src/rules/expect-expect.ts

@@ -7,9 +7,14 @@ export default createRule({
   create(context) {
     const options = {
       assertFunctionNames: [] as string[],
+      assertFunctionPatterns: [] as string[],
       ...((context.options?.[0] as Record<string, unknown>) ?? {}),
     }
 
+    const patterns = options.assertFunctionPatterns.map(
+      (pattern) => new RegExp(pattern),
+    )
+
     const unchecked: ESTree.CallExpression[] = []
 
     function checkExpressions(nodes: ESTree.Node[]) {
@@ -24,16 +29,25 @@ export default createRule({
       }
     }
 
+    function matches(node: ESTree.CallExpression) {
+      if (options.assertFunctionNames.some((name) => dig(node.callee, name))) {
+        return true
+      }
+
+      if (patterns.some((pattern) => dig(node.callee, pattern))) {
+        return true
+      }
+
+      return false
+    }
+
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node)
 
         if (call?.type === 'test') {
           unchecked.push(node)
-        } else if (
-          call?.type === 'expect' ||
-          options.assertFunctionNames.find((name) => dig(node.callee, name))
-        ) {
+        } else if (call?.type === 'expect' || matches(node)) {
           const ancestors = context.sourceCode.getAncestors(node)
           checkExpressions(ancestors)
         }
@@ -63,6 +77,10 @@ export default createRule({
             items: [{ type: 'string' }],
             type: 'array',
           },
+          assertFunctionPatterns: {
+            items: [{ type: 'string' }],
+            type: 'array',
+          },
         },
         type: 'object',
       },