Merge pull request #3 from DyegoMaas/feature/fill-with-property-names-behavior

New behavior: FillWithSequentialValuesBehavior

Author: DyegoMaas

README.md

@@ -174,9 +174,40 @@ private class ProductFactory : MagicFactory<Product>
 
 By default, it will not fill any properties, and it is up to you to fill any properties.
 
+#### FillWithSequentialValuesBehavior
+
+With this behavior, ForeverFactory will recursively initialize every property it can with sequential values. This is similar to the default behavior of NBuilder:
+
+```csharp
+var people = MagicFactory
+    .For<ClassWithInteger>()
+    .WithBehavior(new FillWithSequentialValuesBehavior())
+    .Many(100)
+    .Build();
+   
+people[0].Name.Should().Be("Name1");
+people[0].Age.Should().Be(1);
+people[0].Address.ZipCode.Should().Be("ZipCode1");
+people[1].Name.Should().Be("Name2");
+people[1].Age.Should().Be(2);
+people[1].Address.ZipCode.Should().Be("ZipCode2");
+
+public class Customer
+{
+    public string Name { get; set; }
+    public int Age { get; set; }
+    public Address Address { get; set; } 
+}
+
+public class Address
+{
+    public string ZipCode { get; set; }
+}
+```
+
 #### FillWithEmptyValuesBehavior
 
-With this behavior, ForeverFactory will recursively initialize every property it can. For example, the following class structure will resolve as shown below?
+With this behavior, ForeverFactory will recursively initialize every property it can with empty values. For example, the following class structure will resolve as shown below?
 
 ```csharp
 public class Customer
@@ -196,15 +227,17 @@ public class Address
 The table below shows test done with Benchmark Dotnet tool comparing equivalent scenarios in both `Forever Factory` and `NBuilder`:
 
 ```csv
