build

node_modules/expect/build/utils.js

@@ -98,25 +98,23 @@ const getPath = (object, propertyPath) => {
 
 exports.getPath = getPath;
 
-const getObjectSubset = (object, subset) => {
+const getObjectSubset = (object, subset, seenReferences = new WeakMap()) => {
   if (Array.isArray(object)) {
     if (Array.isArray(subset) && subset.length === object.length) {
       return subset.map((sub, i) => getObjectSubset(object[i], sub));
     }
   } else if (object instanceof Date) {
     return object;
-  } else if (
-    typeof object === 'object' &&
-    object !== null &&
-    typeof subset === 'object' &&
-    subset !== null
-  ) {
+  } else if (isObject(object) && isObject(subset)) {
     const trimmed = {};
-    Object.keys(subset)
-      .filter(key => hasOwnProperty(object, key))
-      .forEach(
-        key => (trimmed[key] = getObjectSubset(object[key], subset[key]))
-      );
+    seenReferences.set(object, trimmed);
+    Object.keys(object)
+      .filter(key => hasOwnProperty(subset, key))
+      .forEach(key => {
+        trimmed[key] = seenReferences.has(object[key])
+          ? seenReferences.get(object[key])
+          : getObjectSubset(object[key], subset[key], seenReferences);
+      });
 
     if (Object.keys(trimmed).length > 0) {
       return trimmed;
@@ -392,27 +390,49 @@ const iterableEquality = (a, b, aStack = [], bStack = []) => {
 
 exports.iterableEquality = iterableEquality;
 
+const isObject = a => a !== null && typeof a === 'object';
+
 const isObjectWithKeys = a =>
-  a !== null &&
-  typeof a === 'object' &&
+  isObject(a) &&
   !(a instanceof Error) &&
   !(a instanceof Array) &&
   !(a instanceof Date);
 
 const subsetEquality = (object, subset) => {
-  if (!isObjectWithKeys(subset)) {
-    return undefined;
-  }
+  // subsetEquality needs to keep track of the references
+  // it has already visited to avoid infinite loops in case
+  // there are circular references in the subset passed to it.
+  const subsetEqualityWithContext = (seenReferences = new WeakMap()) => (
+    object,
+    subset
+  ) => {
+    if (!isObjectWithKeys(subset)) {
+      return undefined;
+    }
 
-  return Object.keys(subset).every(
-    key =>
-      object != null &&
-      hasOwnProperty(object, key) &&
-      (0, _jasmineUtils.equals)(object[key], subset[key], [
-        iterableEquality,
-        subsetEquality
-      ])
-  );
+    return Object.keys(subset).every(key => {
+      if (isObjectWithKeys(subset[key])) {
+        if (seenReferences.get(subset[key])) {
+          return (0, _jasmineUtils.equals)(object[key], subset[key], [
+            iterableEquality
+          ]);
+        }
+
+        seenReferences.set(subset[key], true);
+      }
+
+      return (
+        object != null &&
+        hasOwnProperty(object, key) &&
+        (0, _jasmineUtils.equals)(object[key], subset[key], [
+          iterableEquality,
+          subsetEqualityWithContext(seenReferences)
+        ])
+      );
+    });
+  };
+
+  return subsetEqualityWithContext()(object, subset);
 };
 
 exports.subsetEquality = subsetEquality;