I have been working with Entity Framework for awhile now and start to like it more and more.
Until now we have always run unit tests on the Entity Framework model itself, no mocking was used yet.

But ofcourse, for unit testing, we all know it can be pretty powerful to use any kind of mocking framework (such as Moq, the one I will be using).
Mocking is made possible by using interfaces in your application, but as you might have noticed… Our generated ObjectContext will not inherit any interface (depending on your T4 templates ofcourse):

public partial class ShopEntities : ObjectContext
{
// Some Code left out
/// <summary>
        /// No Metadata Documentation available.
        /// </summary>
        public ObjectSet<Order> Orders
        {
            get
            {
                if ((_Orders == null))
                {
                    _Orders = base.CreateObjectSet<Order>("Orders");
                }
                return _Orders;
            }
        }
        private ObjectSet<Order> _Orders;
    
        /// <summary>
        /// No Metadata Documentation available.
        /// </summary>
        public ObjectSet<Product> Products
        {
            get
            {
                if ((_Products == null))
                {
                    _Products = base.CreateObjectSet<Product>("Products");
                }
                return _Products;
            }
        }
        private ObjectSet<Product> _Products;
    
        /// <summary>
        /// No Metadata Documentation available.
        /// </summary>
        public ObjectSet<User> Users
        {
            get
            {
                if ((_Users == null))
                {
                    _Users = base.CreateObjectSet<User>("Users");
                }
                return _Users;
            }
        }
        private ObjectSet<User> _Users;
}

So while writing unit tests we can not mock our ShopEntities class and therefor are dependent on the database entries. This means that if the amount of users in the database is not equal to 2, the following unit test will fail.

[TestMethod()]
public void GetUsersTest()
{
    ShopEntities context = new ShopEntities();
    ShopRepository shopRepositories = new ShopRepository(context);

    var users = shopRepositories.GetUsers();

    Assert.AreEqual(users.Count, 2);
}

To fix this, you can make use of an interface from which our ShopEntities will inherit. This interface will declare the signatures of the “ObjetSet” (IObjectSet eventually) properties, these are the ones we call to get specific data from our datasource using linq to entities and therefor the ones we, eventually, want to mock.
Ofcourse you can create this interface using T4 templates, but I will focus on the interface here instead of generating it through T4 templates. (I will try to create a blog post about T4 templating pretty soon).

What we want is an interface like this:

public interface IObjectContext
{
    IObjectSet<Order> Orders { get; }

    IObjectSet<Product> Products { get; }

    IObjectSet<User> Users { get; }
}

and an ObjectContext like this:

public partial class ShopEntities : ObjectContext, IObjectContext
{
// Some Code left out
/// <summary>
        /// No Metadata Documentation available.
        /// </summary>
        public IObjectSet<Order> Orders
        {
            get
            {
                if ((_Orders == null))
                {
                    _Orders = base.CreateObjectSet<Order>("Orders");
                }
                return _Orders;
            }
        }
        private IObjectSet<Order> _Orders;
    
        /// <summary>
        /// No Metadata Documentation available.
        /// </summary>
        public IObjectSet<Product> Products
        {
            get
            {
                if ((_Products == null))
                {
                    _Products = base.CreateObjectSet<Product>("Products");
                }
                return _Products;
            }
        }
        private IObjectSet<Product> _Products;
    
        /// <summary>
        /// No Metadata Documentation available.
        /// </summary>
        public IObjectSet<User> Users
        {
            get
            {
                if ((_Users == null))
                {
                    _Users = base.CreateObjectSet<User>("Users");
                }
                return _Users;
            }
        }
        private IObjectSet<User> _Users;
}

As you can see I have used IObjectSet instead of ObjectSet, this is because at the end we want to create our own “ObjectSet” implementing the IObjectSet interface.
Because ObjectSet can not be used to store values in memory, we will be faking our own IObjectSet upon testing.
Since we are using IObjectSet inside the IObjectContext interface and the ShopEntities ObjectContext, we will be able to Mock our own IObjectSet implementation.

Now our entity framework is set up to be mockable!

Create the Unit Tests

As I said, we make use of a fake IObjectSet implementation while mocking: MoqObjectSet

