jest-mock - npm Package Compare versions

Comparing version 29.2.0 to 29.2.1

build/index.d.ts

@@ -250,5 +250,5 @@ /**
   isMockFunction<T extends FunctionLike = UnknownFunction>(
-    fn: SpyInstance<T>,
-  ): fn is SpyInstance<T>;
-  isMockFunction<P extends Array<unknown>, R extends unknown>(
+    fn: MockInstance<T>,
+  ): fn is MockInstance<T>;
+  isMockFunction<P extends Array<unknown>, R>(
     fn: (...args: P) => R,
@@ -262,21 +262,15 @@ ): fn is Mock<(...args: P) => R>;
     V extends Required<T>[K],
-  >(object: T, methodKey: K, accessType: 'get'): SpyInstance<() => V>;
-  spyOn<
-    T extends object,
-    K extends PropertyLikeKeys<T>,
-    V extends Required<T>[K],
-  >(object: T, methodKey: K, accessType: 'set'): SpyInstance<(arg: V) => void>;
-  spyOn<
-    T extends object,
-    K extends ConstructorLikeKeys<T>,
-    V extends Required<T>[K],
+    A extends 'get' | 'set',
   >(
     object: T,
     methodKey: K,
-  ): V extends ClassLike
-    ? SpyInstance<(...args: ConstructorParameters<V>) => InstanceType<V>>
+    accessType: A,
+  ): A extends 'get'
+    ? SpiedGetter<V>
+    : A extends 'set'
+    ? SpiedSetter<V>
     : never;
   spyOn<
     T extends object,
-    K extends MethodLikeKeys<T>,
+    K extends ConstructorLikeKeys<T> | MethodLikeKeys<T>,
     V extends Required<T>[K],
@@ -286,5 +280,4 @@ >(
     methodKey: K,
-  ): V extends FunctionLike
-    ? SpyInstance<(...args: Parameters<V>) => ReturnType<V>>
-    : never;
+  ): V extends ClassLike | FunctionLike ? Spied<V> : never;
+  private _spyOnProperty;
   clearAllMocks(): void;
@@ -319,2 +312,19 @@ resetAllMocks(): void;
 
+export declare type Spied<T extends ClassLike | FunctionLike> =
+  T extends ClassLike
+    ? MockInstance<(...args: ConstructorParameters<T>) => InstanceType<T>>
+    : T extends FunctionLike
+    ? MockInstance<(...args: Parameters<T>) => ReturnType<T>>
+    : never;
+
+export declare type SpiedClass<T extends ClassLike = UnknownClass> =
+  MockInstance<(...args: ConstructorParameters<T>) => InstanceType<T>>;
+
+export declare type SpiedFunction<T extends FunctionLike = UnknownFunction> =
+  MockInstance<(...args: Parameters<T>) => ReturnType<T>>;
+
+export declare type SpiedGetter<T> = MockInstance<() => T>;
+
+export declare type SpiedSetter<T> = MockInstance<(arg: T) => void>;
+
 export declare interface SpyInstance<T extends FunctionLike = UnknownFunction>
@@ -338,11 +348,15 @@ extends MockInstance<T> {}
     V extends Required<T>[K_2],
+    A extends 'set' | 'get',
   >(
     object: T,
     methodKey: K_2,
-    accessType: 'get',
-  ): SpyInstance<() => V>;
+    accessType: A,
+  ): A extends 'get'
+    ? SpiedGetter<V>
+    : A extends 'set'
+    ? SpiedSetter<V>
+    : never;
   <
     T_1 extends object,
-    K_5 extends Exclude<
-      keyof T_1,
+    K_5 extends
       | keyof {
@@ -357,4 +371,3 @@ [K_3 in keyof T_1 as Required<T_1>[K_3] extends ClassLike
             : never]: T_1[K_4];
-        }
-    >,
+        },
     V_1 extends Required<T_1>[K_5],
@@ -364,36 +377,11 @@ >(
     methodKey: K_5,
-    accessType: 'set',
-  ): SpyInstance<(arg: V_1) => void>;
-  <
-    T_2 extends object,
-    K_7 extends keyof {
-      [K_6 in keyof T_2 as Required<T_2>[K_6] extends ClassLike
-        ? K_6
-        : never]: T_2[K_6];
-    },
-    V_2 extends Required<T_2>[K_7],
-  >(
-    object: T_2,
-    methodKey: K_7,
-  ): V_2 extends ClassLike
-    ? SpyInstance<(...args: ConstructorParameters<V_2>) => InstanceType<V_2>>
-    : never;
-  <
-    T_3 extends object,
-    K_9 extends keyof {
-      [K_8 in keyof T_3 as Required<T_3>[K_8] extends FunctionLike
-        ? K_8
-        : never]: T_3[K_8];
-    },
-    V_3 extends Required<T_3>[K_9],
-  >(
-    object: T_3,
-    methodKey: K_9,
-  ): V_3 extends FunctionLike
-    ? SpyInstance<(...args: Parameters<V_3>) => ReturnType<V_3>>
-    : never;
+  ): V_1 extends ClassLike | FunctionLike ? Spied<V_1> : never;
 };
 
+export declare type UnknownClass = {
+  new (...args: Array<unknown>): unknown;
+};
+
 export declare type UnknownFunction = (...args: Array<unknown>) => unknown;
 
 export {};

build/index.js

@@ -250,6 +250,3 @@ 'use strict';
           const propDesc = Object.getOwnPropertyDescriptor(object, prop);
-          if (
-            propDesc !== undefined &&
-            !(propDesc.get && prop == '__proto__')
-          ) {
+          if ((propDesc !== undefined && !propDesc.get) || object.__esModule) {
             slots.add(prop);
@@ -555,3 +552,2 @@ }
     this._getSlots(metadata.members).forEach(slot => {
-      let slotMock;
       const slotMetadata = (metadata.members && metadata.members[slot]) || {};
@@ -565,36 +561,3 @@ if (slotMetadata.ref != null) {
       } else {
-        slotMock = this._generateMock(slotMetadata, callbacks, refs);
-
-        // For superclass accessor properties the subclass metadata contains the definitions
-        // for the getter and setter methods, and the superclass refs to them.
-        // The mock implementations are not available until the callbacks have been executed.
-        // Missing getter and setter refs will be resolved as their callbacks have been
-        // stacked before the setting of the accessor definition is stacked.
-
-        // In some cases, e.g. third-party APIs, a 'prototype' ancestor to be
-        // mocked has a function property called 'get'.  In this circumstance
-        // the 'prototype' property cannot be redefined and doing so causes an
-        // exception. Checks have been added for the 'configurable' and
-        // 'enumberable' properties present on true accessor property
-        // descriptors to prevent the attempt to replace the API.
-        if (
-          (slotMetadata.members?.get?.ref !== undefined ||
-            slotMetadata.members?.set?.ref !== undefined) &&
-          slotMetadata.members?.configurable &&
-          slotMetadata.members?.enumerable
-        ) {
-          callbacks.push(
-            (function (ref) {
-              return () => Object.defineProperty(mock, slot, ref);
-            })(slotMock)
-          );
-        } else if (
-          (slotMetadata.members?.get || slotMetadata.members?.set) &&
-          slotMetadata.members?.configurable &&
-          slotMetadata.members?.enumerable
-        ) {
-          Object.defineProperty(mock, slot, slotMock);
-        } else {
-          mock[slot] = slotMock;
-        }
+        mock[slot] = this._generateMock(slotMetadata, callbacks, refs);
       }
@@ -678,26 +641,4 @@ });
         }
-        let descriptor = Object.getOwnPropertyDescriptor(component, slot);
-        let proto = Object.getPrototypeOf(component);
-        while (!descriptor && proto !== null) {
-          descriptor = Object.getOwnPropertyDescriptor(proto, slot);
-          proto = Object.getPrototypeOf(proto);
-        }
-        let slotMetadata = null;
-        if (descriptor?.get || descriptor?.set) {
-          // Specific case required for mocking class definitions imported via modules.
-          // In this case the class definitions are stored in accessor properties.
-          // All getters were previously ignored except where the containing object had __esModule == true
-          // Now getters are mocked the class definitions must still be read.
-          // @ts-expect-error ignore type mismatch
-          if (component.__esModule) {
-            // @ts-expect-error no index signature
-            slotMetadata = this.getMetadata(component[slot], refs);
-          } else {
-            // @ts-expect-error ignore type mismatch
-            slotMetadata = this.getMetadata(descriptor, refs);
-          }
-        } else {
-          // @ts-expect-error no index signature
-          slotMetadata = this.getMetadata(component[slot], refs);
-        }
+        // @ts-expect-error no index signature
+        const slotMetadata = this.getMetadata(component[slot], refs);
         if (slotMetadata) {
@@ -732,2 +673,7 @@ if (!members) {
   spyOn(object, methodKey, accessType) {
+    if (typeof object !== 'object' && typeof object !== 'function') {
+      throw new Error(
+        `Cannot spyOn on a primitive value; ${this._typeOf(object)} given`
+      );
+    }
     if (!object) {
@@ -741,49 +687,94 @@ throw new Error(
     }
-    if (accessType && accessType != 'get' && accessType != 'set') {
-      throw new Error('Invalid accessType supplied');
+    if (accessType) {
+      return this._spyOnProperty(object, methodKey, accessType);
     }
-    if (typeof object !== 'object' && typeof object !== 'function') {
-      throw new Error(
-        `Cannot spyOn on a primitive value; ${this._typeOf(object)} given`
+    const original = object[methodKey];
+    if (!this.isMockFunction(original)) {
+      if (typeof original !== 'function') {
+        throw new Error(
+          `Cannot spy the ${String(
+            methodKey
+          )} property because it is not a function; ${this._typeOf(
+            original
+          )} given instead`
+        );
+      }
+      const isMethodOwner = Object.prototype.hasOwnProperty.call(
+        object,
+        methodKey
       );
+      let descriptor = Object.getOwnPropertyDescriptor(object, methodKey);
+      let proto = Object.getPrototypeOf(object);
+      while (!descriptor && proto !== null) {
+        descriptor = Object.getOwnPropertyDescriptor(proto, methodKey);
+        proto = Object.getPrototypeOf(proto);
+      }
+      let mock;
+      if (descriptor && descriptor.get) {
+        const originalGet = descriptor.get;
+        mock = this._makeComponent(
+          {
+            type: 'function'
+          },
+          () => {
+            descriptor.get = originalGet;
+            Object.defineProperty(object, methodKey, descriptor);
+          }
+        );
+        descriptor.get = () => mock;
+        Object.defineProperty(object, methodKey, descriptor);
+      } else {
+        mock = this._makeComponent(
+          {
+            type: 'function'
+          },
+          () => {
+            if (isMethodOwner) {
+              object[methodKey] = original;
+            } else {
+              delete object[methodKey];
+            }
+          }
+        );
+        // @ts-expect-error overriding original method with a Mock
+        object[methodKey] = mock;
+      }
+      mock.mockImplementation(function () {
+        return original.apply(this, arguments);
+      });
     }
-    let descriptor = Object.getOwnPropertyDescriptor(object, methodKey);
-    let proto = Object.getPrototypeOf(object);
+    return object[methodKey];
+  }
+  _spyOnProperty(obj, propertyKey, accessType) {
+    let descriptor = Object.getOwnPropertyDescriptor(obj, propertyKey);
+    let proto = Object.getPrototypeOf(obj);
     while (!descriptor && proto !== null) {
-      descriptor = Object.getOwnPropertyDescriptor(proto, methodKey);
+      descriptor = Object.getOwnPropertyDescriptor(proto, propertyKey);
       proto = Object.getPrototypeOf(proto);
     }
     if (!descriptor) {
-      throw new Error(`${String(methodKey)} property does not exist`);
+      throw new Error(`${String(propertyKey)} property does not exist`);
     }
     if (!descriptor.configurable) {
-      throw new Error(`${String(methodKey)} is not declared configurable`);
+      throw new Error(`${String(propertyKey)} is not declared configurable`);
     }
-    if (this.isMockFunction(descriptor.value)) {
-      return object[methodKey];
-    } else if (accessType == 'get' && this.isMockFunction(descriptor.get)) {
-      return descriptor.get;
-    } else if (accessType == 'set' && this.isMockFunction(descriptor.set)) {
-      return descriptor.set;
-    }
-    if (accessType) {
-      if (typeof descriptor[accessType] !== 'function') {
-        throw new Error(`Cannot spy the ${String(accessType)} ${String(
-          methodKey
-        )} property because it is not a function;
-          ${this._typeOf(descriptor?.[accessType])} given instead`);
-      }
-    } else if (typeof descriptor.value !== 'function') {
+    if (!descriptor[accessType]) {
       throw new Error(
-        `Cannot spy the ${String(
-          methodKey
-        )} property because it is not a function; ${this._typeOf(
-          descriptor.value
-        )} given instead`
+        `Property ${String(
+          propertyKey
+        )} does not have access type ${accessType}`
       );
     }
-    let mock;
-    if (accessType == 'get' && descriptor['get']) {
-      const originalAccessor = descriptor['get'];
-      mock = this._makeComponent(
+    const original = descriptor[accessType];
+    if (!this.isMockFunction(original)) {
+      if (typeof original !== 'function') {
+        throw new Error(
+          `Cannot spy the ${String(
+            propertyKey
+          )} property because it is not a function; ${this._typeOf(
+            original
+          )} given instead`
+        );
+      }
+      descriptor[accessType] = this._makeComponent(
         {
@@ -793,53 +784,14 @@ type: 'function'
         () => {
-          descriptor[accessType] = originalAccessor;
-          Object.defineProperty(object, methodKey, descriptor);
+          // @ts-expect-error: mock is assignable
+          descriptor[accessType] = original;
+          Object.defineProperty(obj, propertyKey, descriptor);
         }
       );
-      descriptor[accessType] = mock;
-      mock.mockImplementation(function () {
-        return originalAccessor.call(this);
+      descriptor[accessType].mockImplementation(function () {
+        // @ts-expect-error - wrong context
+        return original.apply(this, arguments);
       });
-      Object.defineProperty(object, methodKey, descriptor);
-    } else if (accessType == 'set' && descriptor['set']) {
-      const originalAccessor = descriptor['set'];
-      mock = this._makeComponent(
-        {
-          type: 'function'
-        },
-        () => {
-          descriptor[accessType] = originalAccessor;
-          Object.defineProperty(object, methodKey, descriptor);
-        }
-      );
-      descriptor[accessType] = mock;
-      mock.mockImplementation(function () {
-        return originalAccessor.call(this, arguments[0]);
-      });
-      Object.defineProperty(object, methodKey, descriptor);
-    } else {
-      const isMethodOwner = Object.prototype.hasOwnProperty.call(
-        object,
-        methodKey
-      );
-      const original = descriptor;
-      mock = this._makeComponent(
-        {
-          type: 'function'
-        },
-        () => {
-          if (isMethodOwner) {
-            object[methodKey] = original.value;
-          } else {
-            delete object[methodKey];
-          }
-        }
-      );
-
-      // @ts-expect-error overriding original method with a Mock
-      object[methodKey] = mock;
-      mock.mockImplementation(function () {
-        return original.value.apply(this, arguments);
-      });
     }
-    return mock;
+    Object.defineProperty(obj, propertyKey, descriptor);
+    return descriptor[accessType];
   }
@@ -846,0 +798,0 @@ clearAllMocks() {

package.json

 {
   "name": "jest-mock",
-  "version": "29.2.0",
+  "version": "29.2.1",
   "repository": {
@@ -20,5 +20,5 @@ "type": "git",
   "dependencies": {
-    "@jest/types": "^29.2.0",
+    "@jest/types": "^29.2.1",
     "@types/node": "*",
-    "jest-util": "^29.2.0"
+    "jest-util": "^29.2.1"
   },
@@ -35,3 +35,3 @@ "devDependencies": {
   },
-  "gitHead": "ee5b37a4f4433afcfffb0356cea47739d8092287"
+  "gitHead": "4551c0fdd4d25b7206824957c7bcc6baf61e63bf"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

41981

decreased by-6.13%

Lines of code

1145

decreased by-5.22%

Dependency changes

• Updated@jest/types@^29.2.1

• Updatedjest-util@^29.2.1