Mocking using MOQ and generic types

Question

Method to unit test: GetUserInfo

Following is the class containing the method:

public class AccountService : IAccountService
{
    IUnitOfWork _UnitOfWork;

    public AccountService(IUnitOfWork unitOfWork)
    {
        _UnitOfWork = unitOfWork;
    }

    public UserInfo GetUserInfo(string userName, string password)
    {
        var userInfo = new UserInfo();
        userInfo.UserType = UserType.Invalid;

   // Statement of interest
   var portalUser = _UnitOfWork.Repository<DvaPortalUser>().Query().Filter(t => t.Email == userName && t.Password == password).Get().FirstOrDefault();

        //....Rest of the code is not included for clarity
    }
}

The interface to mock IUnitOfWork:

public interface IUnitOfWork
{
    void Dispose();
    void Save();
    void Dispose(bool disposing);
    IRepository<T> Repository<T>() where T : class;
}

Repository Implementation:

public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
{

    public virtual RepositoryQuery<TEntity> Query()
    {
        var repositoryGetFluentHelper = new RepositoryQuery<TEntity>(this);

        return repositoryGetFluentHelper;
    }

  internal IEnumerable<TEntity> Get(
        Expression<Func<TEntity, bool>> filter = null,
        Func<IQueryable<TEntity>,
            IOrderedQueryable<TEntity>> orderBy = null,
        List<Expression<Func<TEntity, object>>>
            includeProperties = null,
        int? page = null,
        int? pageSize = null)
    {
        IQueryable<TEntity> query = DbSet;

        if (includeProperties != null)
            includeProperties.ForEach(i => query.Include(i));

        if (filter != null)
            query = query.Where(filter);

        if (orderBy != null)
            query = orderBy(query);

        if (page != null && pageSize != null)
            query = query
                .Skip((page.Value - 1)*pageSize.Value)
                .Take(pageSize.Value);


        return query.ToList();
    }
}

RepositoryQuery Implementation:

public sealed class RepositoryQuery<TEntity> where TEntity : class
{
    private readonly List<Expression<Func<TEntity, object>>> _includeProperties;

    private readonly Repository<TEntity> _repository;
    private Expression<Func<TEntity, bool>> _filter;
    private Func<IQueryable<TEntity>,
        IOrderedQueryable<TEntity>> _orderByQuerable;
    private int? _page;
    private int? _pageSize;

    public RepositoryQuery(Repository<TEntity> repository)
    {
        _repository = repository;
        _includeProperties = new List<Expression<Func<TEntity, object>>>();
    }

    public RepositoryQuery<TEntity> Filter(Expression<Func<TEntity, bool>> filter)
    {
        _filter = filter;
        return this;
    }


    public IEnumerable<TEntity> Get()
    {
        return _repository.Get(
            _filter,
            _orderByQuerable, _includeProperties, _page, _pageSize);
    }
}

Unit Test Method:

 [TestMethod]
 public void AccountService_GetUserInfo_SuccessfulLogin()
 {
    var  _UnitOfWork = new Mock<IUnitOfWork>();
    _AccountService = new AccountService(_UnitOfWork.Object);

    _UnitOfWork.Setup(a =>  a.Repository<T>())).Returns(??); //How do I setup this statement?
    _UnitOfWork.VerifyAll();
 }

Question: How do I setup mock call for the statement _UnitOfWork.Repository()?

Answer 1

I dont know how your IRepository<T> is implemented, but i gues your Query method returns a IEnumerable<T> or a list.

internal interface IRepository<T>
{
    IEnumerable<T> Query();
}

// your mock
_UnitOfWork.Setup(a =>  a.Repository<DvaPortalUser>())).Returns(() => new MyTestRepository());

1. Solution

Define a explicit implemtation of you repository.

// your implementation
public class MyTestRepository : IRepository<DvaPortalUser>
{
    public IEnumerable<DvaPortalUser> Query()
    {
       // return some test users (mocks)
       return new List<DvaPortalUser> {new DvaPortalUser(), new DvaPortalUser()};
    }
}

2. Solution (thanks to Yuliam Chandra)

Define a mock instead of the implemtation

var repository = new Mock<IRepository<DvaPortalUser>>(); 
// return some test users (mocks)
repository.Setup(a => a.Query()).Returns(new[] { new DvaPortalUser() });
_UnitOfWork.Setup(a =>  a.Repository<DvaPortalUser>()).Returns(repository.Object);

What you choose depends on your solution.