fix: support symbol key method

packages/vitest/src/runtime/mocker.ts

@@ -328,20 +328,26 @@ export class VitestMocker {
           const spyModule = this.spyModule
           if (!spyModule)
             throw this.createError('[vitest] `spyModule` is not defined. This is Vitest error. Please open a new issue with reproduction.')
-          const mock = spyModule.spyOn(newContainer, property).mockImplementation(function (this: any) {
+
+          const primitives = this.primitives
+          const mock = spyModule.spyOn(newContainer, property).mockImplementation(function (this: unknown) {
             // jest reference
             // https://github.com/jestjs/jest/blob/2c3d2409879952157433de215ae0eee5188a4384/packages/jest-mock/src/index.ts#L678-L691
 
             // check constructor call
             if (this instanceof newContainer[property]) {
+              const instance = this as any
               // mock each class instance's method
-              // TODO: more sound way to loop prorotype methods?
-              for (const key in this) {
-                if (typeof this[key] === 'function') {
+              for (const { key } of getAllMockableProperties(instance, false, primitives)) {
+                const value = instance[key]
+                const type = getType(value)
+                const isFunction = type.includes('Function') && typeof value === 'function'
+                if (isFunction) {
                   // TODO: ability to restore?
-                  // mock by delegating calls to original prototype method, which should be also mocked already
-                  const original = this[key]
-                  const _mockInner = spyModule.spyOn(this, key).mockImplementation((...args: any[]) => original.apply(this, args))
+                  // mock and delegate calls to original prototype method, which should be also mocked already
+                  const original = instance[key]
+                  // TODO: fix type error for symbol key?
+                  spyModule.spyOn(instance, key as string).mockImplementation((...args: any[]) => original.apply(this, args))
                 }
               }
             }

test/core/src/mockedE.ts

@@ -1,5 +1,11 @@
+export const symbolFn = Symbol.for('symbolFn')
+
 export class MockedE {
   public testFn(arg: string) {
     return arg.repeat(2)
   }
+
+  public [symbolFn](arg: string) {
+    return arg.repeat(2)
+  }
 }

test/core/test/mocked-class.test.ts

@@ -1,6 +1,6 @@
 import { expect, test, vi } from 'vitest'
 
-import { MockedE } from '../src/mockedE'
+import { MockedE, symbolFn } from '../src/mockedE'
 
 vi.mock('../src/mockedE')
 
@@ -87,4 +87,29 @@ test(`each instance's methods of mocked class should have independent mock funct
       ],
     ]
   `)
+
+  // test same things for symbol key method
+  expect(instance1[symbolFn]).not.toBe(instance2[symbolFn])
+  expect(instance1[symbolFn]).not.toBe(MockedE.prototype[symbolFn])
+  expect(vi.mocked(instance1[symbolFn]).mock).not.toBe(vi.mocked(instance2[symbolFn]).mock)
+
+  instance1[symbolFn]('d')
+  expect(instance1[symbolFn]).toBeCalledTimes(1)
+  expect(instance2[symbolFn]).toBeCalledTimes(0)
+  expect(MockedE.prototype[symbolFn]).toBeCalledTimes(1)
+  expect(vi.mocked(instance1[symbolFn]).mock.calls).toMatchInlineSnapshot(`
+    [
+      [
+        "d",
+      ],
+    ]
+  `)
+  expect(vi.mocked(instance2[symbolFn]).mock.calls).toMatchInlineSnapshot(`[]`)
+  expect(vi.mocked(MockedE.prototype[symbolFn]).mock.calls).toMatchInlineSnapshot(`
+    [
+      [
+        "d",
+      ],
+    ]
+  `)
 })