[Bug]: Constructing a mocked class does not return an object typed as a mock, but rather one typed with the original class' type

[ollien]

Version

jest 29.6.4 / jest-mock 29.6.3

Steps to reproduce

1. Clone this test repo https://github.com/ollien/jest-mock-typing-repro
2. Run npm ci
3. Run npx jest, and watch the compilation fail

Expected behavior

Given the following snippet (in the repo, but I am duplicating it here for posterity's sake)

import { MockedObject, ModuleMocker } from 'jest-mock';

class Foo {
  bar() {}
}

const moduleMocker = new ModuleMocker(global);

test('my code works', () => {
  const mockMetadata = moduleMocker.getMetadata(Foo)!;
  const mockClass = moduleMocker.generateFromMetadata(mockMetadata);
  const x: MockedObject<Foo> = new mockClass();
})

I would expect to be able to assign the mocked class to x, as this is what the type signatures imply (and behavior is in reality).

Actual behavior

The code fails to compile, with an error that the class Foo is not assignable to MockedObject<Foo>

$ npx jest
ts-jest[config] (WARN) message TS151001: If you have issues related to imports, you should consider setting `esModuleInterop` to `true` in your TypeScript configuration file (usually `tsconfig.json`). See https://blogs.msdn.microsoft.com/typescript/2018/01/31/announcing-typescript-2-7/#easier-ecmascript-module-interoperability for more information.
 FAIL  ./test.spec.ts
  ● Test suite failed to run

    test.spec.ts:12:9 - error TS2322: Type 'Foo' is not assignable to type 'MockedObject<Foo>'.
      Type 'Foo' is not assignable to type '{ bar: MockedFunction<() => void>; }'.
        Types of property 'bar' are incompatible.
          Type '() => void' is not assignable to type 'MockedFunction<() => void>'.
            Type '() => void' is not assignable to type 'MockInstance<() => void>'.

    12   const x: MockedObject<Foo> = new mockClass();
               ~

Test Suites: 1 failed, 1 total
Tests:       0 total
Snapshots:   0 total
Time:        1.504 s

Additional context

As a preface: I'm fairly sure I'm using ModuleMocker.generateFromMetadata properly (mostly due to the way this test is written), but it's entirely possible I'm missing something.

I've done some digging into the type declarations of what I'm working with. This is why I think what I'm doing should work:

1. generateFromMetadata<T> returns a Mocked<T>.
2. Because I am passing a ClassLike (that is, the class value itself), this resolves to a MockedClass<T>)
3. The definition of MockedClass implies that constructing the class should return a Mocked<InstanceType<T>> (which I believe to be equivalent to a MockObject<T> in this context, but changing the type of x to Mocked<InstanceType<typeof Foo>> fails to compile for the same reason.)

Though I am not certain, I believe (3) is what causes the issue; a class itself is not a function which returns an instance of itself, but rather its constructor is.

Something else of note: if you remove the single method from the class Foo, the above sample does compile.

Environment

System:
    OS: Linux 6.4 Fedora Linux 38 (Thirty Eight)
    CPU: (12) x64 Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz
  Binaries:
    Node: 18.16.1 - /usr/bin/node
    Yarn: 1.22.17 - ~/.local/npm/bin/yarn
    npm: 9.2.0 - ~/.local/npm/bin/npm
  npmPackages:
    jest: ^29.6.4 => 29.6.4 

[mrazauskas]

Thanks for report. Interesting case!

Quick idea: MockedClass type is missing new signature. Trying to construct it with new returns Foo instead of MockInstance<Foo>. (edit: this should be MockInstance, not MockedObject or I missed something?) Fix looks like this:

export type MockedClass<T extends ClassLike> = MockInstance<
  (...args: ConstructorParameters<T>) => Mocked<InstanceType<T>>
> &
+ (new (...args: ConstructorParameters<T>) => MockInstance<InstanceType<T>>) &
  MockedObject<T>;

Not sure if MockedObject<T> should stay here or not? Hm.. Probably it should, but perhaps MockedFunction needs call signature as well? Not sure, here. To figure out I have to live with this a bit more.

This is complex, but fun to play with. Feedback and ideas are more than welcome (;

[ollien]

You'd know better than me, but as an outside observer looking in, I believe that it should be MockedObject, not only a MockInstance, as the latter is (as far as I can tell from the definition), an instance of a mock (the type parameter T seems to refer to a function), while MockedObject seems to be a ... well, mocked object, which gets wrapped by a MockInstance.

That said, I do think that the signature in what you're proposing likely needs to return MockInstance<Mocked<InstanceType<T>>>, so that the instance's properties are also marked as mocks. Not 100%, though.

[mrazauskas]

Ups.. You are right. The initial idea that the return type should be Mocked<InstanceType<T>> seems to be correct. MockInstance is a different thing.

I was reshaping the MockedClass in #13123. Not so long ago, but can’t recall details already. I will look through carefully in few days.

[mrazauskas]

I was trying to fix the typings, but that is rather complicated to figure out. Current type tests are failing, if the change gets implemented as we discussed above. At the moment my time is limited, so I will try to come back later.

Or perhaps someone else would be interested to take a look?

[peanutenthusiast]

Hi, I'd like to take a look into this!

[mrazauskas]

Sure. Give it try!

The typings live in this file: https://github.com/jestjs/jest/blob/main/packages/jest-mock/src/index.ts

To run the type tests: build the library and run test-types. Note that any changes will be visible in test results only after (re)building. Relevant type test files can be found in this directory: https://github.com/jestjs/jest/tree/main/packages/jest-mock/__typetests__