This project is read-only.


AutoPoco is a highly configurable framework for the purpose of fluently building readable test data from Plain Old CLR Objects

Created originally for the personal use of @robashton, it has since gained popularity and new features are being added all the time.


AutoPoco development has now changed hands. I have now taken over the project so that Rob can go onto bigger and better things. I am currently working on fixing some bugs and some light refactoring. Will be releasing a new version soon.

Still working on the new version. Will be looking at releasing this soon though


AutoPoco replaces manually written object mothers/test data builders with a fluent interface and an easy way to generate a large amount of readable test data. By default, no manual set-up is required, conventions can then be written against the names/types of property or manual configuration can be used against specific objects.

The primary use cases are
  • Creating single, valid objects for unit tests in a standard manner across all tests
  • Creating large amounts of valid test data for database population

The default data sources and convention is to perform set up once on start-up, and create a 'generation session' for each test that is run, every session will generate repeatable test data so no flickering tests.

// Perform factory set up (once for entire test run)
IGenerationSessionFactory factory = AutoPocoContainer.Configure(x =>
    x.Conventions(c =>

// Generate one of these per test (factory will be a static variable most likely)
IGenerationSession session = factory.CreateSession();

// Get a single user
SimpleUser user = session.Single<SimpleUser>().Get();

// Get a collection of users
List<SimpleUser> users = session.List<SimpleUser>(100).Get();

// Get a collection of users, but set their role manually
               .Impose(x => x.Role, sharedRole)

Head to the Documentation to get started.


  • Generates the same pseudo-random data per session, so your tests don't "flicker"
  • Convention based configuration to set up defaults on un-specified properties/fields
  • Convention based configuration to match names/types on properties/fields that match a certain pattern
  • Fluent configuration to set up data sources for meaningful data such as e-mail addresses/names
  • Fluent interfaces to generate lists/single objects with all properties automatically populated
  • Ability to override conventions + configuration at object-creation time with manually specified values
  • Support for method invocation as part of an object's initialisation both automatically via configuration and at object-creation time
  • Support for the inheritance of rules from base classes/interfaces

Quick Examples

Member Conventions

Define a rule for all string properties called EmailAddress
public class EmailAddressPropertyConvention : ITypePropertyConvention
    public void Apply(ITypePropertyConventionContext context)

    public void SpecifyRequirements(ITypeMemberConventionRequirements requirements)
        requirements.Name(x => String.Compare(x, "EmailAddress", true) == 0);
        requirements.Type(x => x == typeof(String));

Optionally Setting up data sources for an object

Make the properties get their data from the specified sources on creation
Call the SetPassword method with a password source on creation
                   .Setup(c => c.EmailAddress).Use<EmailAddressSource>()
                   .Setup(c => c.FirstName).Use<FirstNameSource>()
                   .Setup(c => c.LastName).Use<LastNameSource>()
                   .Invoke(c => c.SetPassword(
                      Use.Source<String, PasswordSource>()));

Simple Object Creation

Create a user populated with defaults - all properties will be set (including other complex objects)
            SimpleUser user = mSession.Single<SimpleUser>().Get();

More Complex Object Creation

Create a role for a collection of users and ask for a list of users using that single role

           SimpleUserRole sharedRole = mSession.Single<SimpleUserRole>()
               .Impose(x=>x.Name, "Shared Role")

               .Impose(x => x.Role, sharedRole)

Hardcore Object Creation

Create three roles
Create 100 users
The first 50 of those users will be called Rob Ashton
The last 50 of those users will be called Luke Smith
25 Random users will have RoleOne
A different 25 random users will have RoleTwo
And the other 50 users will have RoleThree
And set the password on every single user to Password1

            SimpleUserRole roleOne = mSession.Single<SimpleUserRole>()
                              .Impose(x => x.Name, "RoleOne").Get();
            SimpleUserRole roleTwo = mSession.Single<SimpleUserRole>()
                              .Impose(x => x.Name, "RoleTwo").Get();
            SimpleUserRole roleThree = mSession.Single<SimpleUserRole>()
                              .Impose(x => x.Name, "RoleThree").Get();

                      .Impose(x => x.FirstName, "Rob")
                      .Impose(x => x.LastName, "Ashton")
                      .Impose(x => x.FirstName, "Luke")
                      .Impose(x => x.LastName, "Smith")
                      .Impose(x => x.Role,roleOne)
                      .Impose(x => x.Role,roleTwo)
                      .Impose(x => x.Role, roleThree)
                      .Invoke(x => x.SetPassword("Password1"))

Last edited May 15, 2014 at 9:25 PM by dalefrancis88, version 70