Merge pull request #30 from Tynamix/ENHANCE_ThrowOnCircularRef

Setup Allows now to specify if an exception will be thrown on circular d...

Author: Tynamix

ObjectFiller.Test/ObjectFillerRecursiveTests.cs

@@ -50,6 +50,7 @@ private class TestDuplicate
         public void RecursiveFill_RecursiveType_ThrowsException()
         {
             var filler = new Filler<TestParent>();
+            filler.Setup().OnCircularReference().ThrowException();
             filler.Create();
         }
 
@@ -78,6 +79,7 @@ public void RecursiveFill_WithFunc_Succeeds()
         public void RecursiveFill_RecursiveType_Parent_First_Fails()
         {
             var filler = new Filler<TestParent>();
+            filler.Setup().OnCircularReference().ThrowException();
             filler.Create();
         }
 
@@ -86,6 +88,7 @@ public void RecursiveFill_RecursiveType_Parent_First_Fails()
         public void RecursiveFill_RecursiveType_Child_First_Fails()
         {
             var filler = new Filler<TestChild>();
+            filler.Setup().OnCircularReference().ThrowException();
             filler.Create();
         }
 
@@ -94,14 +97,17 @@ public void RecursiveFill_RecursiveType_Child_First_Fails()
         public void RecursiveFill_DeepRecursiveType_Fails()
         {
             var filler = new Filler<TestGrandParent>();
+            filler.Setup().OnCircularReference().ThrowException();
             filler.Create();
+
         }
 
         [TestMethod]
         [ExpectedException(typeof(InvalidOperationException))]
         public void RecursiveFill_SelfReferencing_Fails()
         {
             var filler = new Filler<TestSelf>();
+            filler.Setup().OnCircularReference().ThrowException();
             filler.Create();
         }
 
@@ -115,5 +121,39 @@ public void RecursiveFill_DuplicateProperty_Succeeds()
 
             Assert.IsNotNull(result);
         }
+
+        [TestMethod]
+        public void RecursiveFill_RecursiveType_Parent_First_Succeeds()
+        {
+            var filler = new Filler<TestParent>();
+            var r = filler.Create();
+            Assert.IsNull(r.Child.Parent.Child);
+        }
+
+        [TestMethod]
+        public void RecursiveFill_RecursiveType_Child_First_Succeeds()
+        {
+            var filler = new Filler<TestChild>();
+            var r = filler.Create();
+            Assert.IsNull(r.Parent.Child.Parent);
+
+        }
+
+        [TestMethod]
+        public void RecursiveFill_DeepRecursiveType_Succeeds()
+        {
+            var filler = new Filler<TestGrandParent>();
+            var r = filler.Create();
+            Assert.IsNull(r.SubObject.Child.Parent);
+        }
+
+        [TestMethod]
+        public void RecursiveFill_SelfReferencing_Succeeds()
+        {
+            var filler = new Filler<TestSelf>();
+            var r = filler.Create();
+
+            Assert.IsNull(r.Self.Self);
+        }
     }
 }

ObjectFiller/Filler.cs

