Added a static Builder<T> class to emulate NBuilder behaviour

README.md

@@ -79,6 +79,7 @@ Prior to v2.0 this library was known as NTestDataBuilder.
 		    }
 		}
 
+Note that you can optionally override the `BuildObject` method if you want full control over how your object is constructed, for example if you want to use a particular constructor. If you don't provide this then Dossier will create the object for you.
 
 3. Use the builder in a test, e.g.
 

TestStack.Dossier.Tests/BuilderBuildListTests.cs

@@ -0,0 +1,194 @@
+using System.Collections.Generic;
+using System.Linq;
+using Shouldly;
+using TestStack.Dossier.DataSources.Generators;
+using TestStack.Dossier.Lists;
+using TestStack.Dossier.Tests.Builders;
+using TestStack.Dossier.Tests.Entities;
+using Xunit;
+
+namespace TestStack.Dossier.Tests
+{
+    public class BuilderBuildListTests
+    {
+        [Fact]
+        public void GivenANormalBuilderInstance_WhenCallingIsListBuilderProxy_ThenReturnFalse()
+        {
+            var builder = Builder<Customer>.CreateNew();
+
+            builder.IsListBuilderProxy().ShouldBe(false);
+        }
+
+        [Fact]
+        public void GivenAListBuilderProxyInstance_WhenCallingIsListBuilderProxy_ThenReturnTrue()
+        {
+            var builder = Builder<Customer>.CreateListOfSize(1).TheFirst(1);
+
+            builder.IsListBuilderProxy().ShouldBe(true);
+        }
+
+        [Fact]
+        public void GivenListOfBuilders_WhenCallingBuildListExplicitly_ThenAListOfEntitiesOfTheRightSizeShouldBeReturned()
+        {
+            var builders = Builder<Customer>.CreateListOfSize(5);
+
+            var entities = builders.BuildList();
+
+            entities.Count.ShouldBe(5);
+        }
+
+        [Fact]
+        public void GivenListOfBuilders_WhenCallingBuildListImplicitly_ThenAListOfEntitiesOfTheRightSizeShouldBeReturned()
+        {
+            List<Customer> entities = Builder<Customer>.CreateListOfSize(5);
+
+            entities.Count.ShouldBe(5);
+        }
+
+        [Fact]
+        public void GivenListOfBuilders_WhenCallingBuildListExplicitly_ThenAListOfEntitiesOfTheRightTypeShouldBeReturned()
+        {
+            var builders = Builder<Customer>.CreateListOfSize(5);
+
+            var entities = builders.BuildList();
+
+            entities.ShouldBeAssignableTo<IList<Customer>>();
+        }
+
+        [Fact]
+        public void GivenListOfBuilders_WhenCallingBuildListImplicitly_ThenAListOfEntitiesOfTheRightTypeShouldBeReturned()
+        {
+            List<Customer> entities = Builder<Customer>.CreateListOfSize(5);
+
+            entities.ShouldBeAssignableTo<IList<Customer>>();
+        }
+
+        [Fact]
+        public void GivenListOfBuilders_WhenCallingBuildListExplicitly_ThenAListOfUniqueEntitiesShouldBeReturned()
+        {
+            var builders = Builder<Customer>.CreateListOfSize(5);
+
+            var entities = builders.BuildList();
+
+            entities[0].ShouldNotBe(entities[1]);
+            entities[0].ShouldNotBe(entities[2]);
+            entities[0].ShouldNotBe(entities[3]);
+            entities[0].ShouldNotBe(entities[4]);
+            entities[1].ShouldNotBe(entities[2]);
+            entities[1].ShouldNotBe(entities[3]);
+            entities[1].ShouldNotBe(entities[4]);
+            entities[2].ShouldNotBe(entities[3]);
+            entities[2].ShouldNotBe(entities[4]);
+            entities[3].ShouldNotBe(entities[4]);
+        }
+
+        [Fact]
+        public void GivenListOfBuilders_WhenCallingBuildListImplicitly_ThenAListOfUniqueEntitiesShouldBeReturned()
+        {
+            List<Customer> entities = Builder<Customer>.CreateListOfSize(5);
+
+            entities[0].ShouldNotBe(entities[1]);
+            entities[0].ShouldNotBe(entities[2]);
+            entities[0].ShouldNotBe(entities[3]);
+            entities[0].ShouldNotBe(entities[4]);
+            entities[1].ShouldNotBe(entities[2]);
+            entities[1].ShouldNotBe(entities[3]);
+            entities[1].ShouldNotBe(entities[4]);
+            entities[2].ShouldNotBe(entities[3]);
+            entities[2].ShouldNotBe(entities[4]);
+            entities[3].ShouldNotBe(entities[4]);
+        }
+
+        [Fact]
+        public void GivenListOfBuildersWithCustomisation_WhenBuildingEntitiesExplicitly_ThenTheCustomisationShouldTakeEffect()
+        {
+            var generator = new SequentialGenerator(0, 100);
+            var list = CustomerBuilder.CreateListOfSize(3)
+                .All().With(b => b.WithFirstName(generator.Generate().ToString()));
+
+            var data = list.BuildList();
+
+            data.Select(c => c.FirstName).ToArray()
+                .ShouldBe(new[] { "0", "1", "2" });
+        }
+
+        [Fact]
+        public void GivenListOfBuildersWithCustomisation_WhenBuildingEntitiesImplicitly_ThenTheCustomisationShouldTakeEffect()
+        {
+            var generator = new SequentialGenerator(0, 100);
+
+            List<Customer> data = CustomerBuilder.CreateListOfSize(3)
+                .All().With(b => b.WithFirstName(generator.Generate().ToString()));
+
+            data.Select(c => c.FirstName).ToArray()
+                .ShouldBe(new[] { "0", "1", "2" });
+        }
+
+        [Fact]
+        public void GivenListOfBuildersWithARangeOfCustomisationMethods_WhenBuildingEntitiesExplicitly_ThenThenTheListIsBuiltAndModifiedCorrectly()
+        {
+            var i = 0;
+            var customers = CustomerBuilder.CreateListOfSize(5)
+                .TheFirst(1).WithFirstName("First")
+                .TheNext(1).WithLastName("Next Last")
+                .TheLast(1).WithLastName("Last Last")
+                .ThePrevious(2).With(b => b.WithLastName("last" + (++i).ToString()))
+                .All().WhoJoinedIn(1999)
+                .BuildList();
+
+            customers.ShouldBeAssignableTo<IList<Customer>>();
+            customers.Count.ShouldBe(5);
+            customers[0].FirstName.ShouldBe("First");
+            customers[1].LastName.ShouldBe("Next Last");
+            customers[2].LastName.ShouldBe("last1");
+            customers[3].LastName.ShouldBe("last2");
+            customers[4].LastName.ShouldBe("Last Last");
+            customers.ShouldAllBe(c => c.YearJoined == 1999);
+        }
+
+        [Fact]
+        public void GivenListOfBuildersWithARangeOfCustomisationMethods_WhenBuildingEntitiesImplicitly_ThenThenTheListIsBuiltAndModifiedCorrectly()
+        {
+            var i = 0;
+            List<Customer> customers = CustomerBuilder.CreateListOfSize(5)
+                .TheFirst(1).WithFirstName("First")
+                .TheNext(1).WithLastName("Next Last")
+                .TheLast(1).WithLastName("Last Last")
+                .ThePrevious(2).With(b => b.WithLastName("last" + (++i).ToString()))
+                .All().WhoJoinedIn(1999);
+
+            customers.ShouldBeAssignableTo<IList<Customer>>();
+            customers.Count.ShouldBe(5);
+            customers[0].FirstName.ShouldBe("First");
+            customers[1].LastName.ShouldBe("Next Last");
+            customers[2].LastName.ShouldBe("last1");
+            customers[3].LastName.ShouldBe("last2");
+            customers[4].LastName.ShouldBe("Last Last");
+            customers.ShouldAllBe(c => c.YearJoined == 1999);
+        }
+
+        [Fact]
+        public void WhenBuildingEntitiesExplicitly_ThenTheAnonymousValueFixtureIsSharedAcrossBuilders()
+        {
+            var customers = CustomerBuilder.CreateListOfSize(5).BuildList();
+
+            customers[0].CustomerClass.ShouldBe(CustomerClass.Normal);
+            customers[1].CustomerClass.ShouldBe(CustomerClass.Bronze);
+            customers[2].CustomerClass.ShouldBe(CustomerClass.Silver);
+            customers[3].CustomerClass.ShouldBe(CustomerClass.Gold);
+            customers[4].CustomerClass.ShouldBe(CustomerClass.Platinum);
+        }
+
+        [Fact]
+        public void WhenBuildingEntitiesImplicitly_ThenTheAnonymousValueFixtureIsSharedAcrossBuilders()
+        {
+            List<Customer> customers = CustomerBuilder.CreateListOfSize(5);
+
+            customers[0].CustomerClass.ShouldBe(CustomerClass.Normal);
+            customers[1].CustomerClass.ShouldBe(CustomerClass.Bronze);
+            customers[2].CustomerClass.ShouldBe(CustomerClass.Silver);
+            customers[3].CustomerClass.ShouldBe(CustomerClass.Gold);
+            customers[4].CustomerClass.ShouldBe(CustomerClass.Platinum);
+        }
+    }
+}

