fix(core): mock object properties lazily (#1415)

Author: 9aoy

e2e/mock/tests/mockLargeModule.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it, rs } from '@rstest/core';
+
+rs.mock('@rsbuild/core', { mock: true });
+
+describe('rs.mock with { mock: true } for large modules', () => {
+  it('creates mocks lazily for nested exports', async () => {
+    const rsbuild = await import('@rsbuild/core');
+
+    expect(rs.isMockFunction(rsbuild.createRsbuild)).toBe(true);
+    expect(rsbuild.createRsbuild()).toBeUndefined();
+  });
+});

packages/core/src/runtime/api/mockObject.ts

@@ -27,6 +27,12 @@ interface GlobalConstructors {
   RegExp: typeof RegExp;
 }
 
+interface PropertySnapshot {
+  props: Key[];
+  descriptors: Map<Key, PropertyDescriptor>;
+  isModule: boolean;
+}
+
 /**
  * Get the type name of a value using Object.prototype.toString
  */
@@ -52,6 +58,10 @@ function isFunction(value: unknown): value is (...args: any[]) => any {
   return typeof value === 'function';
 }
 
+function isModuleObject(value: Record<Key, any>): boolean {
+  return getTypeName(value) === 'Module' || value.__esModule;
+}
+
 /**
  * Check if a property is a built-in readonly property (e.g., function's name, length)
  */
@@ -149,13 +159,36 @@ function getEnumerableProperties(
   return [...props];
 }
 
+function getPropertyDescriptor(
+  obj: any,
+  prop: Key,
+): PropertyDescriptor | undefined {
+  let current = obj;
+  const visited = new WeakSet();
+
+  while (current) {
+    if (visited.has(current)) {
+      return undefined;
+    }
+    visited.add(current);
+
+    const descriptor = Object.getOwnPropertyDescriptor(current, prop);
+    if (descriptor) {
+      return descriptor;
+    }
+    current = Object.getPrototypeOf(current);
+  }
+
+  return undefined;
+}
+
 /**
  * Deeply mock an object
  *
  * Core algorithm:
  * 1. Iterate over all properties of the object
  * 2. Functions → replace with mock functions (automock) or wrap as spy (autospy)
- * 3. Plain objects → process recursively
+ * 3. Plain objects → process properties lazily
  * 4. Arrays → empty in automock mode, process elements recursively in autospy mode
  * 5. Primitive values → keep unchanged
  * 6. Use WeakMap to track processed objects and avoid circular references
@@ -170,8 +203,44 @@ export function mockObject<T extends Record<Key, any>>(
 
   // Track processed object references to prevent infinite recursion from circular references
   const processedRefs = new WeakMap();
-  // Deferred assignment queue for handling circular references
-  const deferredAssignments: (() => void)[] = [];
+  const snapshotRefs = new WeakMap();
+
+  const snapshotProperties = (value: any): PropertySnapshot | undefined => {
+    if (
+      !isSpyMode ||
+      value === null ||
+      value === undefined ||
+      (typeof value !== 'object' && typeof value !== 'function') ||
+      (!isPlainObject(value) && !isFunction(value))
+    ) {
+      return undefined;
+    }
+
+    if (snapshotRefs.has(value)) {
+      return snapshotRefs.get(value);
+    }
+
+    const props = getEnumerableProperties(value, globalConstructors);
+    const descriptors = new Map<Key, PropertyDescriptor>();
+    const snapshot: PropertySnapshot = {
+      props,
+      descriptors,
+      isModule: !isFunction(value) && isModuleObject(value),
+    };
+    snapshotRefs.set(value, snapshot);
+
+    const isModule = snapshot.isModule;
+    for (const prop of props) {
+      const descriptor = isModule
+        ? Object.getOwnPropertyDescriptor(value, prop)
+        : getPropertyDescriptor(value, prop);
+      if (descriptor) {
+        descriptors.set(prop, descriptor);
+      }
+    }
+
+    return snapshot;
+  };
 
   /**
    * Create a mock instance for a function
@@ -192,7 +261,7 @@ export function mockObject<T extends Record<Key, any>>(
   /**
    * Process a single value and return the mocked value
    */
