fix(expect-utils): handle cross-realm constructors in toStrictEqual

JamieMagee · JamieMagee · commit 1307f205b901 · 2026-02-14T21:05:34.000-08:00
structuredClone returns objects whose constructors come from the outer VM context. typeEquality and iterableEquality compared constructors by identity (===), which always failed across realms — even for plain objects, Maps, Sets, Dates, and RegExps. When constructors don't match by identity, fall back to comparing constructor names, but only when both are native built-in functions. User-defined classes still require identity equality, so toStrictEqual keeps distinguishing e.g. two different classes named Child. Fixes #14011
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,7 @@
 
 ### Fixes
 
+- `[expect-utils]` Fix `toStrictEqual` failing on `structuredClone` results due to cross-realm constructor mismatch ([#14011](https://github.com/jestjs/jest/issues/14011))
 - `[jest-mock]` Use `Symbol` from test environment ([#15858](https://github.com/jestjs/jest/pull/15858))
 - `[jest-reporters]` Fix issue where console output not displayed for GHA reporter even with `silent: false` option ([#15864](https://github.com/jestjs/jest/pull/15864))
 - `[jest-runtime]` Fix issue where user cannot utilize dynamic import despite specifying `--experimental-vm-modules` Node option ([#15842](https://github.com/jestjs/jest/pull/15842))
diff --git a/packages/expect-utils/src/__tests__/utils.test.ts b/packages/expect-utils/src/__tests__/utils.test.ts
@@ -658,6 +658,98 @@ describe('typeEquality', () => {
   test('returns undefined if given mock.calls and []', () => {
     expect(typeEquality(jest.fn().mock.calls, [])).toBeUndefined();
   });
+
+  test('returns undefined for cross-realm plain objects', () => {
+    const vm = require('vm');
+    const context = vm.createContext({});
+    const otherRealmObject = vm.runInContext('({key: "test"})', context);
+    expect(typeEquality(otherRealmObject, {key: 'test'})).toBeUndefined();
+  });
+
+  test('returns undefined for cross-realm Maps', () => {
+    const vm = require('vm');
+    const context = vm.createContext({});
+    const otherRealmMap = vm.runInContext(
+      'new Map([["key", "value"]])',
+      context,
+    );
+    expect(
+      typeEquality(otherRealmMap, new Map([['key', 'value']])),
+    ).toBeUndefined();
+  });
+
+  test('returns undefined for cross-realm Sets', () => {
+    const vm = require('vm');
+    const context = vm.createContext({});
+    const otherRealmSet = vm.runInContext('new Set(["test"])', context);
+    expect(typeEquality(otherRealmSet, new Set(['test']))).toBeUndefined();
+  });
+
+  test('returns undefined for cross-realm Dates', () => {
+    const vm = require('vm');
+    const context = vm.createContext({});
+    const otherRealmDate = vm.runInContext('new Date("2023-01-01")', context);
+    expect(
+      typeEquality(otherRealmDate, new Date('2023-01-01')),
+    ).toBeUndefined();
+  });
+
+  test('returns undefined for cross-realm RegExps', () => {
+    const vm = require('vm');
+    const context = vm.createContext({});
+    const otherRealmRegExp = vm.runInContext('/test/gi', context);
+    expect(typeEquality(otherRealmRegExp, /test/gi)).toBeUndefined();
+  });
+
+  test('returns false for different user-defined classes with same name', () => {
+    class Child {
+      a: number;
+      constructor(a: number) {
+        this.a = a;
+      }
+    }
+    const OtherChild = class Child {
+      a: number;
+      constructor(a: number) {
+        this.a = a;
+      }
+    };
+    expect(typeEquality(new Child(1), new OtherChild(1))).toBe(false);
+  });
+});
+
+describe('iterableEquality (cross-realm)', () => {
+  test('returns true for cross-realm Sets with same values', () => {
+    const vm = require('vm');
+    const context = vm.createContext({});
+    const otherRealmSet = vm.runInContext('new Set([1, 2, 3])', context);
+    expect(iterableEquality(otherRealmSet, new Set([1, 2, 3]))).toBe(true);
+  });
+
+  test('returns true for cross-realm Maps with same entries', () => {
+    const vm = require('vm');
+    const context = vm.createContext({});
+    const otherRealmMap = vm.runInContext(
+      'new Map([["a", 1], ["b", 2]])',
+      context,
+    );
+    expect(
+      iterableEquality(
+        otherRealmMap,
+        new Map([
+          ['a', 1],
+          ['b', 2],
+        ]),
+      ),
+    ).toBe(true);
+  });
+
+  test('returns false for cross-realm Sets with different values', () => {
+    const vm = require('vm');
+    const context = vm.createContext({});
+    const otherRealmSet = vm.runInContext('new Set([1, 2])', context);
+    expect(iterableEquality(otherRealmSet, new Set([1, 2, 3]))).toBe(false);
+  });
 });
 
 describe('arrayBufferEquality', () => {
diff --git a/packages/expect-utils/src/utils.ts b/packages/expect-utils/src/utils.ts
@@ -193,7 +193,17 @@ export const iterableEquality = (
     return undefined;
   }
   if (a.constructor !== b.constructor) {
-    return false;
+    // Same cross-realm constructor check as typeEquality — see #14011.
+    // https://github.com/jestjs/jest/issues/14011
+    if (
+      a.constructor == null ||
+      b.constructor == null ||
+      a.constructor.name !== b.constructor.name ||
+      !isNativeFunction(a.constructor) ||
+      !isNativeFunction(b.constructor)
+    ) {
+      return false;
+    }
   }
   let length = aStack.length;
   while (length--) {
@@ -392,6 +402,14 @@ export const subsetEquality = (
   return subsetEqualityWithContext()(object, subset);
 };
 
+// Returns true if `fn` is a native function (its toString contains "[native code]").
+function isNativeFunction(fn: unknown): boolean {
+  return (
+    typeof fn === 'function' &&
+    Function.prototype.toString.call(fn).includes('[native code]')
+  );
+}
+
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 export const typeEquality = (a: any, b: any): boolean | undefined => {
   if (
@@ -407,6 +425,21 @@ export const typeEquality = (a: any, b: any): boolean | undefined => {
     return undefined;
   }
 
+  // structuredClone (and other cross-realm calls) return objects whose
+  // constructors come from a different VM context, so identity checks fail.
+  // Fall back to comparing constructor names for native built-ins only —
+  // user-defined classes still need identity equality.
+  // https://github.com/jestjs/jest/issues/14011
+  if (
+    a.constructor != null &&
+    b.constructor != null &&
+    a.constructor.name === b.constructor.name &&
+    isNativeFunction(a.constructor) &&
+    isNativeFunction(b.constructor)
+  ) {
+    return undefined;
+  }
+
   return false;
 };
 
