How can I mock a repository and unit of work pattern in Entity Framework?

Question

I am new in Moq and Unit Testing. I want to test my Repository and Unit of Work pattern with entity framework 5. But I don't understand where and how can I start.

My Repository Interface :

public interface ISmRepository<T>
{
    void Add(T entity);
    void Remove(T entity);
    void Update(T entity);
    IQueryable<T> SearchFor(Expression<Func<T, bool>> expression);
    IQueryable<T> GetAll();
    T GetById(Int64 id);
} 

My Repository:

public class SmReporitory<T> : ISmRepository<T> where T : class, IEntity, new()
{
    private readonly DbSet<T> _dbSet;
    private readonly DbContext _dbContext;

    public SmReporitory(DbContext dbContext)
    {
        _dbSet = dbContext.Set<T>();
        _dbContext = dbContext;
    }

    public void Add(T entity)
    {
        _dbSet.Add(entity);
    }

    public void Remove(T entity)
    {
        _dbSet.Remove(entity);
    }

    public void Update(T entity)
    {
        _dbContext.Entry(entity).State = EntityState.Modified;
    }

    public IQueryable<T> SearchFor(Expression<Func<T, bool>> expression)
    {
        return _dbSet.Where(expression);
    }

    public IQueryable<T> GetAll()
    {
        return _dbSet;
    }

    public T GetById(long id)
    {
        return _dbSet.FirstOrDefault(x => x.Id == id);
    }
}

My Unit Of Work Interface :

public interface ISmUnitOfWork : IDisposable
{
    ISmRepository<BreakdownCause> BreakdownCasus { get; }
    ISmRepository<BreakDownType> BreakDownTypes { get; }
    ISmRepository<CompanyInformation> CompanyInformations { get; }
    void Save();
}

My Unit Of Work Implementation :

public class SmUnitOfWork : ISmUnitOfWork
{
    private readonly DbContext _dbContext;
    private ISmRepository<BreakDownType> _breakDownTypes;
    private ISmRepository<BreakdownCause> _breakdownCasus;
    private ISmRepository<CompanyInformation> _companyInformations;

    public SmUnitOfWork() : this(new SmDbContext())
    {
    }

    public SmUnitOfWork(SmDbContext smDbContext)
    {
        _dbContext = smDbContext;
    }

    public ISmRepository<BreakdownCause> BreakdownCasus
    {
        get { return _breakdownCasus ?? (_breakdownCasus = new SmReporitory<BreakdownCause>(_dbContext)); }
    }

    public ISmRepository<BreakDownType> BreakDownTypes
    {
        get { return _breakDownTypes ?? (_breakDownTypes = new SmReporitory<BreakDownType>(_dbContext)); }
    }

    public ISmRepository<CompanyInformation> CompanyInformations
    {
        get { return _companyInformations ?? (_companyInformations = new SmReporitory<CompanyInformation>(_dbContext)); }
    }
    public void Save()
    {
        try
        {
            _dbContext.SaveChanges();
        }
        catch
        {
            throw;
        }
    }
    public void Dispose()
    {
        if (_dbContext!=null)
        {
            _dbContext.Dispose();
        }
    }

Now I want to test ISmRepository interfaces method's.

I already referenced NUnit and Moq in a class library project. Now I need a starting point.

Answer 1

You really don't need to test your repositories as you have them written. The reason is that, as Mystere Man alluded, you're basically just wrapping the Entity Framework API. When working with EF and using either my own repositories or some DbContext I don't worry about testing these data access calls until integration testing time for the reasons already stated.

However, you can (and should) certainly mock your repositories and unit of work to test all of your other code that has dependencies on them. By testing your repositories you're really testing Entity Framework functionality and I'm sure that has been tested more thoroughly than you will. One thing you can do is not put business logic into your repositories that directly interact with EF but instead move that out to another layer that utilizes your repositories for data access.