Added alternative idea for the constructor factories so that the use of the factories is more explicit

Author: robdmoore

TestStack.Dossier.Tests/Builders/AutoConstructorCustomerBuilder.cs

@@ -5,9 +5,6 @@ namespace TestStack.Dossier.Tests.Builders
 {
     class AutoConstructorCustomerBuilder : TestDataBuilder<Customer, AutoConstructorCustomerBuilder>
     {
-        public AutoConstructorCustomerBuilder() 
-            : base(new ConstructorFactory()) { }
-
         public AutoConstructorCustomerBuilder WithFirstName(string firstName)
         {
             return Set(x => x.FirstName, firstName);
@@ -22,5 +19,10 @@ public AutoConstructorCustomerBuilder WhoJoinedIn(int year)
         {
             return Set(x => x.YearJoined, year);
         }
+
+        protected override Customer BuildObject()
+        {
+            return BuildUsing<ConstructorFactory>();
+        }
     }
 }

TestStack.Dossier.Tests/Builders/StudentViewModelBuilder.cs

@@ -1,4 +1,5 @@
 using System;
+using TestStack.Dossier.Factories;
 using TestStack.Dossier.Tests.Stubs.ViewModels;
 
 namespace TestStack.Dossier.Tests.Builders
@@ -19,5 +20,10 @@ public virtual StudentViewModelBuilder WhoEntrolledIn(DateTime enrollmentDate)
         {
             return Set(x => x.EnrollmentDate, enrollmentDate);
         }
+
+        protected override StudentViewModel BuildObject()
+        {
+            return BuildUsing<AllPropertiesFactory>();
+        }
     }
 }

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

@@ -98,12 +98,6 @@
       <SubType>Designer</SubType>
     </None>
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\TestStack.Dossier\TestStack.Dossier.csproj">
-      <Project>{01e4ee61-ab1a-4177-8b6c-d50205d167a9}</Project>
-      <Name>TestStack.Dossier</Name>
-    </ProjectReference>
-  </ItemGroup>
   <ItemGroup>
     <Content Include="SampleDictionaryFile.txt">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
@@ -112,6 +106,12 @@
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\TestStack.Dossier\TestStack.Dossier.csproj">
+      <Project>{01e4ee61-ab1a-4177-8b6c-d50205d167a9}</Project>
+      <Name>TestStack.Dossier</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

TestStack.Dossier/AnonymousValueFixture.cs

@@ -91,6 +91,12 @@ public T Get<TObject, T>(Expression<Func<TObject, T>> property)
             return valueSupplier.GenerateAnonymousValue<TObject, T>(this, propertyName);
         }
 
+        /// <summary>
+        /// Automatically generate an anonymous value for the given property expression.
+        /// </summary>
+        /// <param name="type">The type of the property</param>
+        /// <param name="propertyName">The name of the property</param>
+        /// <returns>The anonymous value, taking into account any registered conventions</returns>
         public object Get(Type type, string propertyName)
         {
             var valueSupplier = LocalValueSuppliers

TestStack.Dossier/Builder.cs

@@ -1,25 +1,67 @@
-using TestStack.Dossier.Factories;
+using Ploeh.AutoFixture.Kernel;
+using TestStack.Dossier.Factories;
+using TestStack.Dossier.Lists;
 
 namespace TestStack.Dossier
 {
     /// <summary>
-    /// A stand-alone class for building objects on the fly.
+    /// A generic Test Data Builder implementation for building objects on the fly.
+    /// By default 
     /// </summary>
     /// <typeparam name="T">The type of object this class generates.</typeparam>
     public class Builder<T> : TestDataBuilder<T, Builder<T>>
         where T : class
     {
+        /// <summary>
+        /// Default constructor.
+        /// </summary>
+        public Builder()
+        {
+            Factory = new AllPropertiesFactory();
+        }
+
+        private IFactory Factory { get; set; }
+
+        internal Builder<T> SetFactory(IFactory factory)
+        {
+            Factory = factory;
+            return this;
+        }
+
         /// <summary>
         /// Initialises a new Builder.
         /// </summary>
+        /// <param name="factory">The type of factory to use to construct the object, uses <see cref="AllPropertiesFactory"/> by default</param>
         /// <returns>Returns a new instance of a Builder for the type of T</returns>
         public static Builder<T> CreateNew(IFactory factory = null)
         {
-            if (factory == null)
+            return new Builder<T>
             {
-                factory = new AllPropertiesFactory();
-            }
-            return new Builder<T> {Factory = factory};
+                Factory = factory ?? new AllPropertiesFactory()
+            };
+        }
+
+        /// <summary>
+        /// Creates an list builder expression that allows you to create a list of entities.
+        /// You can call .First(x), .Last(x), etc. methods followed by chained builder method calls.
+        /// When you are done call .BuildList() to get the list of entities.
+        /// This override allows you to specify the factory that is used to construct the objects,
+        ///   the default implementation uses the <see cref="AllPropertiesFactory"/>.
+        /// </summary>
+        /// <param name="size">The size of list</param>
+        /// <param name="factory">The factory to use to construct the object</param>
+        /// <returns>The list builder for a list of {TBuilder} of the specified size</returns>
+        public static ListBuilder<T, Builder<T>> CreateListOfSize(int size, IFactory factory)
+        {
+            var lb = new ListBuilder<T, Builder<T>>(size);
+            lb.All().With(b => b.SetFactory(factory));
+            return lb;
         } 
+
+        /// <inheritdoc />
+        protected override T BuildObject()
+        {
+            return Factory.BuildObject(this);
+        }
     }
 }