TestStack.Dossier.Tests/BuilderBuildTests.cs

@@ -0,0 +1,56 @@
+using Shouldly;
+using TestStack.Dossier.Tests.Builders;
+using TestStack.Dossier.Tests.Entities;
+using Xunit;
+
+namespace TestStack.Dossier.Tests
+{
+    public class BuilderBuildTests
+    {
+        [Fact]
+        public void GivenBasicBuilder_WhenCallingBuildExplicitly_ThenReturnAnObject()
+        {
+            var builder = Builder<Customer>.CreateNew();
+
+            var customer = builder.Build();
+
+            customer.ShouldBeOfType<Customer>();
+        }
+
+        [Fact]
+        public void GivenBuilder_WhenCallingSetExplicitly_ShouldOverrideValues()
+        {
+            var builder = Builder<Customer>.CreateNew()
+                .Set(x => x.FirstName, "Pi")
+                .Set(x => x.LastName, "Lanningham")
+                .Set(x => x.YearJoined, 2014);
+
+            var customer = builder.Build();
+
+            customer.FirstName.ShouldBe("Pi");
+            customer.LastName.ShouldBe("Lanningham");
+            customer.YearJoined.ShouldBe(2014);
+        }
+
+        [Fact]
+        public void GivenBasicBuilder_WhenCallingBuildImplicitly_ThenReturnAnObject()
+        {
+            Customer customer = Builder<Customer>.CreateNew();
+
+            customer.ShouldBeOfType<Customer>();
+        }
+
+        [Fact]
+        public void GivenBuilder_WhenCallingSetImplicitly_ShouldOverrideValues()
+        {
+            Customer customer = Builder<Customer>.CreateNew()
+                .Set(x => x.FirstName, "Pi")
+                .Set(x => x.LastName, "Lanningham")
+                .Set(x => x.YearJoined, 2014);
+
+            customer.FirstName.ShouldBe("Pi");
+            customer.LastName.ShouldBe("Lanningham");
+            customer.YearJoined.ShouldBe(2014);
+        }
+    }
+}