public class MoqObjectSet<T> : IObjectSet<T> where T : class
    {
        public MoqObjectSet()
            : this(Enumerable.Empty<T>())
        {
        }

        public MoqObjectSet(IEnumerable<T> entities)
        {
            _set = new HashSet<T>();
            foreach (var entity in entities)
            {
                _set.Add(entity);
            }
            _queryableSet = _set.AsQueryable();
        }

        public void AddObject(T entity)
        {
            _set.Add(entity);
        }

        public void Attach(T entity)
        {
            _set.Add(entity);
        }

        public void DeleteObject(T entity)
        {
            _set.Remove(entity);
        }

        public void Detach(T entity)
        {
            _set.Remove(entity);
        }

        public Type ElementType
        {
            get { return _queryableSet.ElementType; }
        }

        public Expression Expression
        {
            get { return _queryableSet.Expression; }
        }

        public IQueryProvider Provider
        {
            get { return _queryableSet.Provider; }
        }

        public IEnumerator<T> GetEnumerator()
        {
            return _set.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        readonly HashSet<T> _set;
        readonly IQueryable<T> _queryableSet;
    }

Now we are able to mock our ObjectContext while writing unit tests and passing the mocked Object Context to our Repository

public class ShopRepository : IShopRepository
{
    private readonly IObjectContext _context;

    public ShopRepository()
    {
        _context = new ShopEntities();
    }

    public ShopRepository(IObjectContext context)
    {
        _context = context;
    }

    public IList<User> GetUsers()
    {
        return _context.Users.ToList();
    }

    public User GetUserById(int id)
    {
        return _context.Users.SingleOrDefault(u => u.id == id);
    }
}

[TestMethod()]
public void MoqGetUsersTest()
{
    // Create Fake user Data, this will replace our Database entries.
    var userList = new List<User>
    {
        new User() { id=1, username = "Frederik", password = "test" },
        new User() { id=2, username = "Admin", password = "test2" }
    };

    // Create a new instance of the MoqObjectSet class, this will be our mocked replacement for the IObjectSet Users property
    IObjectSet<User> moqUserObjectSet = new MoqObjectSet<User>(userList);

    // Create mock for IObjectContextand bind the Users property to our mocked "MoqObjectSet" implementation
    var mockContext = new Mock<IObjectContext>();
    mockContext.Setup(m => m.Users).Returns(moqUserObjectSet);

    // Tests
    var shopRepository = new ShopRepository(mockContext.Object);

    Assert.AreEqual(shopRepository.GetUsers().Count, 2);
    Assert.AreEqual(shopRepository.GetUserById(2).username, "Admin");

}

As you can see, in the above unit test we create a MoqObjectSet based on our List of User collection.
This IObjectSet implementation is then bound to the IObjectContext.Users property, meaning that our repository will now be querying this set of Users instead of my Sql database.
That is why we can now compare the result to the expected result based on the List of User collection: 2 entries and the user with id 2 has the “Admin” username.

Now, editing or adding database entries will not affect this unit test in any way!

Using Include

If you come to a point where you turn of lazy loading and you want to control the Included navigation properties, you will find out this is not working.
The reason for this is we are working with IObjectSet implementations instead of ObjectSet’s. IObjectSet does not support the use of Include, which is why we will provide our own Include method by creating an extension method:

public static class Extensions
{
    public static IQueryable<TSource> Include<TSource>(this IQueryable<TSource> source, string path)
    {
        var objectQuery = source as ObjectQuery<TSource>;

        if (objectQuery != null)
        {
            return objectQuery.Include(path);
        }

        return source;
    }
}

Now you can use the Include method as how you would use it with ObjectSet’s

public class ShopRepository : IShopRepository
{
    private readonly IObjectContext _context;

    public ShopRepository()
    {
        _context = new ShopEntities();
    }

    public ShopRepository(IObjectContext context)
    {
        _context = context;
    }

    public IList<User> GetUsers()
    {
        return _context.Users.Include("Orders").ToList();
    }

    public User GetUserById(int id)
    {
        return _context.Users.Include("Orders").SingleOrDefault(u => u.id == id);
    }
}

Source code and Database can be found at github.