Fix infinite recursion on circular objects (#91)

* tsconfig target bump

* refactor and circular object fix for deep equal

* small test to verify fix

Author: notanengineercom

spec/issues/90.test.ts

@@ -0,0 +1,37 @@
+import test from 'ava';
+
+import { Substitute } from '../../src/index';
+
+test('can handle circular referenced objects', t => {
+  interface Service {
+    foo(a: any): string;
+  }
+
+  const s = Substitute.for<Service>();
+
+  const parent = {} as any;
+  parent.child = parent;
+
+  const root = {} as any;
+  root.path = { to: { nested: root } };
+
+  s.foo(parent).returns('even-circular');
+  s.foo(root).returns('even-nested-circular');
+
+  t.is(s.foo(parent), 'even-circular');
+  t.is(s.foo(root), 'even-nested-circular');
+});
+
+test('can handle non circular referenced objects', t => {
+  interface Service {
+    foo(a: any): string;
+  }
+
+  const s = Substitute.for<Service>();
+
+  const parent = {} as any;
+  parent.child = { family: true };
+
+  s.foo(parent).returns('even-non-circular');
+  t.is(s.foo(parent), 'even-non-circular');
+});

src/Utilities.ts

@@ -1,4 +1,4 @@
-import { Argument, AllArguments } from "./Arguments";
+import { Argument, AllArguments } from './Arguments';
 import { GetPropertyState } from './states/GetPropertyState';
 import { InitialState } from './states/InitialState';
 import { Context } from './Context';
@@ -21,6 +21,7 @@ export enum SubstituteMethods {
     rejects = 'rejects'
 }
 
+const seenObject = Symbol();
 export const Nothing = Symbol();
 export type Nothing = typeof Nothing
 
@@ -73,27 +74,31 @@ export function areArgumentsEqual(a: any, b: any) {
     return deepEqual(a, b);
 };
 
-function deepEqual(a: any, b: any): boolean {
-    if (Array.isArray(a)) {
-        if (!Array.isArray(b) || a.length !== b.length) return false;
-        for (let i = 0; i < a.length; i++) {
-            if (!deepEqual(a[i], b[i])) return false;
-        }
-        return true;
-    }
-    if (typeof a === 'object' && a !== null && b !== null) {
-        if (!(typeof b === 'object')) return false;
+function deepEqual(realA: any, realB: any, objectReferences: Object[] = []): boolean {
+    const a = objectReferences.includes(realA) ? seenObject : realA;
+    const b = objectReferences.includes(realB) ? seenObject : realB;
+    const newObjectReferences = updateObjectReferences(objectReferences, a, b);
+
+    if (nonNullObject(a) && nonNullObject(b)) {
         if (a.constructor !== b.constructor) return false;
-        const keys = Object.keys(a);
-        if (keys.length !== Object.keys(b).length) return false;
+        if (Object.keys(a).length !== Object.keys(b).length) return false;
         for (const key in a) {
-            if (!deepEqual(a[key], b[key])) return false;
+            if (!deepEqual(a[key], b[key], newObjectReferences)) return false;
         }
         return true;
     }
     return a === b;
 }
 
+function updateObjectReferences(objectReferences: Array<Object>, a: any, b: any) {
+    const tempObjectReferences = [...objectReferences, nonNullObject(a) && !objectReferences.includes(a) ? a : void 0];
+    return [...tempObjectReferences, nonNullObject(b) && !tempObjectReferences.includes(b) ? b : void 0];
+}
+
+function nonNullObject(value: any) {
+    return typeof value === 'object' && value !== null;
+}
+
 export function Get(recorder: InitialState, context: Context, property: PropertyKey) {
     const existingGetState = recorder.getPropertyStates.find(state => state.property === property);
     if (existingGetState) {

tsconfig.json

@@ -1,17 +1,16 @@
 {
     "compileOnSave": true,
     "compilerOptions": {
+        "module": "commonjs",
+        "moduleResolution": "node",
         "baseUrl": ".",
-		"declaration": true,
+        "declaration": true,
         "sourceMap": true,
         "inlineSources": true,
         "downlevelIteration": true,
         "outDir": "./dist",
         "strict": true,
         "strictNullChecks": false,
-        "target": "es5",
-        "lib": [
-            "es2015"
-        ]
+        "target": "ES2016"
     }
-}
+}