fix(spy): preserve class mock prototype methods

packages/spy/src/index.ts

@@ -500,6 +500,23 @@ function createMock(
       try {
         if (new.target) {
           returnValue = Reflect.construct(implementation, args, new.target)
+          const implementationPrototype = (implementation as any).prototype
+          if (
+            // prototypeMembers is used by automocking case and we want to skip that case.
+            prototypeMembers.length === 0
+            && new.target.prototype
+            && implementationPrototype
+            // skip when constructor returns value
+            && Object.getPrototypeOf(returnValue) === new.target.prototype
+          ) {
+            const { properties, descriptors } = getAllProperties(implementationPrototype)
+            for (const property of properties) {
+              if (property === 'constructor' || property in returnValue) {
+                continue
+              }
+              Object.defineProperty(returnValue, property, descriptors[property]!)
+            }
+          }
 
           // jest calls this before the implementation, but we have to resolve this _after_
           // because we cannot do it before the `Reflect.construct` called the custom implementation.

test/unit/test/mocking/vi-fn.test.ts

@@ -799,6 +799,56 @@
     expect(Mock.mock.calls).toEqual([['test', 42]])
   })
 
+  test('vi.fn(class) exposes prototype methods on constructed instances', () => {
+    const Mock = vi.fn(class {
+      method() {
+        return 'mocked'
+      }
+    })
+
+    expect(new Mock().method()).toBe('mocked')
+  })
+
+  test('vi.fn(class) does not copy prototype methods when constructor returns an object', () => {
+    const returned = { custom: true }
+    const Mock = vi.fn(class {
+      constructor() {
+        return returned as any
+      }
+
+      method() {
+        return 'mocked'
+      }
+    })
+
+    const instance = new Mock()
+
+    expect(instance).toBe(returned)
+    expect(instance.method).toBeUndefined()
+  })
+
+  test('vi.fn(class) does not leak prototype methods from once implementations', () => {
+    const Mock = vi.fn()
+      .mockImplementationOnce(class {
+        first() {
+          return 'first'
+        }
+      })
+      .mockImplementation(class {
+        second() {
+          return 'second'
+        }
+      })
+
+    const first = new Mock()
+    const second = new Mock()
+
+    expect(first.first()).toBe('first')
+    expect(first.second).toBeUndefined()
+    expect(second.second()).toBe('second')
+    expect(second.first).toBeUndefined()
+  })
+
   test('vi.fn() with mockReturnValue throws when called with new', () => {
     const Mock = vi.fn()
     Mock.mockReturnValue(42)

test/unit/test/mocking/vi-spyOn.test.ts

@@ -262,6 +262,23 @@ describe('vi.spyOn() state', () => {
     assertStateEmpty(state)
   })
 
+  test('vi.spyOn() exposes mockImplementation class prototype methods', () => {
+    class OriginalClass {
+      method() {
+        return 'original'
+      }
+    }
+    const object = { Class: OriginalClass }
+
+    vi.spyOn(object, 'Class').mockImplementation(class MockClass extends OriginalClass {
+      method() {
+        return 'mocked'
+      }
+    })
+
+    expect(new object.Class().method()).toBe('mocked')
+  })
+
   test('vi.spyOn() spies and tracks overridden async calls', async () => {
     const object = createObject()
     const mock = vi.spyOn(object, 'async')