From b16cfc61f9967efca76f5339247731494b9c302d Mon Sep 17 00:00:00 2001
From: mrazauskas <72159681+mrazauskas@users.noreply.github.com>
Date: Sun, 20 Feb 2022 21:22:37 +0200
Subject: [PATCH 1/9] add type tests for jest object

---
 packages/jest-environment/src/index.ts        |  17 +-
 packages/jest-mock/src/index.ts               |  65 ++--
 .../jest-types/__typetests__/jest.test.ts     | 305 +++++++++++++++---
 3 files changed, 304 insertions(+), 83 deletions(-)

diff --git a/packages/jest-environment/src/index.ts b/packages/jest-environment/src/index.ts
index 5f589c7e9b93..01695b50fb5a 100644
--- a/packages/jest-environment/src/index.ts
+++ b/packages/jest-environment/src/index.ts
@@ -8,12 +8,7 @@
 import type {Context} from 'vm';
 import type {LegacyFakeTimers, ModernFakeTimers} from '@jest/fake-timers';
 import type {Circus, Config, Global} from '@jest/types';
-import type {
-  fn as JestMockFn,
-  mocked as JestMockMocked,
-  spyOn as JestMockSpyOn,
-  ModuleMocker,
-} from 'jest-mock';
+import type {ModuleMocker} from 'jest-mock';
 
 export type EnvironmentContext = {
   console: Console;
@@ -110,7 +105,7 @@ export interface Jest {
   /**
    * Creates a mock function. Optionally takes a mock implementation.
    */
-  fn: typeof JestMockFn;
+  fn: ModuleMocker['fn'];
   /**
    * Given the name of a module, use the automatic mocking system to generate a
    * mocked version of the module for you.
@@ -132,9 +127,7 @@ export interface Jest {
   /**
    * Determines if the given function is a mocked function.
    */
-  isMockFunction(
-    fn: (...args: Array<any>) => unknown,
-  ): fn is ReturnType<typeof JestMockFn>;
+  isMockFunction: ModuleMocker['isMockFunction'];
   /**
    * Mocks a module with an auto-mocked version when it is being required.
    */
@@ -196,7 +189,7 @@ export interface Jest {
    * jest.spyOn; other mocks will require you to manually restore them.
    */
   restoreAllMocks(): Jest;
-  mocked: typeof JestMockMocked;
+  mocked: ModuleMocker['mocked'];
   /**
    * Runs failed tests n-times until they pass or until the max number of
    * retries is exhausted. This only works with `jest-circus`!
@@ -259,7 +252,7 @@ export interface Jest {
    * Note: By default, jest.spyOn also calls the spied method. This is
    * different behavior from most other test libraries.
    */
-  spyOn: typeof JestMockSpyOn;
+  spyOn: ModuleMocker['spyOn'];
   /**
    * Indicates that the module system should never return a mocked version of
    * the specified module from require() (e.g. that it should always return the
diff --git a/packages/jest-mock/src/index.ts b/packages/jest-mock/src/index.ts
index bd3e3e11c809..a7d333722788 100644
--- a/packages/jest-mock/src/index.ts
+++ b/packages/jest-mock/src/index.ts
@@ -32,6 +32,14 @@ export type MockFunctionMetadata<
   length?: number;
 };
 
+type ClassLike = {
+  new (...args: Array<any>): any;
+};
+
+type ObjectLike = {
+  [key: string]: any;
+};
+
 export type MockableFunction = (...args: Array<any>) => any;
 export type MethodKeysOf<T> = {
   [K in keyof T]: T[K] extends MockableFunction ? K : never;
@@ -79,6 +87,9 @@ export type MaybeMocked<T> = T extends MockableFunction
   : T;
 
 export type ArgsType<T> = T extends (...args: infer A) => any ? A : never;
+type ConstructorArgsType<T> = T extends new (...args: infer A) => any
+  ? A
+  : never;
 export type Mocked<T> = {
   [P in keyof T]: T[P] extends (...args: Array<any>) => any
     ? MockInstance<ReturnType<T[P]>, ArgsType<T[P]>>
@@ -192,6 +203,10 @@ type FunctionPropertyNames<T> = {
   [K in keyof T]: T[K] extends (...args: Array<any>) => any ? K : never;
 }[keyof T] &
   string;
+type ConstructorPropertyNames<T> = {
+  [K in keyof T]: T[K] extends new (...args: Array<any>) => any ? K : never;
+}[keyof T] &
+  string;
 
 const MOCK_CONSTRUCTOR_NAME = 'mockConstructor';
 
@@ -988,6 +1003,10 @@ export class ModuleMocker {
     return metadata;
   }
 
+  isMockFunction<T, Y extends Array<unknown> = Array<unknown>>(
+    fn: (...args: Y) => T,
+  ): fn is Mock<T, Y>;
+  isMockFunction(fn: unknown): boolean;
   isMockFunction<T>(fn: unknown): fn is Mock<T> {
     return !!fn && (fn as any)._isMockFunction === true;
   }
@@ -1003,19 +1022,27 @@ export class ModuleMocker {
     return fn;
   }
 
-  spyOn<T extends {}, M extends NonFunctionPropertyNames<T>>(
-    object: T,
-    methodName: M,
-    accessType: 'get',
-  ): SpyInstance<T[M], []>;
+  spyOn<
+    T extends ClassLike | ObjectLike,
+    M extends NonFunctionPropertyNames<T>,
+  >(object: T, methodName: M, accessType: 'get'): SpyInstance<T[M], []>;
 
-  spyOn<T extends {}, M extends NonFunctionPropertyNames<T>>(
+  spyOn<
+    T extends ClassLike | ObjectLike,
+    M extends NonFunctionPropertyNames<T>,
+  >(object: T, methodName: M, accessType: 'set'): SpyInstance<void, [T[M]]>;
+
+  spyOn<
+    T extends ClassLike | ObjectLike,
+    M extends ConstructorPropertyNames<Required<T>>,
+  >(
     object: T,
-    methodName: M,
-    accessType: 'set',
-  ): SpyInstance<void, [T[M]]>;
+    method: M,
+  ): T[M] extends new (...args: Array<any>) => any
+    ? SpyInstance<InstanceType<T[M]>, ConstructorArgsType<T[M]>>
+    : never;
 
-  spyOn<T extends {}, M extends FunctionPropertyNames<T>>(
+  spyOn<T extends ClassLike | ObjectLike, M extends FunctionPropertyNames<T>>(
     object: T,
     methodName: M,
   ): T[M] extends (...args: Array<any>) => any
@@ -1023,11 +1050,10 @@ export class ModuleMocker {
     : never;
 
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  spyOn<T extends {}, M extends NonFunctionPropertyNames<T>>(
-    object: T,
-    methodName: M,
-    accessType?: 'get' | 'set',
-  ) {
+  spyOn<
+    T extends ClassLike | ObjectLike,
+    M extends NonFunctionPropertyNames<T>,
+  >(object: T, methodName: M, accessType?: 'get' | 'set') {
     if (accessType) {
       return this._spyOnProperty(object, methodName, accessType);
     }
@@ -1094,11 +1120,10 @@ export class ModuleMocker {
     return object[methodName];
   }
 
-  private _spyOnProperty<T extends {}, M extends NonFunctionPropertyNames<T>>(
-    obj: T,
-    propertyName: M,
-    accessType: 'get' | 'set' = 'get',
-  ): Mock<T> {
+  private _spyOnProperty<
+    T extends ClassLike | ObjectLike,
+    M extends NonFunctionPropertyNames<T>,
+  >(obj: T, propertyName: M, accessType: 'get' | 'set' = 'get'): Mock<T> {
     if (typeof obj !== 'object' && typeof obj !== 'function') {
       throw new Error(
         'Cannot spyOn on a primitive value; ' + this._typeOf(obj) + ' given',
diff --git a/packages/jest-types/__typetests__/jest.test.ts b/packages/jest-types/__typetests__/jest.test.ts
index 3f5478f524ad..dcbb2e9f7acf 100644
--- a/packages/jest-types/__typetests__/jest.test.ts
+++ b/packages/jest-types/__typetests__/jest.test.ts
@@ -7,89 +7,292 @@
 
 import {expectError, expectType} from 'tsd-lite';
 import {jest} from '@jest/globals';
-import type {Mock} from 'jest-mock';
+import type {Mock, SpyInstance} from 'jest-mock';
+
+expectType<typeof jest>(
+  jest
+    .autoMockOff()
+    .autoMockOn()
+    .clearAllMocks()
+    .disableAutomock()
+    .enableAutomock()
+    .deepUnmock('moduleName')
+    .doMock('moduleName')
+    .doMock('moduleName', jest.fn())
+    .doMock('moduleName', jest.fn(), {})
+    .doMock('moduleName', jest.fn(), {virtual: true})
+    .dontMock('moduleName')
+    .isolateModules(() => {})
+    .mock('moduleName')
+    .mock('moduleName', jest.fn())
+    .mock('moduleName', jest.fn(), {})
+    .mock('moduleName', jest.fn(), {virtual: true})
+    .unstable_mockModule('moduleName', jest.fn())
+    .unstable_mockModule('moduleName', () => Promise.resolve(jest.fn()))
+    .unstable_mockModule('moduleName', jest.fn(), {})
+    .unstable_mockModule('moduleName', () => Promise.resolve(jest.fn()), {})
+    .unstable_mockModule('moduleName', jest.fn(), {virtual: true})
+    .unstable_mockModule('moduleName', () => Promise.resolve(jest.fn()), {
+      virtual: true,
+    })
+    .resetAllMocks()
+    .resetModules()
+    .restoreAllMocks()
+    .retryTimes(3)
+    .setMock('moduleName', {a: 'b'})
+    .setTimeout(6000)
+    .unmock('moduleName')
+    .useFakeTimers()
+    .useFakeTimers('modern')
+    .useFakeTimers('legacy')
+    .useRealTimers(),
+);
 
 expectType<typeof jest>(jest.autoMockOff());
+expectError(jest.autoMockOff(true));
+
 expectType<typeof jest>(jest.autoMockOn());
-expectType<typeof jest>(jest.clearAllMocks());
-expectType<void>(jest.clearAllTimers());
-expectType<typeof jest>(jest.resetAllMocks());
-expectType<typeof jest>(jest.restoreAllMocks());
-expectType<void>(jest.clearAllTimers());
+expectError(jest.autoMockOn(false));
+
+expectType<unknown>(jest.createMockFromModule('moduleName'));
+expectError(jest.createMockFromModule());
+
 expectType<typeof jest>(jest.deepUnmock('moduleName'));
-expectType<typeof jest>(jest.disableAutomock());
+expectError(jest.deepUnmock());
+
 expectType<typeof jest>(jest.doMock('moduleName'));
 expectType<typeof jest>(jest.doMock('moduleName', jest.fn()));
 expectType<typeof jest>(jest.doMock('moduleName', jest.fn(), {}));
 expectType<typeof jest>(jest.doMock('moduleName', jest.fn(), {virtual: true}));
+expectError(jest.doMock());
 
 expectType<typeof jest>(jest.dontMock('moduleName'));
+expectError(jest.dontMock());
+
+expectType<typeof jest>(jest.disableAutomock());
+expectError(jest.disableAutomock(true));
+
 expectType<typeof jest>(jest.enableAutomock());
+expectError(jest.enableAutomock('moduleName'));
+
+expectType<typeof jest>(jest.isolateModules(() => {}));
+expectError(jest.isolateModules());
+
 expectType<typeof jest>(jest.mock('moduleName'));
 expectType<typeof jest>(jest.mock('moduleName', jest.fn()));
 expectType<typeof jest>(jest.mock('moduleName', jest.fn(), {}));
 expectType<typeof jest>(jest.mock('moduleName', jest.fn(), {virtual: true}));
-expectType<typeof jest>(jest.resetModules());
-expectType<typeof jest>(jest.isolateModules(() => {}));
-expectType<typeof jest>(jest.retryTimes(3));
-expectType<Mock<Promise<string>, []>>(
-  jest
-    .fn(() => Promise.resolve('string value'))
-    .mockResolvedValueOnce('A string, not a Promise'),
+expectError(jest.mock());
+
+expectType<typeof jest>(jest.unstable_mockModule('moduleName', jest.fn()));
+expectType<typeof jest>(
+  jest.unstable_mockModule('moduleName', () => Promise.resolve(jest.fn())),
 );
-expectType<Mock<Promise<string>, []>>(
-  jest
-    .fn(() => Promise.resolve('string value'))
-    .mockResolvedValue('A string, not a Promise'),
+expectType<typeof jest>(jest.unstable_mockModule('moduleName', jest.fn(), {}));
+expectType<typeof jest>(
+  jest.unstable_mockModule('moduleName', () => Promise.resolve(jest.fn()), {}),
 );
-expectType<Mock<Promise<string>, []>>(
-  jest
-    .fn(() => Promise.resolve('string value'))
-    .mockRejectedValueOnce(new Error('An error, not a string')),
+expectType<typeof jest>(
+  jest.unstable_mockModule('moduleName', jest.fn(), {virtual: true}),
 );
-expectType<Mock<Promise<string>, []>>(
-  jest
-    .fn(() => Promise.resolve('string value'))
-    .mockRejectedValue(new Error('An error, not a string')),
+expectType<typeof jest>(
+  jest.unstable_mockModule('moduleName', () => Promise.resolve(jest.fn()), {
+    virtual: true,
+  }),
 );
 
-expectType<void>(jest.runAllImmediates());
-expectType<void>(jest.runAllTicks());
-expectType<void>(jest.runAllTimers());
-expectType<void>(jest.runOnlyPendingTimers());
-expectType<void>(jest.advanceTimersByTime(9001));
+expectType<unknown>(jest.requireActual('./pathToModule'));
+expectError(jest.requireActual());
+
+expectType<unknown>(jest.requireMock('./pathToModule'));
+expectError(jest.requireMock());
+
+expectType<typeof jest>(jest.resetModules());
+expectError(jest.resetModules('moduleName'));
 
-expectType<typeof jest>(jest.setMock('moduleName', {}));
-expectType<typeof jest>(jest.setMock('moduleName', {}));
 expectType<typeof jest>(jest.setMock('moduleName', {a: 'b'}));
-expectType<typeof jest>(jest.setTimeout(9001));
+expectError(jest.setMock('moduleName'));
+
 expectType<typeof jest>(jest.unmock('moduleName'));
-expectType<typeof jest>(jest.useFakeTimers());
-expectType<typeof jest>(jest.useRealTimers());
+expectError(jest.unmock());
+
+// Mock Functions
+
+expectType<typeof jest>(jest.clearAllMocks());
+expectError(jest.clearAllMocks('moduleName'));
+
+expectType<boolean>(jest.isMockFunction(() => {}));
+expectError(jest.isMockFunction());
+
+const maybeMock = (a: string, b: number) => true;
+
+if (jest.isMockFunction(maybeMock)) {
+  expectType<Mock<boolean, [a: string, b: number]>>(maybeMock);
+
+  maybeMock.mockReturnValueOnce(false);
+  expectError(maybeMock.mockReturnValueOnce(123));
+}
+
+if (!jest.isMockFunction(maybeMock)) {
+  expectType<(a: string, b: number) => boolean>(maybeMock);
+}
+
+const surelyMock = jest.fn((a: string, b: number) => true);
+
+if (jest.isMockFunction(surelyMock)) {
+  expectType<Mock<boolean, [a: string, b: number]>>(surelyMock);
+
+  surelyMock.mockReturnValueOnce(false);
+  expectError(surelyMock.mockReturnValueOnce(123));
+}
+
+if (!jest.isMockFunction(surelyMock)) {
+  expectType<never>(surelyMock);
+}
+
+declare const hardlyMockFn: string;
+
+if (!jest.isMockFunction(hardlyMockFn)) {
+  expectType<string>(hardlyMockFn);
+}
+
+if (jest.isMockFunction(hardlyMockFn)) {
+  expectType<string>(hardlyMockFn);
+}
+
+expectType<Mock<unknown>>(jest.fn());
+expectType<Mock<void, []>>(jest.fn(() => {}));
+expectType<Mock<boolean, [a: string, b: number]>>(
+  jest.fn((a: string, b: number) => true),
+);
+expectType<Mock<never, [e: any]>>(
+  jest.fn((e: any) => {
+    throw new Error();
+  }),
+);
+expectError(jest.fn('moduleName'));
+
+expectType<typeof jest>(jest.resetAllMocks());
+expectError(jest.resetAllMocks(true));
+
+expectType<typeof jest>(jest.restoreAllMocks());
+expectError(jest.restoreAllMocks(false));
+
+const spiedArray = ['a', 'b'];
+
+const spiedFunction = () => {};
+
+spiedFunction.toString();
+
+const spiedObject = {
+  _propertyB: false,
+
+  methodA() {
+    return true;
+  },
+  methodB(a: string, b: number) {
+    return;
+  },
+  methodC(e: any) {
+    throw new Error();
+  },
+
+  propertyA: 'abc',
+
+  set propertyB(value) {
+    this._propertyB = value;
+  },
+  get propertyB() {
+    return this._propertyB;
+  },
+};
+
+expectType<SpyInstance<boolean, []>>(jest.spyOn(spiedObject, 'methodA'));
+expectType<SpyInstance<void, [a: string, b: number]>>(
+  jest.spyOn(spiedObject, 'methodB'),
+);
+expectType<SpyInstance<never, [e: any]>>(jest.spyOn(spiedObject, 'methodC'));
+
+expectType<SpyInstance<boolean, []>>(
+  jest.spyOn(spiedObject, 'propertyB', 'get'),
+);
+expectType<SpyInstance<void, [boolean]>>(
+  jest.spyOn(spiedObject, 'propertyB', 'set'),
+);
+expectError(jest.spyOn(spiedObject, 'propertyB'));
+expectError(jest.spyOn(spiedObject, 'methodB', 'get'));
+expectError(jest.spyOn(spiedObject, 'methodB', 'set'));
+
+expectType<SpyInstance<string, []>>(
+  jest.spyOn(spiedObject, 'propertyA', 'get'),
+);
+expectType<SpyInstance<void, [string]>>(
+  jest.spyOn(spiedObject, 'propertyA', 'set'),
+);
+expectError(jest.spyOn(spiedObject, 'propertyA'));
+
+expectError(jest.spyOn(spiedObject, 'notThere'));
+expectError(jest.spyOn(spiedArray as unknown as ArrayConstructor, 'from'));
+expectError(jest.spyOn(spiedFunction as unknown as Function, 'toString')); // eslint-disable-line @typescript-eslint/ban-types
+expectError(jest.spyOn('abc', 'methodA'));
+expectError(jest.spyOn(123, 'methodA'));
+expectError(jest.spyOn(true, 'methodA'));
+expectError(jest.spyOn(spiedObject));
+expectError(jest.spyOn());
+
+expectType<SpyInstance<Date, [value: string | number | Date]>>(
+  jest.spyOn(global, 'Date'),
+);
+expectType<SpyInstance<number, []>>(jest.spyOn(Date, 'now'));
+
+// Mock Timers
+
+expectType<void>(jest.advanceTimersByTime(6000));
+expectError(jest.advanceTimersByTime());
 
 expectType<void>(jest.advanceTimersToNextTimer());
 expectType<void>(jest.advanceTimersToNextTimer(2));
+expectError(jest.advanceTimersToNextTimer('2'));
 
-// https://jestjs.io/docs/jest-object#jestusefaketimersimplementation-modern--legacy
-expectType<typeof jest>(jest.useFakeTimers('modern'));
-expectType<typeof jest>(jest.useFakeTimers('legacy'));
+expectType<void>(jest.clearAllTimers());
+expectError(jest.clearAllTimers(false));
+
+expectType<number>(jest.getTimerCount());
+expectError(jest.getTimerCount(true));
+
+expectType<number>(jest.getRealSystemTime());
+expectError(jest.getRealSystemTime(true));
+
+expectType<void>(jest.runAllImmediates());
+expectError(jest.runAllImmediates(true));
+
+expectType<void>(jest.runAllTicks());
+expectError(jest.runAllTicks(true));
 
-expectError(jest.useFakeTimers('foo'));
+expectType<void>(jest.runAllTimers());
+expectError(jest.runAllTimers(false));
+
+expectType<void>(jest.runOnlyPendingTimers());
+expectError(jest.runOnlyPendingTimers(true));
 
-// https://jestjs.io/docs/jest-object#jestsetsystemtimenow-number--date
 expectType<void>(jest.setSystemTime());
-expectType<void>(jest.setSystemTime(0));
-expectType<void>(jest.setSystemTime(new Date(0)));
+expectType<void>(jest.setSystemTime(1483228800000));
+expectType<void>(jest.setSystemTime(Date.now()));
+expectType<void>(jest.setSystemTime(new Date(1995, 11, 17)));
+expectError(jest.setSystemTime('1995-12-17T03:24:00'));
 
-expectError(jest.setSystemTime('foo'));
+expectType<typeof jest>(jest.useFakeTimers());
+expectType<typeof jest>(jest.useFakeTimers('modern'));
+expectType<typeof jest>(jest.useFakeTimers('legacy'));
+expectError(jest.useFakeTimers('latest'));
 
-// https://jestjs.io/docs/jest-object#jestgetrealsystemtime
-expectType<number>(jest.getRealSystemTime());
+expectType<typeof jest>(jest.useRealTimers());
+expectError(jest.useRealTimers(true));
 
-expectError(jest.getRealSystemTime('foo'));
+// Misc
 
-// https://jestjs.io/docs/jest-object#jestrequireactualmodulename
-expectType<unknown>(jest.requireActual('./thisReturnsTheActualModule'));
+expectType<typeof jest>(jest.setTimeout(6000));
+expectError(jest.setTimeout());
 
-// https://jestjs.io/docs/jest-object#jestrequiremockmodulename
-expectType<unknown>(jest.requireMock('./thisAlwaysReturnsTheMock'));
+expectType<typeof jest>(jest.retryTimes(3));
+expectError(jest.retryTimes());

From e89c64b29be770a29de2d8ab90c0a959554f2508 Mon Sep 17 00:00:00 2001
From: mrazauskas <72159681+mrazauskas@users.noreply.github.com>
Date: Sun, 20 Feb 2022 22:14:57 +0200
Subject: [PATCH 2/9] fix test

---
 packages/jest-types/__typetests__/jest.test.ts | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/packages/jest-types/__typetests__/jest.test.ts b/packages/jest-types/__typetests__/jest.test.ts
index dcbb2e9f7acf..1a90a7306273 100644
--- a/packages/jest-types/__typetests__/jest.test.ts
+++ b/packages/jest-types/__typetests__/jest.test.ts
@@ -232,14 +232,26 @@ expectType<SpyInstance<void, [string]>>(
 expectError(jest.spyOn(spiedObject, 'propertyA'));
 
 expectError(jest.spyOn(spiedObject, 'notThere'));
-expectError(jest.spyOn(spiedArray as unknown as ArrayConstructor, 'from'));
-expectError(jest.spyOn(spiedFunction as unknown as Function, 'toString')); // eslint-disable-line @typescript-eslint/ban-types
 expectError(jest.spyOn('abc', 'methodA'));
 expectError(jest.spyOn(123, 'methodA'));
 expectError(jest.spyOn(true, 'methodA'));
 expectError(jest.spyOn(spiedObject));
 expectError(jest.spyOn());
 
+expectType<
+  SpyInstance<
+    Array<unknown>,
+    [
+      iterable: Iterable<unknown> | ArrayLike<unknown>,
+      mapfn: (v: unknown, k: number) => unknown,
+      thisArg?: any,
+    ]
+  >
+>(jest.spyOn(spiedArray as unknown as ArrayConstructor, 'from'));
+expectType<SpyInstance<string, []>>(
+  jest.spyOn(spiedFunction as unknown as Function, 'toString'), // eslint-disable-line @typescript-eslint/ban-types
+);
+
 expectType<SpyInstance<Date, [value: string | number | Date]>>(
   jest.spyOn(global, 'Date'),
 );

From 19e56a6a6eac990d3778f63e5d82b47baf40a55d Mon Sep 17 00:00:00 2001
From: mrazauskas <72159681+mrazauskas@users.noreply.github.com>
Date: Sun, 20 Feb 2022 22:40:30 +0200
Subject: [PATCH 3/9] tweak constrain

---
 packages/jest-mock/src/index.ts               | 44 ++++++++-----------
 .../jest-types/__typetests__/jest.test.ts     | 16 +++----
 2 files changed, 24 insertions(+), 36 deletions(-)

diff --git a/packages/jest-mock/src/index.ts b/packages/jest-mock/src/index.ts
index a7d333722788..d56e996d8346 100644
--- a/packages/jest-mock/src/index.ts
+++ b/packages/jest-mock/src/index.ts
@@ -32,14 +32,6 @@ export type MockFunctionMetadata<
   length?: number;
 };
 
-type ClassLike = {
-  new (...args: Array<any>): any;
-};
-
-type ObjectLike = {
-  [key: string]: any;
-};
-
 export type MockableFunction = (...args: Array<any>) => any;
 export type MethodKeysOf<T> = {
   [K in keyof T]: T[K] extends MockableFunction ? K : never;
@@ -1022,27 +1014,26 @@ export class ModuleMocker {
     return fn;
   }
 
-  spyOn<
-    T extends ClassLike | ObjectLike,
-    M extends NonFunctionPropertyNames<T>,
-  >(object: T, methodName: M, accessType: 'get'): SpyInstance<T[M], []>;
+  spyOn<T extends object, M extends NonFunctionPropertyNames<T>>(
+    object: T,
+    methodName: M,
+    accessType: 'get',
+  ): SpyInstance<T[M], []>;
 
-  spyOn<
-    T extends ClassLike | ObjectLike,
-    M extends NonFunctionPropertyNames<T>,
-  >(object: T, methodName: M, accessType: 'set'): SpyInstance<void, [T[M]]>;
+  spyOn<T extends object, M extends NonFunctionPropertyNames<T>>(
+    object: T,
+    methodName: M,
+    accessType: 'set',
+  ): SpyInstance<void, [T[M]]>;
 
-  spyOn<
-    T extends ClassLike | ObjectLike,
-    M extends ConstructorPropertyNames<Required<T>>,
-  >(
+  spyOn<T extends object, M extends ConstructorPropertyNames<Required<T>>>(
     object: T,
     method: M,
   ): T[M] extends new (...args: Array<any>) => any
     ? SpyInstance<InstanceType<T[M]>, ConstructorArgsType<T[M]>>
     : never;
 
-  spyOn<T extends ClassLike | ObjectLike, M extends FunctionPropertyNames<T>>(
+  spyOn<T extends object, M extends FunctionPropertyNames<T>>(
     object: T,
     methodName: M,
   ): T[M] extends (...args: Array<any>) => any
@@ -1050,10 +1041,11 @@ export class ModuleMocker {
     : never;
 
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  spyOn<
-    T extends ClassLike | ObjectLike,
-    M extends NonFunctionPropertyNames<T>,
-  >(object: T, methodName: M, accessType?: 'get' | 'set') {
+  spyOn<T extends object, M extends NonFunctionPropertyNames<T>>(
+    object: T,
+    methodName: M,
+    accessType?: 'get' | 'set',
+  ) {
     if (accessType) {
       return this._spyOnProperty(object, methodName, accessType);
     }
@@ -1121,7 +1113,7 @@ export class ModuleMocker {
   }
 
   private _spyOnProperty<
-    T extends ClassLike | ObjectLike,
+    T extends object,
     M extends NonFunctionPropertyNames<T>,
   >(obj: T, propertyName: M, accessType: 'get' | 'set' = 'get'): Mock<T> {
     if (typeof obj !== 'object' && typeof obj !== 'function') {
diff --git a/packages/jest-types/__typetests__/jest.test.ts b/packages/jest-types/__typetests__/jest.test.ts
index 1a90a7306273..d1a361af09f9 100644
--- a/packages/jest-types/__typetests__/jest.test.ts
+++ b/packages/jest-types/__typetests__/jest.test.ts
@@ -238,19 +238,15 @@ expectError(jest.spyOn(true, 'methodA'));
 expectError(jest.spyOn(spiedObject));
 expectError(jest.spyOn());
 
-expectType<
-  SpyInstance<
-    Array<unknown>,
-    [
-      iterable: Iterable<unknown> | ArrayLike<unknown>,
-      mapfn: (v: unknown, k: number) => unknown,
-      thisArg?: any,
-    ]
-  >
->(jest.spyOn(spiedArray as unknown as ArrayConstructor, 'from'));
+expectType<SpyInstance<boolean, [arg: any]>>(
+  jest.spyOn(spiedArray as unknown as ArrayConstructor, 'isArray'),
+);
+expectError(jest.spyOn(spiedArray, 'isArray'));
+
 expectType<SpyInstance<string, []>>(
   jest.spyOn(spiedFunction as unknown as Function, 'toString'), // eslint-disable-line @typescript-eslint/ban-types
 );
+expectError(jest.spyOn(spiedFunction, 'toString'));
 
 expectType<SpyInstance<Date, [value: string | number | Date]>>(
   jest.spyOn(global, 'Date'),

From fe798c693461791ead1bb4fb3b2b9c40f94f5692 Mon Sep 17 00:00:00 2001
From: mrazauskas <72159681+mrazauskas@users.noreply.github.com>
Date: Mon, 21 Feb 2022 08:37:13 +0200
Subject: [PATCH 4/9] add changelog entry

---
 CHANGELOG.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 01f3284eb17e..27efaa30ea04 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,7 @@
 - `[jest-environment-node]` [**BREAKING**] Add default `node` and `node-addon` conditions to `exportConditions` for `node` environment ([#11924](https://github.com/facebook/jest/pull/11924))
 - `[@jest/expect]` New module which extends `expect` with `jest-snapshot` matchers ([#12404](https://github.com/facebook/jest/pull/12404), [#12410](https://github.com/facebook/jest/pull/12410), [#12418](https://github.com/facebook/jest/pull/12418))
 - `[@jest/expect-utils]` New module exporting utils for `expect` ([#12323](https://github.com/facebook/jest/pull/12323))
+- `[jest-mock]` Improve `isMockFunction` to infer types of passed function ([#12442](https://github.com/facebook/jest/pull/12442))
 - `[jest-resolve]` [**BREAKING**] Add support for `package.json` `exports` ([#11961](https://github.com/facebook/jest/pull/11961), [#12373](https://github.com/facebook/jest/pull/12373))
 - `[jest-resolve, jest-runtime]` Add support for `data:` URI import and mock ([#12392](https://github.com/facebook/jest/pull/12392))
 - `[@jest/schemas]` New module for JSON schemas for Jest's config ([#12384](https://github.com/facebook/jest/pull/12384))
@@ -27,6 +28,7 @@
 - `[jest-haste-map]` Don't use partial results if file crawl errors ([#12420](https://github.com/facebook/jest/pull/12420))
 - `[jest-jasmine2, jest-types]` [**BREAKING**] Move all `jasmine` specific types from `@jest/types` to its own package ([#12125](https://github.com/facebook/jest/pull/12125))
 - `[jest-matcher-utils]` Pass maxWidth to `pretty-format` to avoid printing every element in arrays by default ([#12402](https://github.com/facebook/jest/pull/12402))
+- `[jest-mock]` Fix function overloads for `spyOn` to allow more correct type inference in complex object ([#12442](https://github.com/facebook/jest/pull/12442))
 
 ### Chore & Maintenance
 

From 8c25aab5a3bc16c104d9d528e8d63b02f8b7eae8 Mon Sep 17 00:00:00 2001
From: mrazauskas <72159681+mrazauskas@users.noreply.github.com>
Date: Mon, 21 Feb 2022 08:42:33 +0200
Subject: [PATCH 5/9] clean up

---
 packages/jest-mock/src/index.ts | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/packages/jest-mock/src/index.ts b/packages/jest-mock/src/index.ts
index d56e996d8346..011d4a93cd4a 100644
--- a/packages/jest-mock/src/index.ts
+++ b/packages/jest-mock/src/index.ts
@@ -79,9 +79,6 @@ export type MaybeMocked<T> = T extends MockableFunction
   : T;
 
 export type ArgsType<T> = T extends (...args: infer A) => any ? A : never;
-type ConstructorArgsType<T> = T extends new (...args: infer A) => any
-  ? A
-  : never;
 export type Mocked<T> = {
   [P in keyof T]: T[P] extends (...args: Array<any>) => any
     ? MockInstance<ReturnType<T[P]>, ArgsType<T[P]>>
@@ -1030,7 +1027,7 @@ export class ModuleMocker {
     object: T,
     method: M,
   ): T[M] extends new (...args: Array<any>) => any
-    ? SpyInstance<InstanceType<T[M]>, ConstructorArgsType<T[M]>>
+    ? SpyInstance<InstanceType<T[M]>, ConstructorParameters<T[M]>>
     : never;
 
   spyOn<T extends object, M extends FunctionPropertyNames<T>>(

From d98face4adadcb40b150b0f579e92d1956d7ef9b Mon Sep 17 00:00:00 2001
From: mrazauskas <72159681+mrazauskas@users.noreply.github.com>
Date: Mon, 21 Feb 2022 08:44:26 +0200
Subject: [PATCH 6/9] clean up

---
 .../__typetests__/mock-functions.test.ts      | 90 +++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 packages/jest-types/__typetests__/mock-functions.test.ts

diff --git a/packages/jest-types/__typetests__/mock-functions.test.ts b/packages/jest-types/__typetests__/mock-functions.test.ts
new file mode 100644
index 000000000000..48bb95287ff9
--- /dev/null
+++ b/packages/jest-types/__typetests__/mock-functions.test.ts
@@ -0,0 +1,90 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {expectError, expectType} from 'tsd-lite';
+import {jest} from '@jest/globals';
+import type {Mock} from 'jest-mock';
+
+// jest.fn()
+
+const mockFn = jest.fn((a: string, b: number) => true);
+
+expectType<string>(mockFn.getMockName());
+expectError(mockFn.getMockName('some-mock'));
+
+expectType<number>(mockFn.mock.calls.length);
+
+// hm.. possibly undefined?
+// https://github.com/facebook/jest/issues/10402
+expectType<string>(mockFn.mock.calls[0][0]);
+expectType<number>(mockFn.mock.calls[0][1]);
+
+expectType<string>(mockFn.mock.calls[1][0]);
+expectType<number>(mockFn.mock.calls[1][1]);
+
+expectType<[a: string, b: number] | undefined>(mockFn.mock.lastCall);
+
+expectType<Array<number>>(mockFn.mock.invocationCallOrder);
+
+const returnValue = mockFn.mock.results[0];
+
+expectType<'incomplete' | 'return' | 'throw'>(returnValue.type);
+expectType<unknown>(returnValue.value);
+
+// TODO
+//
+// if (returnValue.type === 'incomplete') {
+//   expectType(returnValue.value);
+// }
+
+// if (returnValue.type === 'return') {
+//   expectType(returnValue.value);
+// }
+
+// if (returnValue.type === 'throw') {
+//   expectType(returnValue.value);
+// }
+
+expectType<Mock<boolean, [a: string, b: number]>>(mockFn.mockClear());
+expectError(mockFn.mockClear('some-mock'));
+
+expectType<Mock<boolean, [a: string, b: number]>>(mockFn.mockReset());
+expectError(mockFn.mockClear('some-mock'));
+
+expectType<void>(mockFn.mockRestore());
+expectError(mockFn.mockClear('some-mock'));
+
+//
+// All bellow is TODO
+//
+
+const mock = jest.fn();
+
+mock.mockClear();
+
+expectType<Mock<Promise<string>, []>>(
+  jest
+    .fn(() => Promise.resolve('string value'))
+    .mockResolvedValueOnce('A string, not a Promise'),
+);
+expectType<Mock<Promise<string>, []>>(
+  jest
+    .fn(() => Promise.resolve('string value'))
+    .mockResolvedValue('A string, not a Promise'),
+);
+expectType<Mock<Promise<string>, []>>(
+  jest
+    .fn(() => Promise.resolve('string value'))
+    .mockRejectedValueOnce(new Error('An error, not a string')),
+);
+expectType<Mock<Promise<string>, []>>(
+  jest
+    .fn(() => Promise.resolve('string value'))
+    .mockRejectedValue(new Error('An error, not a string')),
+);
+
+// jest.spyOn()

From f342cce83738f75adea88b78d1b037e672675b66 Mon Sep 17 00:00:00 2001
From: mrazauskas <72159681+mrazauskas@users.noreply.github.com>
Date: Mon, 21 Feb 2022 08:48:23 +0200
Subject: [PATCH 7/9] real clean up

---
 packages/jest-mock/src/index.ts               |  2 +-
 .../__typetests__/mock-functions.test.ts      | 90 -------------------
 2 files changed, 1 insertion(+), 91 deletions(-)
 delete mode 100644 packages/jest-types/__typetests__/mock-functions.test.ts

diff --git a/packages/jest-mock/src/index.ts b/packages/jest-mock/src/index.ts
index 011d4a93cd4a..ad13745428ef 100644
--- a/packages/jest-mock/src/index.ts
+++ b/packages/jest-mock/src/index.ts
@@ -1025,7 +1025,7 @@ export class ModuleMocker {
 
   spyOn<T extends object, M extends ConstructorPropertyNames<Required<T>>>(
     object: T,
-    method: M,
+    methodName: M,
   ): T[M] extends new (...args: Array<any>) => any
     ? SpyInstance<InstanceType<T[M]>, ConstructorParameters<T[M]>>
     : never;
diff --git a/packages/jest-types/__typetests__/mock-functions.test.ts b/packages/jest-types/__typetests__/mock-functions.test.ts
deleted file mode 100644
index 48bb95287ff9..000000000000
--- a/packages/jest-types/__typetests__/mock-functions.test.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {expectError, expectType} from 'tsd-lite';
-import {jest} from '@jest/globals';
-import type {Mock} from 'jest-mock';
-
-// jest.fn()
-
-const mockFn = jest.fn((a: string, b: number) => true);
-
-expectType<string>(mockFn.getMockName());
-expectError(mockFn.getMockName('some-mock'));
-
-expectType<number>(mockFn.mock.calls.length);
-
-// hm.. possibly undefined?
-// https://github.com/facebook/jest/issues/10402
-expectType<string>(mockFn.mock.calls[0][0]);
-expectType<number>(mockFn.mock.calls[0][1]);
-
-expectType<string>(mockFn.mock.calls[1][0]);
-expectType<number>(mockFn.mock.calls[1][1]);
-
-expectType<[a: string, b: number] | undefined>(mockFn.mock.lastCall);
-
-expectType<Array<number>>(mockFn.mock.invocationCallOrder);
-
-const returnValue = mockFn.mock.results[0];
-
-expectType<'incomplete' | 'return' | 'throw'>(returnValue.type);
-expectType<unknown>(returnValue.value);
-
-// TODO
-//
-// if (returnValue.type === 'incomplete') {
-//   expectType(returnValue.value);
-// }
-
-// if (returnValue.type === 'return') {
-//   expectType(returnValue.value);
-// }
-
-// if (returnValue.type === 'throw') {
-//   expectType(returnValue.value);
-// }
-
-expectType<Mock<boolean, [a: string, b: number]>>(mockFn.mockClear());
-expectError(mockFn.mockClear('some-mock'));
-
-expectType<Mock<boolean, [a: string, b: number]>>(mockFn.mockReset());
-expectError(mockFn.mockClear('some-mock'));
-
-expectType<void>(mockFn.mockRestore());
-expectError(mockFn.mockClear('some-mock'));
-
-//
-// All bellow is TODO
-//
-
-const mock = jest.fn();
-
-mock.mockClear();
-
-expectType<Mock<Promise<string>, []>>(
-  jest
-    .fn(() => Promise.resolve('string value'))
-    .mockResolvedValueOnce('A string, not a Promise'),
-);
-expectType<Mock<Promise<string>, []>>(
-  jest
-    .fn(() => Promise.resolve('string value'))
-    .mockResolvedValue('A string, not a Promise'),
-);
-expectType<Mock<Promise<string>, []>>(
-  jest
-    .fn(() => Promise.resolve('string value'))
-    .mockRejectedValueOnce(new Error('An error, not a string')),
-);
-expectType<Mock<Promise<string>, []>>(
-  jest
-    .fn(() => Promise.resolve('string value'))
-    .mockRejectedValue(new Error('An error, not a string')),
-);
-
-// jest.spyOn()

From 93971bf4ac276e80bc5ae10d605cec9f16738f8a Mon Sep 17 00:00:00 2001
From: mrazauskas <72159681+mrazauskas@users.noreply.github.com>
Date: Mon, 21 Feb 2022 10:15:46 +0200
Subject: [PATCH 8/9] more tests

---
 .../jest-types/__typetests__/jest.test.ts     | 30 +++++++++++++++----
 1 file changed, 25 insertions(+), 5 deletions(-)

diff --git a/packages/jest-types/__typetests__/jest.test.ts b/packages/jest-types/__typetests__/jest.test.ts
index d1a361af09f9..a9f2e55aa24a 100644
--- a/packages/jest-types/__typetests__/jest.test.ts
+++ b/packages/jest-types/__typetests__/jest.test.ts
@@ -150,14 +150,34 @@ if (!jest.isMockFunction(surelyMock)) {
   expectType<never>(surelyMock);
 }
 
-declare const hardlyMockFn: string;
+declare const stringNotMock: string;
 
-if (!jest.isMockFunction(hardlyMockFn)) {
-  expectType<string>(hardlyMockFn);
+if (!jest.isMockFunction(stringNotMock)) {
+  expectType<string>(stringNotMock);
 }
 
-if (jest.isMockFunction(hardlyMockFn)) {
-  expectType<string>(hardlyMockFn);
+if (jest.isMockFunction(stringNotMock)) {
+  expectType<string>(stringNotMock);
+}
+
+declare const anyNotMock: any;
+
+if (!jest.isMockFunction(anyNotMock)) {
+  expectType<any>(anyNotMock);
+}
+
+if (jest.isMockFunction(anyNotMock)) {
+  expectType<any>(anyNotMock);
+}
+
+declare const unknownNotMock: unknown;
+
+if (!jest.isMockFunction(unknownNotMock)) {
+  expectType<unknown>(unknownNotMock);
+}
+
+if (jest.isMockFunction(unknownNotMock)) {
+  expectType<unknown>(unknownNotMock);
 }
 
 expectType<Mock<unknown>>(jest.fn());

From 92b21a8eb176016532c065455052fd98c9a279a6 Mon Sep 17 00:00:00 2001
From: mrazauskas <72159681+mrazauskas@users.noreply.github.com>
Date: Mon, 21 Feb 2022 10:25:38 +0200
Subject: [PATCH 9/9] tweak overload type

---
 packages/jest-mock/src/index.ts               |  2 +-
 .../jest-types/__typetests__/jest.test.ts     | 30 +++++++++----------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/packages/jest-mock/src/index.ts b/packages/jest-mock/src/index.ts
index ad13745428ef..db143d16fe59 100644
--- a/packages/jest-mock/src/index.ts
+++ b/packages/jest-mock/src/index.ts
@@ -995,7 +995,7 @@ export class ModuleMocker {
   isMockFunction<T, Y extends Array<unknown> = Array<unknown>>(
     fn: (...args: Y) => T,
   ): fn is Mock<T, Y>;
-  isMockFunction(fn: unknown): boolean;
+  isMockFunction(fn: unknown): fn is Mock<unknown>;
   isMockFunction<T>(fn: unknown): fn is Mock<T> {
     return !!fn && (fn as any)._isMockFunction === true;
   }
diff --git a/packages/jest-types/__typetests__/jest.test.ts b/packages/jest-types/__typetests__/jest.test.ts
index a9f2e55aa24a..821a322137b2 100644
--- a/packages/jest-types/__typetests__/jest.test.ts
+++ b/packages/jest-types/__typetests__/jest.test.ts
@@ -150,34 +150,34 @@ if (!jest.isMockFunction(surelyMock)) {
   expectType<never>(surelyMock);
 }
 
-declare const stringNotMock: string;
+declare const stringMaybeMock: string;
 
-if (!jest.isMockFunction(stringNotMock)) {
-  expectType<string>(stringNotMock);
+if (!jest.isMockFunction(stringMaybeMock)) {
+  expectType<string>(stringMaybeMock);
 }
 
-if (jest.isMockFunction(stringNotMock)) {
-  expectType<string>(stringNotMock);
+if (jest.isMockFunction(stringMaybeMock)) {
+  expectType<string & Mock<unknown, Array<unknown>>>(stringMaybeMock);
 }
 
-declare const anyNotMock: any;
+declare const anyMaybeMock: any;
 
-if (!jest.isMockFunction(anyNotMock)) {
-  expectType<any>(anyNotMock);
+if (!jest.isMockFunction(anyMaybeMock)) {
+  expectType<any>(anyMaybeMock);
 }
 
-if (jest.isMockFunction(anyNotMock)) {
-  expectType<any>(anyNotMock);
+if (jest.isMockFunction(anyMaybeMock)) {
+  expectType<Mock<unknown, Array<unknown>>>(anyMaybeMock);
 }
 
-declare const unknownNotMock: unknown;
+declare const unknownMaybeMock: unknown;
 
-if (!jest.isMockFunction(unknownNotMock)) {
-  expectType<unknown>(unknownNotMock);
+if (!jest.isMockFunction(unknownMaybeMock)) {
+  expectType<unknown>(unknownMaybeMock);
 }
 
-if (jest.isMockFunction(unknownNotMock)) {
-  expectType<unknown>(unknownNotMock);
+if (jest.isMockFunction(unknownMaybeMock)) {
+  expectType<Mock<unknown, Array<unknown>>>(unknownMaybeMock);
 }
 
 expectType<Mock<unknown>>(jest.fn());