Generating Test Data in Entity Framework

I will be the first to admit that I have a love hate relationship with Entity Framework.  One of the things that I do love about Entity Framework is that it provides a seed method that it can automatically call for you after it runs data migrations.  When implemented, this method can be used to create test data in Entity Framework.  In many of the solutions I work on that use Entity Framework I use the seed method to create test data for my application.

Generating Test Data in Entity Framework

A simple way for generation test data in Entity Framework is to setup a static class that returns some objects, add these to the appropriate set in your context during the seed method, and saving the records.

Here’s is what this scenario might look like in code:

public static class ProductFactory
    {
        public static Product[] All()
        {
            return new Product[]
            {
                new Product() {Name = "Pipe Bender" },
                new Product() {Name = "Blender" },
                new Product() {Name = "Game Console" },
                new Product() {Name = "Frying Pan" },
                new Product() {Name = "TV" },
                new Product() {Name = "Ice Maker" },
                new Product() {Name = "Bookcase" }
            };
        }
    }

And the corresponding seed method may look like this:

context.AddRange(ProductFactory.All());
context.SaveChanges();

Pretty simple right?  Yup…but…(there’s always a but isn’t there!)  As our application continues to grow and we add more data models we begin to create lots of dependencies between our data because the over all complexity of our model is growing.  Pretty soon our seed method starts to look like this:

context.AddRange(ProductFactory.All())
context.AddRange(OrderFactory.All())
context.AddRange(SomeFactory.All())
context.AddRange(AnotherFactory.All())
context.AddRange(ShouldThisBeCalledFirst.All())
context.AddRange(ThisDependsOnALotOfThings.All())
context.AddRange(AmIDoingThisRight.All())

Ok maybe I got a little carried away there but hopefully you get the point.  Every time we add a model we need to make sure it is placed in the correct order.  What if we update an old model?  We may really have to reorganize things!  Let’s take a look at something I came up with for generating test data in entity framework that is simple and much more maintainable in the long run.

The Easy Way

For this example I setup a simple data model of Companies, Products, Orders, and Users.  I have also created something called ITestDataFactory<>.  This interface will force all of our test data factories to implement an All method.

public interface ITestDataFactory<T> where T : IEntity
    {
        T[] All();
    }

public class OrderTestDataFactory : ITestDataFactory<Order>
    {
        private Order[] _orders;
        private readonly DbContext _context;

        public OrderTestDataFactory(DbContext context)
        {
            _context = context;
        }

        public Order[] All()
        {
            return _orders ?? (_orders = Generate());
        }

        private Order[] Generate()
        {
            var orders = new List<Order>();
            _context.Set<Company>().ForEach(c => orders.Add(new Order() {Company = c, Number = $"{c.Name}-{new Guid().ToString()}", Products = _context.Set<Product>().ToList()}));

            return orders.ToArray();
        }
    }

The important thing to note here is that I am able to ensure that Companies and Product are both created and stored in my database before my Order factory is called.  This is done by my TestDataGenerator class which has one public method called Generate that will automatically call the the All method from each factory in the correct order and store the data.  I’ve even included c# 6 string interpolation in my example.  If you haven’t had a chance to look at it yet head over to Mike’s post on it to learn more: https://brosteins.com/2015/08/11/string-interpolation-in-c-6/

public void Generate()
        {
            var factories = Assembly.GetAssembly(typeof (ITestDataFactory<>)).GetTypes().Where(t => !t.IsInterface && t.GetInterfaces().Any(i => i.Name == typeof (ITestDataFactory<>).Name));
            var maxDepthList = _entityList.GroupBy(e => e.Item1).Select(g => new {Type = g.Key, Depth = g.Max(m => m.Item2)}).OrderByDescending(o => o.Depth).Select(i => i.Type);

            maxDepthList.ForEach(t =>
            {
                if (factories.Any(f => f.GetInterfaces()[0].GetGenericArguments()[0] == t) && _context.Set(t).ToListAsync(CancellationToken.None).Result.Count == 0)
                {
                    var factory = factories.FirstOrDefault(f => f.GetInterfaces()[0].GetGenericArguments()[0] == t);
                    var factoryObject = factory.GetConstructor(new Type[] {typeof (DbContext)}).Invoke(new object[] {_context});
                    var method = factory.GetMethod("All");
                    var result = method.Invoke(factoryObject, null);

                    _context.Set(t).AddRange((object[]) result);
                    _context.SaveChanges();
                }
            });
        }

And here is how we use it:

protected override void Seed(WebDbContext context)
        {
            var generator = new TestDataGenerator(new WebDbContext());

            generator.Generate();
        }

What is it Doing?

When we instantiate the TestDataGenerator it is scanning our assembly for anything that implements IEntity (this could be something different in your project).  Once all of our models are found then a dependency tree of sorts is built.  When the generate method is called we again scan our assembly for anything that implements ITestDataFactory<> (again this can be something different in your project) and we proceed to call these in the appropriate order (based on the dependencies found previously).

That’s it – nothing else too it.  If you’d like to take a look at the full source code it is over on github. Go ahead and try adding some additional models and factories yourself!

View on Github