TestStack.Dossier.Tests/GetAnonymousTests.cs

@@ -1,4 +1,5 @@
-using Shouldly;
+using System;
+using Shouldly;
 using TestStack.Dossier.DataSources.Person;
 using TestStack.Dossier.Lists;
 using TestStack.Dossier.Tests.Builders;
@@ -113,9 +114,20 @@ public bool CanSupplyValue<TObject, TValue>(string propertyName)
                    && propertyName.ToLower().StartsWith("year");
         }
 
+        public bool CanSupplyValue(Type type, string propertyName)
+        {
+            return type == typeof(int)
+                   && propertyName.ToLower().StartsWith("year");
+        }
+
         public TValue GenerateAnonymousValue<TObject, TValue>(AnonymousValueFixture any, string propertyName)
         {
             return (TValue)(object)_year++;
         }
+
+        public object GenerateAnonymousValue(AnonymousValueFixture any, Type type, string propertyName)
+        {
+            return _year++;
+        }
     }
 }

TestStack.Dossier.Tests/TestHelpers/StaticAnonymousValueSupplier.cs

@@ -1,4 +1,6 @@
-namespace TestStack.Dossier.Tests.TestHelpers
+using System;
+
+namespace TestStack.Dossier.Tests.TestHelpers
 {
     public class StaticAnonymousValueSupplier : IAnonymousValueSupplier
     {
@@ -14,9 +16,19 @@ public bool CanSupplyValue<TObject, TValue>(string propertyName)
             return typeof(TValue) == _valueToSupply.GetType();
         }
 
+        public bool CanSupplyValue(Type type, string propertyName)
+        {
+            return type == _valueToSupply.GetType();
+        }
+
         public TValue GenerateAnonymousValue<TObject, TValue>(AnonymousValueFixture any, string propertyName)
         {
             return (TValue) _valueToSupply;
         }
+
+        public object GenerateAnonymousValue(AnonymousValueFixture any, Type type, string propertyName)
+        {
+            return _valueToSupply;
+        }
     }
 }

TestStack.Dossier.Tests/TestStack.Dossier.Tests.csproj

@@ -54,6 +54,8 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="BuilderBuildListTests.cs" />
+    <Compile Include="BuilderBuildTests.cs" />
     <Compile Include="ChildBuilderTests.cs" />
     <Compile Include="Entities\CustomerClass.cs" />
     <Compile Include="DataSources\DataSourceTests.cs" />

TestStack.Dossier/AnonymousValueFixture.cs

@@ -82,13 +82,23 @@ public AnonymousValueFixture()
         /// <returns>The anonymous value, taking into account any registered conventions</returns>
         public T Get<TObject, T>(Expression<Func<TObject, T>> property)
         {
-            var propertyName = PropertyNameGetter.Get(property);
+            var propertyName = Reflector.GetPropertyFor(property);
             var valueSupplier = LocalValueSuppliers
                 .Concat(GlobalValueSuppliers)
                 .Concat(DefaultValueSuppliers)
-                .First(s => s.CanSupplyValue<TObject, T>(propertyName));
+                .First(s => s.CanSupplyValue(typeof(T), propertyName));
 
             return valueSupplier.GenerateAnonymousValue<TObject, T>(this, propertyName);
         }
+
+        public object Get(Type type, string propertyName)
+        {
+            var valueSupplier = LocalValueSuppliers
+                .Concat(GlobalValueSuppliers)
+                .Concat(DefaultValueSuppliers)
+                .First(s => s.CanSupplyValue(type,propertyName));
+
+            return valueSupplier.GenerateAnonymousValue(this, type, propertyName);
+        }
     }
 }

TestStack.Dossier/Builder.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace TestStack.Dossier
+{
+    public class Builder<T> : TestDataBuilder<T, Builder<T>>
+        where T : class
+    {
+        public static Builder<T> CreateNew()
+        {
+            return new Builder<T>();
+        } 
+    }
+}