Does it make any sense testing this? (Repository pattern)

Question

Getting started with TDD and the repository pattern, I'm wondering if it makes any sense testing this...

Using the repository pattern, I have this interface:

public interface ICustomerRepository
{
    IList<Customer> List();
    Customer Get(int id);
}

I have like 50 different entities, so 50 different repository interfaces/implementations.

My question is if it's correct to test each repository, by mocking up the interface, like:

[TestMethod]
public void List_Should_Return_Two_Customers()
{
    // Arrange
    var customerr = new List<Customer>();
    customer.Add(new Customer());
    customer.Add(new Customer());

    var repository = new Mock<ICustomerRepository>();
    repository.Setup(r => r.List()).Returns(customer);

    // Assert
    Assert.AreEqual(2, repository.Object.List().Count);
}

[TestMethod]
public void Get_Should_Return_One_Customer()
{
    // Arrange
    var customer = new List<Customer>();
    customerr.Add(new Customer() { Id = 1 });
    customerr.Add(new Customer() { Id = 2 });

    var repository = new Mock<ICustomerRepository>();
    repository.Setup(r => r.Get(1)).Returns(customer.Where(w => w.Id == 1).First());

    // Assert
    Assert.IsTrue(repository.Object.Get(1).Id == 1);
}

Does it make any sense testing a fake implementation of these interfaces? To me it does not.

Answer 1

Yes, it is "correct" to test each Repository. Repositories exist to abstract your database away from the code, and should be verified that they are working correctly. Your data access layer is arguably one of the most important components to test.

Answer 2

No, it does not make sense. Obviously you should test only implementations, not interfaces. There is nothing to test in an interface.

The only things being tested in your examples are the mocking framework, the .NET list and some LINQ extension methods. There is no need to test those, somebody else already takes care of that.

Maybe the intention was to provide unit tests for the fact that the interface exists and has certain methods? In that case, the tests are still unnecessary. This is implicitly tested by the tests for other code that relies on the interface declaration.

You should only create an ICustomerRepository mock when you need a fake implementation in order to test other code.

Answer 3

The others are right. You can't test interfaces. You are in fact testing mocks, and that doesn't make sense. Usually I test repositories against a database, so, not so much unit testing for them. And for testing anything above them I mock them. Keep in mind that 50 types of entities doesn't mean 50 repositories.

Regards.

Answer 4

Can I propose an alternate solution... As Simple as your Repository is (if they are all the same methods except for what they return) why don't you make a base class using Generics. Then you would only have to test the base class.

public interface IRepository<TEntity> where TEntity : class
{
    IList<TEntity> List();
    TEntity Get(int id);
}

public abstract class BaseRepository<TEntity> : IRepository<TEntity> where TEntity : class
{
    IList<TEntity> List()
    {
        //DataContext.GetTable<TEntity>().ToList();
    }

    TEntity Get(int id)
    {
        //Might have to do some magic here... you can use reflection or create
        //an abstract method that the derived class must override that returns
        //a delegate id selector.
    }
}