Merge pull request #2 from gokTyBalD/FEATURE_IgnoreProperties_by_Type

Added feature IgnoreAllOfType

Author: Roman K

ObjectFiller.Test/PersonFillingTest.cs

@@ -21,7 +21,7 @@ public void TestFillPerson()
 
             Assert.IsNotNull(filledPerson.Address);
             Assert.IsNotNull(filledPerson.Addresses);
-            Assert.IsNotNull(filledPerson.BlaToBla);
+            Assert.IsNotNull(filledPerson.StringToIAddress);
             Assert.IsNotNull(filledPerson.SureNames);
 
         }
@@ -106,6 +106,7 @@ public void TestSetupForTypeOverrideSettings()
             Assert.AreEqual(1, p.Age);
             Assert.AreNotEqual(1, p.Address.HouseNumber);
         }
+
         [TestMethod]
         public void TestSetupForTypeWithoutOverrideSettings()
         {
@@ -119,5 +120,53 @@ public void TestSetupForTypeWithoutOverrideSettings()
             Assert.AreEqual(1, p.Age);
             Assert.AreEqual(1, p.Address.HouseNumber);
         }
+
+        [TestMethod]
+        public void TestIgnoreAllOfType()
+        {
+            ObjectFiller<Person> pFiller = new ObjectFiller<Person>();
+            pFiller.Setup()
+                .RegisterInterface<IAddress, Address>()
+                .IgnoreAllOfType<string>()
+                ;
+
+            Person p = pFiller.Fill();
+
+            Assert.IsNotNull(p);
+            Assert.IsNull(p.FirstName);
+            Assert.IsNotNull(p.Address);
+            Assert.IsNull(p.Address.City);
+        }
+
+        [TestMethod]
+        public void TestIgnoreAllOfComplexType()
+        {
+            ObjectFiller<Person> pFiller = new ObjectFiller<Person>();
+            pFiller.Setup()
+                .RegisterInterface<IAddress, Address>()
+                .IgnoreAllOfType<Address>()
+                .IgnoreAllOfType<IAddress>()
+                ;
+            Person p = pFiller.Fill();
+
+            Assert.IsNotNull(p);
+            Assert.IsNull(p.Address);
+        }
+
+        [TestMethod]
+        public void TestIgnoreAllOfTypeDictionary()
+        {
+            ObjectFiller<Person> pFiller = new ObjectFiller<Person>();
+            pFiller.Setup()
+                .RegisterInterface<IAddress, Address>()
+                .IgnoreAllOfType<Address>()
+                .IgnoreAllOfType<IAddress>()
+                .IgnoreAllOfType<Dictionary<string, IAddress>>();
+            Person p = pFiller.Fill();
+
+            Assert.IsNotNull(p);
+            Assert.IsNull(p.Address);
+            Assert.IsNull(p.StringToIAddress);
+        }
     }
 }

ObjectFiller.Test/TestPoco/Person/Person.cs

@@ -19,12 +19,12 @@ public class Person
 
         public string Title { get; set; }
 
-        public Dictionary<string, IAddress> BlaToBla { get; set; }
+        public Dictionary<string, IAddress> StringToIAddress { get; set; }
 
         public IList<IAddress> Addresses { get; set; }
 
         public ICollection<IAddress> AddressCollection { get; set; }
 
-        public Dictionary<string, List<Address>> SenselessDictionary { get; set; }
+        public Dictionary<string, List<Address>> StringToListOfAddress { get; set; }
     }
 }

ObjectFiller/IFluentFillerApi.cs

@@ -49,7 +49,7 @@ public interface IFluentFillerApi<TTargetObject>
         /// <param name="property">The target property which will be filled by the customm <see cref="randomizerPlugin"/>.</param>
         /// <param name="additionalProperties">Some more properties which should be also filled by the custom <see cref="randomizerPlugin"/></param>
         /// <example>