TestStack.Dossier/Lists/EnsureAllMethodsVirtual.cs

@@ -13,7 +13,7 @@ public void MethodsInspected()
 
         public void NonProxyableMemberNotification(Type type, MemberInfo memberInfo)
         {
-            if (new[]{"get_Any", "set_Any", "Build", "AsProxy", "Get", "GetOrDefault", "Set", "Has", "get_ListBuilder", "set_ListBuilder"}.Contains(memberInfo.Name))
+            if (new[]{"get_Any", "set_Any", "Build", "AsProxy", "Get", "GetOrDefault", "Set", "Has", "get_ListBuilder", "set_ListBuilder", "BuildUsing", "SetFactory"}.Contains(memberInfo.Name))
                 return;
             throw new InvalidOperationException(string.Format("Tried to build a list with a builder who has non-virtual method. Please make {0} on type {1} virtual.", memberInfo.Name, type.Name));
         }

TestStack.Dossier/TestDataBuilder.cs

@@ -19,29 +19,15 @@ public abstract class TestDataBuilder<TObject, TBuilder>
         private ProxyBuilder<TObject> _proxyBuilder;
 
         /// <summary>
-        /// The factory used to create the instance of TObject.
-        /// </summary>
-        public IFactory Factory;
-
-        /// <summary>
-        /// The list builder instance (if this ia a list builder proxy).
+        /// The list builder instance (if this is a a list builder proxy).
         /// </summary>
         public ListBuilder<TObject, TBuilder> ListBuilder { get; internal set; } 
 
         /// <summary>
         /// Default Constructor.
         /// </summary>
         protected TestDataBuilder()
-            : this(new AllPropertiesFactory())
-        {
-        }
-
-        /// <summary>
-        /// Allow object builder factory to be passed in
-        /// </summary>
-        protected TestDataBuilder(IFactory factory)
         {
-            Factory = factory;
             Any = new AnonymousValueFixture();
         }
 
@@ -85,14 +71,21 @@ public static implicit operator List<TObject>(TestDataBuilder<TObject, TBuilder>
         }
 
         /// <summary>
-        /// Build the actual object - you can optionally override this and call the constructor and any other methods.
+        /// Build the actual object - you can call the <see cref="BuildUsing{TFactory}"/> method to quickly build a builder.
         /// </summary>
         /// <returns>The built object</returns>
-        protected virtual TObject BuildObject()
+        protected abstract TObject BuildObject();
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TFactory"></typeparam>
+        /// <returns></returns>
+        protected TObject BuildUsing<TFactory>()
+            where TFactory : IFactory, new()
         {
-            var model = Factory.BuildObject(this);
-            
-            return model;
+            var factory = new TFactory();
+            return factory.BuildObject(this);
         }
 
         /// <summary>