-|                               Method |           Mean |        Error |       StdDev |   Gen 0 |   Gen 1 | Allocated |
-|------------------------------------- |---------------:|-------------:|-------------:|--------:|--------:|----------:|
-|      BuildSingleObjectForeverFactory |       683.6 ns |      7.34 ns |      6.86 ns |  0.1373 |       - |   1,152 B |
-|            BuildSingleObjectNBuilder |     1,939.7 ns |     20.81 ns |     19.47 ns |  0.0935 |       - |     784 B |
-|   BuildThousandObjectsForeverFactory |   243,524.0 ns |  3,502.33 ns |  2,924.61 ns | 53.7109 |  5.8594 | 449,403 B |
-|         BuildThousandObjectsNBuilder | 1,555,241.7 ns | 17,075.19 ns | 14,258.56 ns | 76.1719 | 15.6250 | 653,402 B |
+|                                                    Method |           Mean |        Error |       StdDev |   Gen 0 |   Gen 1 | Allocated |
+|---------------------------------------------------------- |---------------:|-------------:|-------------:|--------:|--------:|----------:|
+|                           BuildSingleObjectForeverFactory |       658.8 ns |      8.06 ns |      6.73 ns |  0.1373 |       - |   1,152 B |
+|                                 BuildSingleObjectNBuilder |     1,764.0 ns |      8.72 ns |      8.16 ns |  0.0935 |       - |     784 B |
+|                        BuildThousandObjectsForeverFactory |   255,085.5 ns |  1,757.46 ns |  1,643.93 ns | 53.7109 |  5.8594 | 449,403 B |
+|                              BuildThousandObjectsNBuilder | 1,447,481.4 ns | 20,004.55 ns | 18,712.27 ns | 76.1719 | 15.6250 | 653,390 B |
+| BuildThousandObjectsFillingSequentialValuesForeverFactory |   524,209.5 ns |  3,039.96 ns |  2,538.51 ns | 80.0781 | 15.6250 | 673,170 B |
+|       BuildThousandObjectsFillingSequentialValuesNBuilder |   984,430.7 ns |  7,177.55 ns |  6,362.71 ns | 70.3125 | 13.6719 | 589,282 B |
 ```
 
-The code to the tests is found [here](/tests/Benchmarks/Program.cs).
+The code to the tests is found [here](tests/Benchmarks/Program.cs).
 
 ## How to contribute
 
@@ -233,7 +266,5 @@ dotnet stryker
 
 - Allow to configure custom builder per builder (single builder and many builder)
 - Support custom constructor scoped by builder (for now, custom constructors are shared along the linked builders)
-- Allow configuration by rules
-- Allow sequences in numbers properties and things like email, etc
 - Support "smart" behavior, which identifies by convention which type of sequences and rules to apply to every property 
 - Add the concept of "Localization Extensions", which could contain localized versions of the fluent API, translated for other languages, like, portuguese, spanish, etc

src/ForeverFactory/Behaviors/DoNotFillBehavior.cs

@@ -4,6 +4,10 @@
 
 namespace ForeverFactory.Behaviors
 {
+    /// <summary>
+    /// This behavior do not fill automatically any properties. After instantiation, all properties of the object
+    /// will have default values.
+    /// </summary>
     public class DoNotFillBehavior : Behavior
     {
         public override IEnumerable<Transform<T>> GetTransforms<T>()

src/ForeverFactory/Behaviors/FillWithEmptyValuesBehavior.cs

@@ -1,14 +1,42 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using ForeverFactory.Generators.Transforms;
 using ForeverFactory.Generators.Transforms.Factories;
 
 namespace ForeverFactory.Behaviors
 {
+    /// <summary>
+    /// This behavior will automatically set all string properties do "".
+    /// Nested types will also be recursively initialized.
+    /// </summary>
     public class FillWithEmptyValuesBehavior : Behavior
     {
+        private readonly RecursiveTransformFactoryOptions _recursiveTransformFactoryOptions;
+
+        public FillWithEmptyValuesBehavior(Action<FillWithEmptyValuesBehaviorOptions> options = null)
+        {
+            var configuration = new FillWithEmptyValuesBehaviorOptions();
+            options?.Invoke(configuration);
+
+            _recursiveTransformFactoryOptions = new RecursiveTransformFactoryOptions
+            {
+                EnableRecursiveInstantiation = configuration.Recursive
+            };
+        }
+
         public override IEnumerable<Transform<T>> GetTransforms<T>()
         {
-            yield return TransformFactory.FillWithEmptyValues<T>();
+            var factory = new FillWithEmptyStringTransformFactory(_recursiveTransformFactoryOptions);
+            yield return factory.GetTransform<T>();
         }
     }
+
+    public class FillWithEmptyValuesBehaviorOptions
+    {
+        /// <summary>
+        /// If enabled, nested classes will be instantiated and all its properties will be set with "".
+        /// Default is true.
+        /// </summary>
+        public bool Recursive { get; set; } = true;
+    }
 }

src/ForeverFactory/Behaviors/FillWithSequentialValuesBehavior.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using ForeverFactory.Generators.Transforms;
+using ForeverFactory.Generators.Transforms.Factories;
+
+namespace ForeverFactory.Behaviors
+{
+    /// <summary>
+    /// This behavior will automatically set all properties sequential values.
+    /// Nested objects will also be recursively initialized.  
+    /// </summary>
+    /// <example>
+    /// var persons = MagicFactory.For<ClassWithInteger>().Many(100).Build();
+    /// person[0].Name == "Name1"
+    /// person[0].Age == "1"
+    /// person[1].Name == "Name2"
+    /// person[1].Age == "2"
+    /// ...
+    /// </example>
+    public class FillWithSequentialValuesBehavior : Behavior
+    {
+        private readonly RecursiveTransformFactoryOptions _recursiveTransformFactoryOptions;
+
+        public FillWithSequentialValuesBehavior(Action<FillWithSequentialValuesBehaviorOptions> options = null)
+        {
+            var configuration = new FillWithSequentialValuesBehaviorOptions();
+            options?.Invoke(configuration);
+
+            _recursiveTransformFactoryOptions = new RecursiveTransformFactoryOptions
+            {
+                EnableRecursiveInstantiation = configuration.Recursive
+            };
+        }
+        
+        public override IEnumerable<Transform<T>> GetTransforms<T>()
+        {
+            var factory = new FillWithSequentialValuesTransformFactory(_recursiveTransformFactoryOptions);
+            yield return factory.GetTransform<T>();
+        }
+    }
+    
+    public class FillWithSequentialValuesBehaviorOptions
+    {
+        /// <summary>
+        /// If enabled, nested classes will be instantiated and all its properties will be set with sequential values.
+        /// Default is true.
+        /// </summary>
+        public bool Recursive { get; set; } = true;
+    }
+}

src/ForeverFactory/Generators/GeneratorNode.cs

@@ -60,7 +60,7 @@ private void ApplyTransformsToInstance(IEnumerable<GuardedTransform<T>> guardedT
         {
             foreach (var guardedTransform in guardedTransforms)
                 if (guardedTransform.Guard.CanApply(instanceIndex))
-                    guardedTransform.Transform.ApplyTo(instance);
+                    guardedTransform.Transform.ApplyTo(instance, instanceIndex);
         }
     }
 }

src/ForeverFactory/Generators/Transforms/Factories/BaseRecursiveTransformFactory.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Linq;
+using System.Reflection;
+
+namespace ForeverFactory.Generators.Transforms.Factories
+{
+    internal abstract class BaseRecursiveTransformFactory : ITranformFactory
+    {
+        private readonly RecursiveTransformFactoryOptions _options;
+
+        protected BaseRecursiveTransformFactory(RecursiveTransformFactoryOptions options = null)
+        {
+            _options = options ?? new RecursiveTransformFactoryOptions();
+        }
+
+        public Transform<T> GetTransform<T>()
+            where T : class
+        {
+            var setMember = new Func<T, int, object>((instance, index) =>
+            {
+                FillPropertiesRecursively(instance, typeof(T), index);
+                return instance;
+            });
+            return new ReflectedFuncTransform<T>(setMember);
+        }
+        
+        private void FillPropertiesRecursively(object instance, IReflect type, int index)
+        {
+            var propertyInfos = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+            foreach (var propertyInfo in propertyInfos)
+            {
+                var buildFunction = GetBuildFunction(propertyInfo, index);
+                if (buildFunction == null)
+                    continue;
+
+                var propertyValue = buildFunction.Invoke();
+                propertyInfo.SetValue(instance, propertyValue);
+
+                if (CanApplyRecursion(propertyInfo))
+                    FillPropertiesRecursively(propertyValue, propertyInfo.PropertyType, index);
+            }
+        }
+
+        private Func<object> GetBuildFunction(PropertyInfo propertyInfo, int index)
+        {
+            var buildFunction = GetBuildFunctionForSpecializedProperty(propertyInfo, index);
+            if (buildFunction != null)
+                return buildFunction;
+
+            if (_options.EnableRecursiveInstantiation is false)
+                return null;
+
+            var parameterlessConstructor = propertyInfo.PropertyType
+                .GetConstructors()
+                .FirstOrDefault(x => x.GetParameters().Length == 0);
+            if (parameterlessConstructor != null) 
+                return () => parameterlessConstructor.Invoke(Array.Empty<object>());
+
+            return null;
+        }
+
+        protected abstract Func<object> GetBuildFunctionForSpecializedProperty(PropertyInfo propertyInfo, int index);
+
+        private bool CanApplyRecursion(PropertyInfo propertyInfo)
+        {
+            return _options.EnableRecursiveInstantiation && propertyInfo.PropertyType != typeof(string);
+        }
+    }
+}

src/ForeverFactory/Generators/Transforms/Factories/FillWithEmptyStringTransformFactory.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Reflection;
+
+namespace ForeverFactory.Generators.Transforms.Factories
+{
+    internal class FillWithEmptyStringTransformFactory : BaseRecursiveTransformFactory
+    {
+        public FillWithEmptyStringTransformFactory(RecursiveTransformFactoryOptions options = null) 
+            : base(options)
+        {
+        }
+
+        protected override Func<object> GetBuildFunctionForSpecializedProperty(PropertyInfo propertyInfo, int index)
+        {
+            if (propertyInfo.PropertyType == typeof(string)) 
+                return () => string.Empty;
+
+            return null;
+        }
+    }
+}

src/ForeverFactory/Generators/Transforms/Factories/FillWithSequentialValuesTransformFactory.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Reflection;
+
+namespace ForeverFactory.Generators.Transforms.Factories
+{
+    internal class FillWithSequentialValuesTransformFactory : BaseRecursiveTransformFactory
+    {
+        public FillWithSequentialValuesTransformFactory(RecursiveTransformFactoryOptions options = null) 
+            : base(options)
+        {
+        }
+
+        protected override Func<object> GetBuildFunctionForSpecializedProperty(PropertyInfo propertyInfo, int index)
+        {
+            var sequentialNumber = index + 1;
+            
+            if (propertyInfo.PropertyType == typeof(string)) 
+                return () => propertyInfo.Name + sequentialNumber;
+            
+            if (propertyInfo.PropertyType == typeof(byte))
+                return () =>
+                {
+                    if (sequentialNumber > byte.MaxValue)
+                        return (byte)(sequentialNumber % byte.MaxValue);
+                    return (byte)sequentialNumber;
+                };
+            
+            if (propertyInfo.PropertyType == typeof(short))
+                return () =>
+                {
+                    if (sequentialNumber > short.MaxValue)
+                        return (short)(sequentialNumber % short.MaxValue);
+                    return (short)sequentialNumber;
+                };
+            
+            if (propertyInfo.PropertyType == typeof(ushort))
+                return () =>
+                {
+                    if (sequentialNumber > ushort.MaxValue)
+                        return (ushort)(sequentialNumber % ushort.MaxValue);
+                    return (ushort)sequentialNumber;
+                };
+            
+            if (propertyInfo.PropertyType == typeof(int))
+                return () => sequentialNumber;
+            
+            if (propertyInfo.PropertyType == typeof(uint))
+                return () => (uint)sequentialNumber;
+            
+            if (propertyInfo.PropertyType == typeof(long))
+                return () => sequentialNumber;
+            
+            if (propertyInfo.PropertyType == typeof(ulong))
+                return () => (ulong)sequentialNumber;
+            
+            if (propertyInfo.PropertyType == typeof(float))
+                return () => sequentialNumber;
+            
+            if (propertyInfo.PropertyType == typeof(double))
+                return () => sequentialNumber;
+            
+            if (propertyInfo.PropertyType == typeof(decimal))
+                return () => Convert.ToDecimal(sequentialNumber);
+
+            return null;
+        }
+    }
+}

src/ForeverFactory/Generators/Transforms/Factories/ITranformFactory.cs

@@ -0,0 +1,8 @@
+namespace ForeverFactory.Generators.Transforms.Factories
+{
+    internal interface ITranformFactory
+    {
+        Transform<T> GetTransform<T>() 
+            where T : class;
+    }
+}

src/ForeverFactory/Generators/Transforms/Factories/RecursiveTransformFactoryOptions.cs

@@ -0,0 +1,7 @@
+namespace ForeverFactory.Generators.Transforms.Factories
+{
+    internal class RecursiveTransformFactoryOptions
+    {
+        public bool EnableRecursiveInstantiation { get; set; } = true;
+    }
+}