Skip to content

Commit f144074

Browse files
lucasfcostalucasfcosta
committed
fix: handle circular references correctly in objects (closes #8663)
1 parent b76f01b commit f144074

5 files changed

Lines changed: 286 additions & 31 deletions

File tree

‎CHANGELOG.md‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@
2424
- `[jest-core]` Fix incorrect `passWithNoTests` warning ([#8595](https://github.com/facebook/jest/pull/8595))
2525
- `[jest-snapshots]` Fix test retries that contain snapshots ([#8629](https://github.com/facebook/jest/pull/8629))
2626
- `[jest-mock]` Fix incorrect assignments when restoring mocks in instances where they originally didn't exist ([#8631](https://github.com/facebook/jest/pull/8631))
27+
- `[expect]` Fix stack overflow when matching objects with circular references ([#8687](https://github.com/facebook/jest/pull/8687))
2728

2829
### Chore & Maintenance
2930

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

Lines changed: 98 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4092,6 +4092,104 @@ Expected: not <green>Set {2, 1}</>
40924092
Received: <red>Set {1, 2}</>"
40934093
`;
40944094

4095+
exports[`toMatchObject() circular references simple circular references {pass: false} expect({"a": "hello", "ref": [Circular]}).toMatchObject({"a": "world", "ref": [Circular]}) 1`] = `"Maximum call stack size exceeded"`;
4096+
4097+
exports[`toMatchObject() circular references simple circular references {pass: false} expect({"ref": "not a ref"}).toMatchObject({"a": "hello", "ref": [Circular]}) 1`] = `
4098+
"<dim>expect(</><red>received</><dim>).</>toMatchObject<dim>(</><green>expected</><dim>)</>
4099+
4100+
<green>- Expected</>
4101+
<red>+ Received</>
4102+
4103+
<dim> Object {</>
4104+
<green>- \\"a\\": \\"hello\\",</>
4105+
<green>- \\"ref\\": [Circular],</>
4106+
<red>+ \\"ref\\": \\"not a ref\\",</>
4107+
<dim> }</>"
4108+
`;
4109+
4110+
exports[`toMatchObject() circular references simple circular references {pass: false} expect({}).toMatchObject({"a": "hello", "ref": [Circular]}) 1`] = `
4111+
"<dim>expect(</><red>received</><dim>).</>toMatchObject<dim>(</><green>expected</><dim>)</>
4112+
4113+
<green>- Expected</>
4114+
<red>+ Received</>
4115+
4116+
<green>- Object {</>
4117+
<green>- \\"a\\": \\"hello\\",</>
4118+
<green>- \\"ref\\": [Circular],</>
4119+
<green>- }</>
4120+
<red>+ Object {}</>"
4121+
`;
4122+
4123+
exports[`toMatchObject() circular references simple circular references {pass: true} expect({"a": "hello", "ref": [Circular]}).toMatchObject({"a": "hello", "ref": [Circular]}) 1`] = `
4124+
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toMatchObject<dim>(</><green>expected</><dim>)</>
4125+
4126+
Expected: not <green>{\\"a\\": \\"hello\\", \\"ref\\": [Circular]}</>"
4127+
`;
4128+
4129+
exports[`toMatchObject() circular references simple circular references {pass: true} expect({"a": "hello", "ref": [Circular]}).toMatchObject({}) 1`] = `
4130+
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toMatchObject<dim>(</><green>expected</><dim>)</>
4131+
4132+
Expected: not <green>{}</>
4133+
Received: <red>{\\"a\\": \\"hello\\", \\"ref\\": [Circular]}</>"
4134+
`;
4135+
4136+
exports[`toMatchObject() circular references transitive circular references {pass: false} expect({"a": "world", "nestedObj": {"parentObj": [Circular]}}).toMatchObject({"a": "hello", "nestedObj": {"parentObj": [Circular]}}) 1`] = `"Maximum call stack size exceeded"`;
4137+
4138+
exports[`toMatchObject() circular references transitive circular references {pass: false} expect({"nestedObj": {"parentObj": "not the parent ref"}}).toMatchObject({"a": "hello", "nestedObj": {"parentObj": [Circular]}}) 1`] = `
4139+
"<dim>expect(</><red>received</><dim>).</>toMatchObject<dim>(</><green>expected</><dim>)</>
4140+
4141+
<green>- Expected</>
4142+
<red>+ Received</>
4143+
4144+
<dim> Object {</>
4145+
<green>- \\"a\\": \\"hello\\",</>
4146+
<dim> \\"nestedObj\\": Object {</>
4147+
<green>- \\"parentObj\\": [Circular],</>
4148+
<red>+ \\"parentObj\\": \\"not the parent ref\\",</>
4149+
<dim> },</>
4150+
<dim> }</>"
4151+
`;
4152+
4153+
exports[`toMatchObject() circular references transitive circular references {pass: false} expect({}).toMatchObject({"a": "hello", "nestedObj": {"parentObj": [Circular]}}) 1`] = `
4154+
"<dim>expect(</><red>received</><dim>).</>toMatchObject<dim>(</><green>expected</><dim>)</>
4155+
4156+
<green>- Expected</>
4157+
<red>+ Received</>
4158+
4159+
<green>- Object {</>
4160+
<green>- \\"a\\": \\"hello\\",</>
4161+
<green>- \\"nestedObj\\": Object {</>
4162+
<green>- \\"parentObj\\": [Circular],</>
4163+
<green>- },</>
4164+
<green>- }</>
4165+
<red>+ Object {}</>"
4166+
`;
4167+
4168+
exports[`toMatchObject() circular references transitive circular references {pass: true} expect({"a": "hello", "nestedObj": {"parentObj": [Circular]}}).toMatchObject({"a": "hello", "nestedObj": {"parentObj": [Circular]}}) 1`] = `
4169+
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toMatchObject<dim>(</><green>expected</><dim>)</>
4170+
4171+
Expected: not <green>{\\"a\\": \\"hello\\", \\"nestedObj\\": {\\"parentObj\\": [Circular]}}</>"
4172+
`;
4173+
4174+
exports[`toMatchObject() circular references transitive circular references {pass: true} expect({"a": "hello", "nestedObj": {"parentObj": [Circular]}}).toMatchObject({}) 1`] = `
4175+
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toMatchObject<dim>(</><green>expected</><dim>)</>
4176+
4177+
Expected: not <green>{}</>
4178+
Received: <red>{\\"a\\": \\"hello\\", \\"nestedObj\\": {\\"parentObj\\": [Circular]}}</>"
4179+
`;
4180+
4181+
exports[`toMatchObject() does not match properties up in the prototype chain 1`] = `
4182+
"<dim>expect(</><red>received</><dim>).</>toMatchObject<dim>(</><green>expected</><dim>)</>
4183+
4184+
<green>- Expected</>
4185+
<red>+ Received</>
4186+
4187+
<dim> Object {</>
4188+
<dim> \\"other\\": \\"child\\",</>
4189+
<green>- \\"ref\\": [Circular],</>
4190+
<dim> }</>"
4191+
`;
4192+
40954193
exports[`toMatchObject() throws expect("44").toMatchObject({}) 1`] = `
40964194
"<dim>expect(</><red>received</><dim>).</>toMatchObject<dim>(</><green>expected</><dim>)</>
40974195

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

Lines changed: 104 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1537,7 +1537,91 @@ describe('toMatchObject()', () => {
15371537
}
15381538
}
15391539

1540-
[
1540+
const testNotToMatchSnapshots = tuples => {
1541+
tuples.forEach(([n1, n2]) => {
1542+
it(`{pass: true} expect(${stringify(n1)}).toMatchObject(${stringify(
1543+
n2,
1544+
)})`, () => {
1545+
jestExpect(n1).toMatchObject(n2);
1546+
expect(() =>
1547+
jestExpect(n1).not.toMatchObject(n2),
1548+
).toThrowErrorMatchingSnapshot();
1549+
});
1550+
});
1551+
};
1552+
1553+
const testToMatchSnapshots = tuples => {
1554+
tuples.forEach(([n1, n2]) => {
1555+
it(`{pass: false} expect(${stringify(n1)}).toMatchObject(${stringify(
1556+
n2,
1557+
)})`, () => {
1558+
jestExpect(n1).not.toMatchObject(n2);
1559+
expect(() =>
1560+
jestExpect(n1).toMatchObject(n2),
1561+
).toThrowErrorMatchingSnapshot();
1562+
});
1563+
});
1564+
};
1565+
1566+
describe('circular references', () => {
1567+
describe('simple circular references', () => {
1568+
const circularObjA1 = {a: 'hello'};
1569+
circularObjA1.ref = circularObjA1;
1570+
1571+
const circularObjB = {a: 'world'};
1572+
circularObjB.ref = circularObjB;
1573+
1574+
const circularObjA2 = {a: 'hello'};
1575+
circularObjA2.ref = circularObjA2;
1576+
1577+
const primitiveInsteadOfRef = {};
1578+
primitiveInsteadOfRef.ref = 'not a ref';
1579+
1580+
testNotToMatchSnapshots([
1581+
[circularObjA1, {}],
1582+
[circularObjA2, circularObjA1],
1583+
]);
1584+
1585+
testToMatchSnapshots([
1586+
[{}, circularObjA1],
1587+
[circularObjA1, circularObjB],
1588+
[primitiveInsteadOfRef, circularObjA1],
1589+
]);
1590+
});
1591+
1592+
describe('transitive circular references', () => {
1593+
const transitiveCircularObjA1 = {a: 'hello'};
1594+
transitiveCircularObjA1.nestedObj = {parentObj: transitiveCircularObjA1};
1595+
1596+
const transitiveCircularObjA2 = {a: 'hello'};
1597+
transitiveCircularObjA2.nestedObj = {
1598+
parentObj: transitiveCircularObjA2,
1599+
};
1600+
1601+
const transitiveCircularObjB = {a: 'world'};
1602+
transitiveCircularObjB.nestedObj = {
1603+
parentObj: transitiveCircularObjB,
1604+
};
1605+
1606+
const primitiveInsteadOfRef = {};
1607+
primitiveInsteadOfRef.nestedObj = {
1608+
parentObj: 'not the parent ref',
1609+
};
1610+
1611+
testNotToMatchSnapshots([
1612+
[transitiveCircularObjA1, {}],
1613+
[transitiveCircularObjA2, transitiveCircularObjA1],
1614+
]);
1615+
1616+
testToMatchSnapshots([
1617+
[{}, transitiveCircularObjA1],
1618+
[transitiveCircularObjB, transitiveCircularObjA1],
1619+
[primitiveInsteadOfRef, transitiveCircularObjA1],
1620+
]);
1621+
});
1622+
});
1623+
1624+
testNotToMatchSnapshots([
15411625
[{a: 'b', c: 'd'}, {a: 'b'}],
15421626
[{a: 'b', c: 'd'}, {a: 'b', c: 'd'}],
15431627
[{a: 'b', t: {x: {r: 'r'}, z: 'z'}}, {a: 'b', t: {z: 'z'}}],
@@ -1560,18 +1644,9 @@ describe('toMatchObject()', () => {
15601644
[new Error('bar'), {message: 'bar'}],
15611645
[new Foo(), {a: undefined, b: 'b'}],
15621646
[Object.assign(Object.create(null), {a: 'b'}), {a: 'b'}],
1563-
].forEach(([n1, n2]) => {
1564-
it(`{pass: true} expect(${stringify(n1)}).toMatchObject(${stringify(
1565-
n2,
1566-
)})`, () => {
1567-
jestExpect(n1).toMatchObject(n2);
1568-
expect(() =>
1569-
jestExpect(n1).not.toMatchObject(n2),
1570-
).toThrowErrorMatchingSnapshot();
1571-
});
1572-
});
1647+
]);
15731648

1574-
[
1649+
testToMatchSnapshots([
15751650
[{a: 'b', c: 'd'}, {e: 'b'}],
15761651
[{a: 'b', c: 'd'}, {a: 'b!', c: 'd'}],
15771652
[{a: 'a', c: 'd'}, {a: jestExpect.any(Number)}],
@@ -1597,16 +1672,7 @@ describe('toMatchObject()', () => {
15971672
[[1, 2, 3], [1, 2, 2]],
15981673
[new Error('foo'), new Error('bar')],
15991674
[Object.assign(Object.create(null), {a: 'b'}), {c: 'd'}],
1600-
].forEach(([n1, n2]) => {
1601-
it(`{pass: false} expect(${stringify(n1)}).toMatchObject(${stringify(
1602-
n2,
1603-
)})`, () => {
1604-
jestExpect(n1).not.toMatchObject(n2);
1605-
expect(() =>
1606-
jestExpect(n1).toMatchObject(n2),
1607-
).toThrowErrorMatchingSnapshot();
1608-
});
1609-
});
1675+
]);
16101676

16111677
[
16121678
[null, {}],
@@ -1628,4 +1694,20 @@ describe('toMatchObject()', () => {
16281694
).toThrowErrorMatchingSnapshot();
16291695
});
16301696
});
1697+
1698+
it('does not match properties up in the prototype chain', () => {
1699+
const a = {};
1700+
a.ref = a;
1701+
1702+
const b = Object.create(a);
1703+
b.other = 'child';
1704+
1705+
const matcher = {other: 'child'};
1706+
matcher.ref = matcher;
1707+
1708+
jestExpect(b).not.toMatchObject(matcher);
1709+
expect(() =>
1710+
jestExpect(b).toMatchObject(matcher),
1711+
).toThrowErrorMatchingSnapshot();
1712+
});
16311713
});

‎packages/expect/src/__tests__/utils.test.js‎

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -202,6 +202,60 @@ describe('subsetEquality()', () => {
202202
test('undefined does not return errors', () => {
203203
expect(subsetEquality(undefined, {foo: 'bar'})).not.toBeTruthy();
204204
});
205+
206+
describe('matching subsets with circular references', () => {
207+
test('simple circular references', () => {
208+
const circularObjA1 = {a: 'hello'};
209+
circularObjA1.ref = circularObjA1;
210+
211+
const circularObjA2 = {a: 'hello'};
212+
circularObjA2.ref = circularObjA2;
213+
214+
const circularObjB = {a: 'world'};
215+
circularObjB.ref = circularObjB;
216+
217+
const primitiveInsteadOfRef = {};
218+
primitiveInsteadOfRef.ref = 'not a ref';
219+
220+
expect(subsetEquality(circularObjA1, {})).toBe(true);
221+
expect(subsetEquality({}, circularObjA1)).toBe(false);
222+
expect(subsetEquality(circularObjA2, circularObjA1)).toBe(true);
223+
expect(subsetEquality(circularObjB, circularObjA1)).toBe(false);
224+
expect(subsetEquality(primitiveInsteadOfRef, circularObjA1)).toBe(false);
225+
});
226+
227+
test('transitive circular references', () => {
228+
const transitiveCircularObjA1 = {a: 'hello'};
229+
transitiveCircularObjA1.nestedObj = {parentObj: transitiveCircularObjA1};
230+
231+
const transitiveCircularObjA2 = {a: 'hello'};
232+
transitiveCircularObjA2.nestedObj = {
233+
parentObj: transitiveCircularObjA2,
234+
};
235+
236+
const transitiveCircularObjB = {a: 'world'};
237+
transitiveCircularObjB.nestedObj = {
238+
parentObj: transitiveCircularObjB,
239+
};
240+
241+
const primitiveInsteadOfRef = {};
242+
primitiveInsteadOfRef.nestedObj = {
243+
parentObj: 'not the parent ref',
244+
};
245+
246+
expect(subsetEquality(transitiveCircularObjA1, {})).toBe(true);
247+
expect(subsetEquality({}, transitiveCircularObjA1)).toBe(false);
248+
expect(
249+
subsetEquality(transitiveCircularObjA2, transitiveCircularObjA1),
250+
).toBe(true);
251+
expect(
252+
subsetEquality(transitiveCircularObjB, transitiveCircularObjA1),
253+
).toBe(false);
254+
expect(
255+
subsetEquality(primitiveInsteadOfRef, transitiveCircularObjA1),
256+
).toBe(false);
257+
});
258+
});
205259
});
206260

207261
describe('iterableEquality', () => {

‎packages/expect/src/utils.ts‎

Lines changed: 29 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -268,16 +268,36 @@ export const subsetEquality = (
268268
object: any,
269269
subset: any,
270270
): undefined | boolean => {
271-
if (!isObjectWithKeys(subset)) {
272-
return undefined;
273-
}
271+
// subsetEquality needs to keep track of the references
272+
// it has already visited to avoid infinite loops in case
273+
// there are circular references in the subset passed to it.
274+
const subsetEqualityWithContext = (
275+
seenReferences: WeakMap<object, boolean> = new WeakMap(),
276+
) => (object: any, subset: any): undefined | boolean => {
277+
if (!isObjectWithKeys(subset)) {
278+
return undefined;
279+
}
274280

275-
return Object.keys(subset).every(
276-
key =>
277-
object != null &&
278-
hasOwnProperty(object, key) &&
279-
equals(object[key], subset[key], [iterableEquality, subsetEquality]),
280-
);
281+
return Object.keys(subset).every(key => {
282+
if (isObjectWithKeys(subset[key])) {
283+
if (seenReferences.get(subset[key])) {
284+
return equals(object[key], subset[key], [iterableEquality]);
285+
}
286+
seenReferences.set(subset[key], true);
287+
}
288+
289+
return (
290+
object != null &&
291+
hasOwnProperty(object, key) &&
292+
equals(object[key], subset[key], [
293+
iterableEquality,
294+
subsetEqualityWithContext(seenReferences),
295+
])
296+
);
297+
});
298+
};
299+
300+
return subsetEqualityWithContext()(object, subset);
281301
};
282302

283303
export const typeEquality = (a: any, b: any) => {

0 commit comments

Comments
 (0)
⚡