-        ///   objectFiller.Setup()..RandomizerForProperty<Person, string>(new MnemonicStringPlugin(1), person => person.FirstName, person => person.LastName)
+        ///   objectFiller.Setup().RandomizerForProperty<Person, string>(new MnemonicStringPlugin(1), person => person.FirstName, person => person.LastName)
         /// </example>
         IFluentFillerApi<TTargetObject> RandomizerForProperty<TTargetType>(IRandomizerPlugin<TTargetType> randomizerPlugin, Expression<Func<TTargetObject, TTargetType>> property, params Expression<Func<TTargetObject, TTargetType>>[] additionalProperties);
 
@@ -60,11 +60,17 @@ public interface IFluentFillerApi<TTargetObject>
         /// <typeparam name="TTargetObject">The type of object where the target properties to ignore are located</typeparam>
         /// <param name="propertyToIgnore">Targetproperty to ignore</param>
         /// <param name="additionalProperties">OPTIONAL: Additional Properties which will be also ignored</param>
-        IFluentFillerApi<TTargetObject> IgnoreProperties(
-            Expression<Func<TTargetObject, object>> propertyToIgnore,
-            params Expression<Func<TTargetObject, object>>[] additionalProperties);
-        //  where TTargetObject : class;
+        IFluentFillerApi<TTargetObject> IgnoreProperties(Expression<Func<TTargetObject, object>> propertyToIgnore, params Expression<Func<TTargetObject, object>>[] additionalProperties);
 
+        /// <summary>
+        /// Ignore all properties of type <see cref="TTargetType"/> when generating Testdata.
+        /// </summary>
+        /// <typeparam name="TTargetType">Type which will be ignored</typeparam>
+        /// <example>
+        /// objectFiller.IgnoreAllOfType<string>();
+        /// </example>
+        IFluentFillerApi<TTargetObject> IgnoreAllOfType<TTargetType>();
+            
         /// <summary>
         /// Setup the maximum item count for lists. The ObjectFiller will not generate more listitems then this.
         /// The default value is 25.

ObjectFiller/ObjectFiller.cs

@@ -111,6 +111,11 @@ private void FillInternal(object objectToFill)
 
             foreach (PropertyInfo property in properties)
             {
+                if (currentSetup.TypesToIgnore.Contains(property.PropertyType))
+                {
+                    continue;
+                }
+
                 if (IgnoreProperty(property, currentSetup))
                 {
                     continue;

ObjectFiller/ObjectFillerApi.cs

@@ -126,6 +126,20 @@ public IFluentFillerApi<TTargetObject> IgnoreProperties(Expression<Func<TTargetO
             return this;
         }
 
+        /// <summary>
+        /// Ignore all properties of type <see cref="TTargetType"/> when generating Testdata 
+        /// </summary>
+        /// <typeparam name="TTargetType">Type which will be ignored</typeparam>
+        /// <example>
+        /// objectFiller.IgnoreAllOfType<string>();
+        /// </example>
+        public IFluentFillerApi<TTargetObject> IgnoreAllOfType<TTargetType>()
+        {
+            SetupManager.GetFor<TTargetObject>().TypesToIgnore.Add(typeof (TTargetType));
+
+            return this;
+        }
+
 
         /// <summary>
         /// Setup the maximum item count for lists. The ObjectFiller will not generate more listitems then this.

ObjectFiller/ObjectFillerSetup.cs

@@ -19,6 +19,7 @@ public ObjectFillerSetup()
             TypeToRandomFunc = new Dictionary<Type, Func<object>>();
             PropertyToRandomFunc = new Dictionary<PropertyInfo, Func<object>>();
             ProperiesToIgnore = new List<PropertyInfo>();
+            TypesToIgnore = new List<Type>();
 
             InterfaceToImplementation = new Dictionary<Type, Type>();
 
@@ -71,6 +72,11 @@ private void SetDefaultRandomizer()
         /// </summary>
         public List<PropertyInfo> ProperiesToIgnore { get; private set; }
 
+        /// <summary>
+        /// All types which will be ignored completly
+        /// </summary>
+        public List<Type> TypesToIgnore { get; private set; }
+
         /// <summary>
         /// Minimum count of list items which will be generated 
         /// </summary>