I would be very interested in this feature !!

In my particular case, I'm using Vitest to unit test Vue.js components. And I often need to instanciate a class to provide a mock to components that use inject. At the moment, I'm forced to use workarounds like the one suggested by @everett1992.

It would also be very useful to be able to retrieve the mocked methods of this mocked class instance, to specify a behaviour if needed, depending on the test case.

import { Class } from 'module'
vi.mock('module')
// @ts-ignore-error Ignore constructor argument errors
const mockInstance  = new Class()

mockInstance.someMethod.mockReturnValue('mocked value');
expect(mockInstance.someMethod).toHaveBeenCalled();

Is this already possible with vi.importMock? This should return "automock"-ed module without actually setting up module mocking. I made a simple example here:

https://stackblitz.com/edit/vitest-dev-vitest-hnt4sl?file=src%2Fsome.test.ts

//
// some.test.ts
//
import { vi, test, expect } from 'vitest';

test('repro', async () => {
  const { SomeClass } = await vi.importMock<typeof import('./some-class')>('./some-class');

  const someInstance = new SomeClass();

  // type check works
  vi.mocked(someInstance.someMethod).mockReturnValue('hello');
  expect(someInstance.someMethod(1234)).toMatchInlineSnapshot(`"hello"`);
});


//
// some-class.ts
//
export class SomeClass {
  someMethod(x: number) {
    return String(x);
  }
}

I see. Your concern was the type error on construction. Then I'm not sure if it's really important features to just help silencing type errors.
Do you see more on this feature other than type errors?

EDIT: Well, I actually thought it would be a neat feature if we can expose mockObject utility for users to easily simulate automock without concerned with modules.

Is this already possible with vi.importMock? This should return "automock"-ed module without actually setting up module mocking. I made a simple example here:

https://stackblitz.com/edit/vitest-dev-vitest-hnt4sl?file=src%2Fsome.test.ts

//
// some.test.ts
//
import { vi, test, expect } from 'vitest';

test('repro', async () => {
  const { SomeClass } = await vi.importMock<typeof import('./some-class')>('./some-class');

  const someInstance = new SomeClass();

  // type check works
  vi.mocked(someInstance.someMethod).mockReturnValue('hello');
  expect(someInstance.someMethod(1234)).toMatchInlineSnapshot(`"hello"`);
});


//
// some-class.ts
//
export class SomeClass {
  someMethod(x: number) {
    return String(x);
  }
}

I get this error while trying to instanciate the class your way :

This expression is not constructable.
  Type 'Promise<MockedObjectDeep<typeof import("...")>>' has no construct signatures.ts(2351)

The class is the only and default export of the module (single file class).

Ok, it works this way :

//
// some.test.ts
//
import { vi, test, expect } from 'vitest';

test('repro', async () => {
  const SomeClass = (await vi.importMock<typeof import('./SomeClass')>('./SomeClass')).default;

  const someInstance = new SomeClass();

  // type check works
  vi.mocked(someInstance.someMethod).mockReturnValue('hello');
  expect(someInstance.someMethod(1234)).toMatchInlineSnapshot(`"hello"`);
});


//
// SomeClass.ts
//
export default class SomeClass {
  someMethod(x: number) {
    return String(x);
  }
}

Thx for the tip @hi-ogawa !!

I see. Your concern was the type error on construction. Then I'm not sure if it's really important features to just help silencing type errors. Do you see more on this feature other than type errors?

EDIT: Well, I actually thought it would be a neat feature if we can expose mockObject utility for users to easily simulate automock without concerned with modules.

vitest/packages/vitest/src/runtime/mocker.ts

Line 282 in c84113f

public mockObject(object: Record<Key, any>, mockExports: Record<Key, any> = {}) {

👍

We can expose something like this:

const SomeClass = vi.mockObject(OriginalClass) 
const instance = new SomeClass() // Mock<OriginalClass>
expect(SomeClass).toHaveBeenCalled()