fix: prevent infinite recursion with self-referential getters (#15822) (#15831)

Co-authored-by: Claude <[email protected]>
Co-authored-by: Christoph Nakazawa <[email protected]>

Author: 3 people

CHANGELOG.md

@@ -17,6 +17,7 @@
 
 ### Fixes
 
+- `[jest-matcher-utils]` Fix infinite recursion with self-referential getters in `deepCyclicCopyReplaceable` ([#15831](https://github.com/jestjs/jest/pull/15831))
 - `[babel-jest]` Export the `TransformerConfig` interface ([#15820](https://github.com/jestjs/jest/pull/15820))
 - `[jest-config]` Fix `jest.config.ts` with TS loader specified in docblock pragma ([#15839](https://github.com/jestjs/jest/pull/15839))
 

packages/expect/src/__tests__/__snapshots__/matchers.test.js.snap

@@ -4595,6 +4595,19 @@ Expected: not <g>Set {2, 1}</>
 Received:     <r>Set {1, 2}</>
 `;
 
+exports[`toMatchObject() circular references getter circular references handles self-referential getter without infinite recursion 1`] = `
+<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>
+
+<g>- Expected  - 2</>
+<r>+ Received  + 2</>
+
+<g>- TestClass {</>
+<g>-   "value": "def",</>
+<r>+ Object {</>
+<r>+   "value": "abc",</>
+<d>  }</>
+`;
+
 exports[`toMatchObject() circular references simple circular references {pass: false} expect({"a": "hello", "ref": [Circular]}).toMatchObject({"a": "world", "ref": [Circular]}) 1`] = `
 <d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>
 

packages/expect/src/__tests__/matchers.test.js

@@ -2213,6 +2213,30 @@ describe('toMatchObject()', () => {
         [primitiveInsteadOfRef, transitiveCircularObjA1],
       ]);
     });
+
+    describe('getter circular references', () => {
+      test('handles self-referential getter without infinite recursion', () => {
+        class TestClass {
+          constructor(value) {
+            this.value = value;
+          }
+
+          get selfRef() {
+            return new TestClass(this.value.toLowerCase());
+          }
+        }
+
+        const abc = new TestClass('abc');
+        const def = new TestClass('def');
+
+        jestExpect(abc).toMatchObject(abc);
+        jestExpect(abc).not.toMatchObject(def);
+
+        expect(() =>
+          jestExpect(abc).toMatchObject(def),
+        ).toThrowErrorMatchingSnapshot();
+      });
+    });
   });
 
   testNotToMatchSnapshots([

packages/jest-matcher-utils/src/__tests__/__snapshots__/printDiffOrStringify.test.ts.snap

@@ -184,6 +184,16 @@ Expected: <g>"multi</>
 Received: <r>""</>
 `;
 
+exports[`printDiffOrStringify getters handles self-referential getters without infinite recursion 1`] = `
+<g>- Expected  - 1</>
+<r>+ Received  + 1</>
+
+<d>  TestClass {</>
+<g>-   "value": "hello",</>
+<r>+   "value": "world",</>
+<d>  }</>
+`;
+
 exports[`printDiffOrStringify has no common after clean up chaff multiline 1`] = `
 <g>- Expected  - 2</>
 <r>+ Received  + 2</>

packages/jest-matcher-utils/src/__tests__/deepCyclicCopyReplaceable.test.ts

@@ -184,3 +184,76 @@ test('json from Response', async () => {
   const json = await response().json();
   deepCyclicCopyReplaceable(json);
 });
+
+test('handles self-referential getters without infinite recursion', () => {
+  class TestClass {
+    constructor(public value: string) {}
+
+    get selfRef() {
+      return new TestClass(this.value.toLowerCase());
+    }
+  }
+
+  const obj = new TestClass('HELLO');
+  const copy = deepCyclicCopyReplaceable(obj);
+
+  expect(copy.value).toBe('HELLO');
+  expect(copy.selfRef).toBe('[Getter]');
+});
+
+test('handles getters returning different class instances', () => {
+  class OtherClass {
+    constructor(public value: string) {}
+  }
+
+  class WithGetter {
+    constructor(public value: string) {}
+
+    get other() {
+      return new OtherClass(this.value.toLowerCase());
+    }
+  }
+
+  const obj = new WithGetter('HELLO');
+  const copy = deepCyclicCopyReplaceable(obj);
+
+  expect(copy.value).toBe('HELLO');
+  expect(copy.other).toEqual({value: 'hello'});
+  expect(copy.other.constructor).toBe(OtherClass);
+});
+
+test('handles nested objects with self-referential getters', () => {
+  class InnerClass {
+    constructor(public value: string) {}
+
+    get self() {
+      return new InnerClass(`${this.value}_self`);
+    }
+  }
+
+  class OuterClass {
+    constructor(public inner: InnerClass) {}
+  }
+
+  const obj = new OuterClass(new InnerClass('test'));
+  const copy = deepCyclicCopyReplaceable(obj);
+
+  expect(copy.inner.value).toBe('test');
+  expect(copy.inner.self).toBe('[Getter]');
+});
+
+test('handles getters returning primitive values', () => {
+  class TestClass {
+    constructor(public value: string) {}
+
+    get upperCase() {
+      return this.value.toUpperCase();
+    }
+  }
+
+  const obj = new TestClass('hello');
+  const copy = deepCyclicCopyReplaceable(obj);
+
+  expect(copy.value).toBe('hello');
+  expect(copy.upperCase).toBe('HELLO');
+});

packages/jest-matcher-utils/src/__tests__/printDiffOrStringify.test.ts

@@ -269,4 +269,21 @@ describe('printDiffOrStringify', () => {
       expect(testDiffOrStringify(expected, received)).toMatchSnapshot();
     });
   });
+
+  describe('getters', () => {
+    test('handles self-referential getters without infinite recursion', () => {
+      class TestClass {
+        constructor(public value: string) {}
+
+        get selfRef() {
+          return new TestClass(`${this.value}_ref`);
+        }
+      }
+
+      const expected = new TestClass('hello');
+      const received = new TestClass('world');
+
+      expect(testDiffOrStringify(expected, received)).toMatchSnapshot();
+    });
+  });
 });

packages/jest-matcher-utils/src/deepCyclicCopyReplaceable.ts

@@ -101,16 +101,30 @@ function deepCyclicCopyObject<T>(object: T, cycles: WeakMap<any, unknown>): T {
     //https://github.com/microsoft/TypeScript/issues/1863
     (newDescriptors: {[x: string]: PropertyDescriptor}, key: string) => {
       const enumerable = descriptors[key].enumerable;
+      const descriptor = descriptors[key];
+
+      let value;
+
+      if (descriptor.get) {
+        const getterRes = (object as Record<string | symbol, unknown>)[key];
+        const isSelfReferential =
+          getterRes?.constructor === (object as any).constructor &&
+          getterRes?.constructor !== Object;
+
+        value = isSelfReferential
+          ? '[Getter]'
+          : deepCyclicCopyReplaceable(getterRes, cycles);
+      } else {
+        value = deepCyclicCopyReplaceable(
+          (object as Record<string | symbol, unknown>)[key],
+          cycles,
+        );
+      }
 
       newDescriptors[key] = {
         configurable: true,
         enumerable,
-        value: deepCyclicCopyReplaceable(
-          // this accesses the value or getter, depending. We just care about the value anyways, and this allows us to not mess with accessors
-          // it has the side effect of invoking the getter here though, rather than copying it over
-          (object as Record<string | symbol, unknown>)[key],
-          cycles,
-        ),
+        value,
         writable: true,
       };
       return newDescriptors;