-  const processValue = (value: any): any => {
+  const processValue = (value: any, snapshot?: PropertySnapshot): any => {
     // Return primitive values as-is
     if (value === null || value === undefined) {
       return value;
@@ -216,7 +285,7 @@ export function mockObject<T extends Record<Key, any>>(
     if (isFunction(value)) {
       const mock = createFunctionMock(value);
       // Functions may also have properties, process them recursively
-      processProperties(value, mock);
+      processProperties(value, mock, snapshot);
       return mock;
     }
 
@@ -227,14 +296,14 @@ export function mockObject<T extends Record<Key, any>>(
         return [];
       }
       // autospy mode: process array elements recursively
-      return value.map(processValue);
+      return value.map((item) => processValue(item));
     }
 
     // Handle plain objects
     if (isPlainObject(value)) {
       const result: Record<Key, any> = {};
       processedRefs.set(value, result);
-      processProperties(value, result);
+      processProperties(value, result, snapshot);
       return result;
     }
 
@@ -248,17 +317,20 @@ export function mockObject<T extends Record<Key, any>>(
   const processProperties = (
     source: Record<Key, any>,
     target: Record<Key, any>,
+    snapshot?: PropertySnapshot,
   ): void => {
-    const props = getEnumerableProperties(source, globalConstructors);
-    const isModule = getTypeName(source) === 'Module' || source.__esModule;
+    const props =
+      snapshot?.props ?? getEnumerableProperties(source, globalConstructors);
+    const isModule = snapshot?.isModule ?? isModuleObject(source);
 
     for (const prop of props) {
       // Skip built-in readonly properties
       if (isBuiltinReadonly(source, prop)) {
         continue;
       }
 
-      const descriptor = Object.getOwnPropertyDescriptor(source, prop);
+      const descriptor =
+        snapshot?.descriptors.get(prop) ?? getPropertyDescriptor(source, prop);
       if (!descriptor) continue;
 
       // Handle getter/setter (non-module)
@@ -281,22 +353,58 @@ export function mockObject<T extends Record<Key, any>>(
         continue;
       }
 
-      const value = source[prop];
-
-      // Check for circular references
-      if (value && typeof value === 'object' && processedRefs.has(value)) {
-        // Defer assignment until all objects are processed
-        deferredAssignments.push(() => {
-          target[prop] = processedRefs.get(value);
-        });
+      const hasValue = 'value' in descriptor;
+      const value = hasValue ? descriptor.value : undefined;
+      const sourceValue =
+        hasValue && isSpyMode && Array.isArray(value) ? value.slice() : value;
+      const sourceSnapshot = hasValue ? snapshotProperties(value) : undefined;
+      const recursiveFunctionMock =
+        hasValue && isFunction(source) && value === source ? target : undefined;
+      const canInstallLazyProperty = !(
+        isFunction(target) &&
+        prop === 'prototype' &&
+        value &&
+        typeof value === 'object'
+      );
+
+      if (!canInstallLazyProperty) {
+        try {
+          target[prop] =
+            recursiveFunctionMock ?? processValue(sourceValue, sourceSnapshot);
+        } catch {
+          // Ignore assignment failures (some properties may be readonly)
+        }
         continue;
       }
 
-      // Process and assign the value
       try {
-        target[prop] = processValue(value);
+        let initialized = false;
+        let mockedValue: any;
+        const getSourceValue = () => (hasValue ? sourceValue : source[prop]);
+
+        Object.defineProperty(target, prop, {
+          configurable: descriptor.configurable,
+          enumerable: descriptor.enumerable,
+          get: () => {
+            if (!initialized) {
+              initialized = true;
+              try {
+                mockedValue =
+                  recursiveFunctionMock ??
+                  processValue(getSourceValue(), sourceSnapshot);
+              } catch {
+                mockedValue = undefined;
+              }
+            }
+            return mockedValue;
+          },
+          set: (newValue) => {
+            initialized = true;
+            mockedValue = newValue;
+          },
+        });
       } catch {
-        // Ignore assignment failures (some properties may be readonly)
+        // Ignore definition failures
       }
     }
   };
@@ -305,10 +413,5 @@ export function mockObject<T extends Record<Key, any>>(
   processedRefs.set(object, mockExports);
   processProperties(object, mockExports);
 
-  // Execute deferred assignments to resolve circular references
-  for (const assign of deferredAssignments) {
-    assign();
-  }
-
   return mockExports as T;
 }