fix: independently mock each instance's methods for mocked class

packages/vitest/src/runtime/mocker.ts

@@ -328,7 +328,29 @@ 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(() => undefined)
+
+ const primitives = this.primitives
+ const mock = spyModule.spyOn(newContainer, property).mockImplementation(function (this: any) {
+ // 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]) {
+ // mock each mothod of mocked class instance
+ for (const { key } of getAllMockableProperties(this, false, primitives)) {
+ const value = this[key]
+ const type = getType(value)
+ const isFunction = type.includes('Function') && typeof value === 'function'
+ if (isFunction) {
+ // TODO: ability to restore?
+ // mock and delegate calls to original prototype method, which should be also mocked already
+ const original = this[key]
+ // TODO: fix type error for symbol key?
+ spyModule.spyOn(this, key as string).mockImplementation((...args: any[]) => original.apply(this, args))
+ }
+ }
+ }
+ })
  mock.mockRestore = () => {
  mock.mockReset()
  mock.mockImplementation(() => undefined)

test/core/src/mockedE.ts

@@ -0,0 +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

@@ -0,0 +1,115 @@
+import { expect, test, vi } from 'vitest'
+
+import { MockedE, symbolFn } from '../src/mockedE'
+
+vi.mock('../src/mockedE')
+
+test(`each instance's methods of mocked class should have independent mock function state`, () => {
+ const instance1 = new MockedE()
+ const instance2 = new MockedE()
+ expect(instance1).not.toBe(instance2)
+ expect(instance1.testFn).not.toBe(instance2.testFn)
+ expect(instance1.testFn).not.toBe(MockedE.prototype.testFn)
+ expect(vi.mocked(instance1.testFn).mock).not.toBe(vi.mocked(instance2.testFn).mock)
+
+ instance1.testFn('a')
+ expect(instance1.testFn).toBeCalledTimes(1)
+ expect(instance2.testFn).toBeCalledTimes(0)
+ expect(MockedE.prototype.testFn).toBeCalledTimes(1)
+ expect(vi.mocked(instance1.testFn).mock.calls).toMatchInlineSnapshot(`
+ [
+ [
+ "a",
+ ],
+ ]
+ `)
+ expect(vi.mocked(MockedE.prototype.testFn).mock.calls).toMatchInlineSnapshot(`
+ [
+ [
+ "a",
+ ],
+ ]
+ `)
+
+ instance2.testFn('b')
+ expect(instance1.testFn).toBeCalledTimes(1)
+ expect(instance2.testFn).toBeCalledTimes(1)
+ expect(MockedE.prototype.testFn).toBeCalledTimes(2)
+ expect(vi.mocked(instance2.testFn).mock.calls).toMatchInlineSnapshot(`
+ [
+ [
+ "b",
+ ],
+ ]
+ `)
+ expect(vi.mocked(MockedE.prototype.testFn).mock.calls).toMatchInlineSnapshot(`
+ [
+ [
+ "a",
+ ],
+ [
+ "b",
+ ],
+ ]
+ `)
+
+ instance1.testFn('c')
+ expect(instance1.testFn).toBeCalledTimes(2)
+ expect(instance2.testFn).toBeCalledTimes(1)
+ expect(MockedE.prototype.testFn).toBeCalledTimes(3)
+ expect(vi.mocked(instance1.testFn).mock.calls).toMatchInlineSnapshot(`
+ [
+ [
+ "a",
+ ],
+ [
+ "c",
+ ],
+ ]
+ `)
+ expect(vi.mocked(instance2.testFn).mock.calls).toMatchInlineSnapshot(`
+ [
+ [
+ "b",
+ ],
+ ]
+ `)
+ expect(vi.mocked(MockedE.prototype.testFn).mock.calls).toMatchInlineSnapshot(`
+ [
+ [
+ "a",
+ ],
+ [
+ "b",
+ ],
+ [
+ "c",
+ ],
+ ]
+ `)
+
+ // 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",
+ ],
+ ]
+ `)
+})