feat: Support test.expect style

Fixes #297

src/rules/expect-expect.test.ts

@@ -46,6 +46,7 @@ runRuleTester('expect-expect', rule, {
     '["bar"]();',
     'testing("will test something eventually", () => {})',
     'test("should pass", () => expect(true).toBeDefined())',
+    'test("should pass", () => test.expect(true).toBeDefined())',
     'test.slow("should pass", () => expect(true).toBeDefined())',
     'test.skip("should pass", () => expect(true).toBeDefined())',
     // Config methods

src/utils/ast.ts

@@ -19,9 +19,12 @@ export function getRawValue(node: ESTree.Node) {
   return node.type === 'Literal' ? node.raw : undefined
 }
 
-export function isIdentifier(node: ESTree.Node, name?: string | RegExp) {
+export function isIdentifier(
+  node: ESTree.Node | undefined,
+  name?: string | RegExp,
+) {
   return (
-    node.type === 'Identifier' &&
+    node?.type === 'Identifier' &&
     (!name ||
       (typeof name === 'string' ? node.name === name : name.test(node.name)))
   )

src/utils/parseFnCall.test.ts

@@ -464,6 +464,32 @@ runRuleTester('expect', rule, {
       `,
       errors: [{ column: 1, line: 3, messageId: 'modifier-unknown' }],
     },
+    {
+      code: 'test.expect(x).toBe(y);',
+      errors: [
+        {
+          column: 1,
+          data: expectedParsedFnCallResultData({
+            args: ['x'],
+            group: 'expect',
+            head: {
+              local: 'test',
+              node: 'test',
+              original: null,
+            },
+            matcher: 'toBe',
+            matcherArgs: ['y'],
+            matcherName: 'toBe',
+            members: ['toBe'],
+            modifiers: [],
+            name: 'expect',
+            type: 'expect',
+          }),
+          line: 1,
+          messageId: 'details',
+        },
+      ],
+    },
   ],
   valid: [],
 })

src/utils/parseFnCall.ts

@@ -329,10 +329,6 @@ function parse(
   let name = resolved.original ?? resolved.local
   const links = [name, ...rest.map((link) => getStringValue(link))]
 
-  if (name !== 'expect' && !VALID_CHAINS.has(links.join('.'))) {
-    return null
-  }
-
   // To support Playwright's convention of `test.describe`, `test.beforeEach`,
   // etc. we need to test the second link in the chain to find the true type.
   if (name === 'test' && links.length > 1) {
@@ -344,6 +340,10 @@ function parse(
     }
   }
 
+  if (name !== 'expect' && !VALID_CHAINS.has(links.join('.'))) {
+    return null
+  }
+
   const parsedFnCall: Omit<ParsedFnCall, 'group' | 'type'> = {
     head: { ...resolved, node: first },
     // every member node must have a member expression as their parent
@@ -355,6 +355,13 @@ function parse(
   const group = determinePlaywrightFnGroup(name)
 
   if (group === 'expect') {
+    // If using `test.expect` style, the `rest` array will start with `expect`
+    // and we need to remove it to ensure the chain accurately represents the
+    // `expect` call chain.
+    if (isIdentifier(rest[0], 'expect')) {
+      parsedFnCall.members.shift()
+    }
+
     const result = parseExpectCall(parsedFnCall)
 
     // If the `expect` call chain is not valid, only report on the topmost node