chore: extend and improve type tests for jest object

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

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,31 +1022,38 @@ 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
     ? SpyInstance<ReturnType<T[M]>, Parameters<T[M]>>
     : 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',