Commit 6093d76

get() {

return 0

}

expect(cart.get()).toBe(0)

Instances keep the prototype chain of the implementation class, so its prototype methods are available on instances, and `instanceof` checks against the implementation class pass. See [Mocking Classes](/guide/mocking/classes) for details.

Instances created from a class mock previously inherited from the mock's own empty `prototype`. Methods defined with the regular class syntax were `undefined` on instances, even inside the constructor, and `instanceof` checks against the implementation class failed. This affected [`vi.fn(Dog)`](/api/vi#vi-fn), `vi.spyOn(obj, 'Dog')` with or without a mock implementation, and [`.mockImplementation(class ...)`](/api/mock#mockimplementation).

The mock's `prototype` is now chained to the implementation's prototype as soon as the implementation is set, and kept in sync when it changes, so instances behave like instances of the implementation class:

class Dog {

speak() {

return 'bark!'

}

}

const MockedDog = vi.fn(Dog)

const dog = new MockedDog()

typeof dog.speak // was 'undefined', now 'function'

dog instanceof Dog // was false, now true

dog instanceof MockedDog // true, as before

Object.getPrototypeOf(MockedDog.prototype) // was Object.prototype, now Dog.prototype

Overriding methods on the mock's `prototype` still works and shadows the implementation. [`mockReset`](/api/mock#mockreset) reverts the chain together with the implementation: back to the original class for `vi.fn(Dog)` and `vi.spyOn()`, and to a plain object for `vi.fn()`. See [Mocking Classes](/guide/mocking/classes) for details.

Notice that this class defines its members in two different ways, and the difference matters for mocking:

- `greet` is a class field. The assignment runs during construction, so every instance gets its own copy of the function as its own property.

- `speak`, `isHungry`, and `feed` are prototype methods. They are created once and stored on `Dog.prototype`, an object that all instances share. An instance doesn't have a `speak` property of its own: when you call `dog.speak()`, JavaScript doesn't find `speak` on the instance and continues looking on `Dog.prototype`. Every instance finds the same function there, so `dog.speak === Dog.prototype.speak` is `true`.

We can re-create this class with `vi.fn` (or `vi.spyOn().mockImplementation()`). By defining every method as a class field, each instance gets its own separate mock, which allows checking calls on a single instance:

isHungry = vi.fn(() => false)

You don't have to redefine every method as a class field. Instances keep the prototype chain of the class you pass to `vi.fn`, so prototype methods stay available on instances, both during and after construction, and instances pass `instanceof` checks against that class:

class OriginalDog {

constructor(name) {

this.name = name

}

speak() {

return 'bark!'

}

}

const MockedDog = vi.fn(OriginalDog)

const dog = new MockedDog('Cooper')

dog.speak() // bark!

dog instanceof MockedDog // true

dog instanceof OriginalDog // true

Note that nothing is mocked in this example. Unlike the `speak = vi.fn()` field in the `Dog` example above, the instance doesn't receive its own mock function. `dog.speak` is found through the prototype chain and refers to the original class method (`dog.speak === MockedDog.prototype.speak`), so call assertions throw:

expect(dog.speak).toHaveBeenCalled()

Since every instance finds `speak` on the prototype, you can mock it for all of them at once by assigning a mock there:

MockedDog.prototype.speak = vi.fn(() => 'woof!')

const cooper = new MockedDog('Cooper')

const max = new MockedDog('Max')

cooper.speak() // woof!

max.speak() // woof!

expect(MockedDog.prototype.speak).toHaveBeenCalledTimes(2)

expect(vi.mocked(MockedDog.prototype.speak).mock.contexts).toEqual([cooper, max])

Assigning on `MockedDog.prototype` instead of `OriginalDog.prototype` keeps the original class untouched: the lookup order is `instance` → `MockedDog.prototype` → `OriginalDog.prototype`, so the assigned function shadows the original method. Because instances look the method up on every call rather than keeping a copy, the mock is visible to all of them, even those created before the assignment. The trade-off is that they also share a single call history, unlike class fields, which give every instance its own mock.

::: warning

The mock's `prototype` always follows the current implementation: it is re-pointed when you set a new implementation, when a queued `mockImplementationOnce` class is constructed, and when the mock is reset. If a single mock uses different class implementations, instances created by earlier implementations lose access to their prototype methods once a newer implementation takes over. Own properties assigned in the constructor or via class fields are not affected.

:::

If you want to mock the method of one instance only, use [`vi.spyOn`](/api/vi#vi-spyon). It defines the mock directly on that instance, shadowing the prototype method just for it:

const cooper = new MockedDog('Cooper')

const max = new MockedDog('Max')

vi.spyOn(cooper, 'speak').mockReturnValue('meow!')

cooper.speak() // meow!

max.speak() // bark!, still the original method

expect(cooper.speak).toHaveBeenCalledTimes(1)

When methods are defined as class fields, like in the mocked `Dog` class at the top of this page, every instance already has its own mock, so you can reassign the return value for a specific instance directly:

To mock a non-function property, like `name`, we can use the `vi.spyOn(dog, 'name', 'get')` method. This makes it possible to use spy assertions on the mocked property:

// keep the prototype chain in sync with the implementation the next

// construction will use, so it is correct before any `new` call.

// automocked classes are skipped: their methods are pre-mocked

// on `mock.prototype`

const updateMockPrototype = () => {

if (!options.prototypeMembers?.length) {

reparentMockPrototype(

mock,

config.onceMockImplementations[0]

|| config.mockImplementation

|| originalImplementation,

)

}

}

updateMockPrototype()

updateMockPrototype()

updateMockPrototype()

updateMockPrototype()

updateMockPrototype()

else {

// vi.spyOn() has no mock implementation, chain the original one

updateMockPrototype()

}

const noopImplementation = function () {}

|| noopImplementation

// the prototype chain is already prepared when the implementation

// is registered, but a consumed `mockImplementationOnce` can change

// which implementation this construction uses

if (prototypeMembers.length === 0) {

// eslint-disable-next-line ts/no-use-before-define

reparentMockPrototype(mock, implementation === noopImplementation ? undefined : implementation)

}

function reparentMockPrototype(

mock: Mock<Procedure | Constructable>,

implementation: Procedure | Constructable | undefined,

) {

const mockPrototype = mock.prototype

if (mockPrototype == null) {

return

}

// an implementation without a usable prototype (reset mock, arrow or bound

// function) reverts the chain to `Object.prototype`, the parent every mock

// is created with

const parent = (implementation as Constructable | undefined)?.prototype ?? Object.prototype

if (Object.getPrototypeOf(mockPrototype) !== parent) {

Object.setPrototypeOf(mockPrototype, parent)

}

expect(new Spy()).toBeInstanceOf(MockExample)