@@ -290,10 +290,15 @@ private object GetFilledPoco(Type type, FillerSetupItem currentSetupItem, HashSt
             {
                 if (typeTracker.Contains(type))
                 {
-                    throw new InvalidOperationException(
-                        string.Format(
-                            "The type {0} was already encountered before, which probably means you have a circular reference in your model. Either ignore the properties which cause this or specify explicit creation rules for them which do not rely on types.",
-                            type.Name));
+                    if (currentSetupItem.ThrowExceptionOnCircularReference)
+                    {
+                        throw new InvalidOperationException(
+                                string.Format(
+                                    "The type {0} was already encountered before, which probably means you have a circular reference in your model. Either ignore the properties which cause this or specify explicit creation rules for them which do not rely on types.",
+                                    type.Name));
+                    }
+
+                    return GetDefaultValueOfType(type);
                 }
 
                 typeTracker.Push(type);
@@ -413,18 +418,23 @@ private object GetRandomValue(Type propertyType, FillerSetupItem setupItem)
 
             if (setupItem.IgnoreAllUnknownTypes)
             {
-                if (propertyType.IsValueType)
-                {
-                    return Activator.CreateInstance(propertyType);
-                }
-                return null;
+                return GetDefaultValueOfType(propertyType);
             }
 
             string message = "The type [" + propertyType.Name + "] was not registered in the randomizer.";
             Debug.WriteLine("ObjectFiller: " + message);
             throw new TypeInitializationException(propertyType.FullName, new Exception(message));
         }
 
+        private static object GetDefaultValueOfType(Type propertyType)
+        {
+            if (propertyType.IsValueType)
+            {
+                return Activator.CreateInstance(propertyType);
+            }
+            return null;
+        }
+
         private static bool TypeIsValidForObjectFiller(Type type, FillerSetupItem currentSetupItem)
         {
             return HasTypeARandomFunc(type, currentSetupItem)

ObjectFiller/ObjectFiller.csproj

@@ -39,6 +39,7 @@
     <Compile Include="Plugins\String\Lipsum.cs" />
     <Compile Include="HashStack.cs" />
     <Compile Include="Setup\FillerSetup.cs" />
+    <Compile Include="Setup\FluentCircularApi.cs" />
     <Compile Include="Setup\FluentFillerApi.cs" />
     <Compile Include="Setup\FluentPropertyApi.cs" />
     <Compile Include="Setup\FluentTypeApi.cs" />

ObjectFiller/Setup/FillerSetupItem.cs

@@ -105,5 +105,10 @@ private void SetDefaultRandomizer()
         /// </summary>
         internal bool IgnoreAllUnknownTypes { get; set; }
 
+        /// <summary>
+        /// True if an exception will be thrown if an circular reference occured
+        /// </summary>
+        public bool ThrowExceptionOnCircularReference { get; set; }
+
     }
 }

ObjectFiller/Setup/FluentCircularApi.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Tynamix.ObjectFiller.Setup
+{
+    public class FluentCircularApi<TTargetObject> where TTargetObject : class
+    {
+        private readonly FluentFillerApi<TTargetObject> _callback;
+        private readonly SetupManager _setupManager;
+
+        internal FluentCircularApi(FluentFillerApi<TTargetObject> callback, SetupManager setupManager)
+        {
+            _callback = callback;
+            _setupManager = setupManager;
+        }
+
+        /// <summary>
+        /// Call this when you want to get an exception in case of a circular reference in your filled model.
+        /// By default the ObjectFiller recognizes circular references and stop filling them without throwing an exception.
+        /// When you want to get an explicit exception on circular refernce call this method!
+        /// </summary>
+        /// <param name="throwException">True (default) when you want to get exception on a circular reference</param>
+        public FluentFillerApi<TTargetObject> ThrowException(bool throwException = true)
+        {
+            _setupManager.GetFor<TTargetObject>().ThrowExceptionOnCircularReference = throwException;
+
+            return _callback;
+        }
+    }
+}

ObjectFiller/Setup/FluentFillerApi.cs

@@ -3,6 +3,7 @@
 using System.Diagnostics;
 using System.Linq.Expressions;
 using System.Reflection;
+using Tynamix.ObjectFiller.Setup;
 
 namespace Tynamix.ObjectFiller
 {
@@ -34,6 +35,15 @@ public FluentTypeApi<TTargetObject, TTargetType> OnType<TTargetType>()
             return new FluentTypeApi<TTargetObject, TTargetType>(this, _setupManager);
         }
 
+
+        /// <summary>
+        /// Starts to configure the behaviour of the ObjectFiller when a circular reference in your model occurs
+        /// </summary>
+        public FluentCircularApi<TTargetObject> OnCircularReference()
+        {
+            return new FluentCircularApi<TTargetObject>(this, _setupManager);
+        }
+
         /// <summary>
         /// Starts to configure a property of the <see cref="TTargetObject"/> for objectfiller.
         /// So you can setup a custom randomizer to a specific property within a class.
@@ -159,5 +169,6 @@ public FluentFillerApi<TNewType> SetupFor<TNewType>(bool useDefaultSettings = fa
             return new FluentFillerApi<TNewType>(_setupManager);
         }
 
+
     }
 }

ObjectFiller/Setup/SetupManager.cs

@@ -7,8 +7,7 @@ namespace Tynamix.ObjectFiller
     /// Responsible to get the right <see cref="FillerSetupItem"/> for a given type.
     /// </summary>
     internal class SetupManager
-    {
-       
+    {       
         internal FillerSetup FillerSetup { get;  set; }
 
         /// <summary>