fix(unbound-method): ignore inline use of jest.mocked(...) (#1862)

* fix: issue 1800

* fix: issue 1800

* fix: ut

* fix: cr

* fix: ut

Author: eryue0220

src/rules/__tests__/unbound-method.test.ts

@@ -30,6 +30,14 @@ const ConsoleClassAndVariableCode = dedent`
   const console = new Console();
 `;
 
+const ServiceClassAndMethodCode = dedent`
+  class Service {
+    method() {}
+  }
+
+  const service = new Service();
+`;
+
 const toThrowMatchers = [
   'toThrow',
   'toThrowError',
@@ -54,6 +62,19 @@ const validTestCases: string[] = [
   'expect(() => Promise.resolve().then(console.log)).not.toThrow();',
   ...toThrowMatchers.map(matcher => `expect(console.log).not.${matcher}();`),
   ...toThrowMatchers.map(matcher => `expect(console.log).${matcher}();`),
+  // https://github.com/jest-community/eslint-plugin-jest/issues/1800
+  ...[
+    'const parameter = jest.mocked(service.method).mock.calls[0][0];',
+    'const calls = jest.mocked(service.method).mock.calls;',
+    'const lastCall = jest.mocked(service.method).mock.calls[0];',
+    'const mockedMethod = jest.mocked(service.method); const parameter = mockedMethod.mock.calls[0][0];',
+
+    'jest.mocked(service.method).mock;',
+
+    'const mockProp = jest.mocked(service.method).mock;',
+    'const result = jest.mocked(service.method, true);',
+    'jest.mocked(service.method, { shallow: true });',
+  ].map(code => [ServiceClassAndMethodCode, code].join('\n')),
 ];
 
 const invalidTestCases: Array<TSESLint.InvalidTestCase<MessageIds, Options>> = [
@@ -108,6 +129,52 @@ const invalidTestCases: Array<TSESLint.InvalidTestCase<MessageIds, Options>> = [
       },
     ],
   })),
+  // Ensure that accessing .mock on non-jest.mocked() results still reports errors
+  // Note: These cases might not report errors if the base rule doesn't consider
+  // property access as unbound method access, so we'll remove them for now
+  // and focus on cases that should definitely report errors
+  // Ensure that service.method as non-argument still reports errors
+  {
+    code: dedent`
+      ${ServiceClassAndMethodCode}
+
+      const method = service.method;
+      jest.mocked(method);
+    `,
+    errors: [
+      {
+        line: 7,
+        messageId: 'unboundWithoutThisAnnotation',
+      },
+    ],
+  },
+  // Ensure that regular unbound method access still reports errors
+  {
+    code: dedent`
+      ${ServiceClassAndMethodCode}
+
+      const method = service.method;
+    `,
+    errors: [
+      {
+        line: 7,
+        messageId: 'unboundWithoutThisAnnotation',
+      },
+    ],
+  },
+  {
+    code: dedent`
+      ${ServiceClassAndMethodCode}
+
+      Promise.resolve().then(service.method);
+    `,
+    errors: [
+      {
+        line: 7,
+        messageId: 'unboundWithoutThisAnnotation',
+      },
+    ],
+  },
   // toThrow matchers call the expected value (which is expected to be a function)
   ...toThrowMatchers.map(matcher => ({
     code: dedent`
@@ -196,6 +263,7 @@ const arith = {
 ${code}
   `;
 }
+
 function addContainsMethodsClassInvalid(
   code: string[],
 ): Array<TSESLint.InvalidTestCase<MessageIds, Options>> {

src/rules/unbound-method.ts

@@ -8,6 +8,7 @@ import {
   findTopMostCallExpression,
   getAccessorValue,
   isIdentifier,
+  isSupportedAccessor,
   parseJestFnCall,
 } from './utils';
 
@@ -73,10 +74,36 @@ export default createRule<Options, MessageIds>({
       return {};
     }
 
+    /**
+     * Checks if a MemberExpression is an argument to a `jest.mocked()` call.
+     * This handles cases like `jest.mocked(service.method)` where `service.method`
+     * should not be flagged as an unbound method.
+     */
+    const isArgumentToJestMocked = (
+      node: TSESTree.MemberExpression,
+    ): boolean => {
+      // Check if the immediate parent is a CallExpression
+      if (node.parent?.type !== AST_NODE_TYPES.CallExpression) {
+        return false;
+      }
+
+      const parentCall = node.parent;
+
+      return (
+        parentCall.callee.type === AST_NODE_TYPES.MemberExpression &&
+        isSupportedAccessor(parentCall.callee.object, 'jest') &&
+        isSupportedAccessor(parentCall.callee.property, 'mocked')
+      );
+    };
+
     return {
       ...baseSelectors,
       MemberExpression(node: TSESTree.MemberExpression): void {
-        if (node.parent.type === AST_NODE_TYPES.CallExpression) {
+        if (isArgumentToJestMocked(node)) {
+          return;
+        }
+
+        if (node.parent?.type === AST_NODE_TYPES.CallExpression) {
           const jestFnCall = parseJestFnCall(
             findTopMostCallExpression(node.parent),
             context,