Moq - setup Where extension?

Question

How to set up where linq extension on object? DbSet in my case. Here is my code:

this.workflowStateSet
   .Setup(m => m.Where(It.IsAny<Expression<Func<Model.WorkflowState, int, bool>>>()))
   .Returns(new List<Model.WorkflowState>().AsQueryable());

However, it gives me exception not very familiar exception:

System.NotSupportedException: Expression references a method that does not belong to the mocked object: m => m.Where<WorkflowState>

I will be grateful for any hint.

Answer 1

This extension method will help mock the DbSet

public static class MockDbSetExtensions {
    public static Mock<DbSet<T>> AsDbSetMock<T>(this IEnumerable<T> list) where T : class {
        IQueryable<T> queryableList = list.AsQueryable();
        Mock<DbSet<T>> dbSetMock = new Mock<DbSet<T>>();
        dbSetMock.As<IQueryable<T>>().Setup(x => x.Provider).Returns(queryableList.Provider);
        dbSetMock.As<IQueryable<T>>().Setup(x => x.Expression).Returns(queryableList.Expression);
        dbSetMock.As<IQueryable<T>>().Setup(x => x.ElementType).Returns(queryableList.ElementType);
        dbSetMock.As<IQueryable<T>>().Setup(x => x.GetEnumerator()).Returns(() => queryableList.GetEnumerator());
        return dbSetMock;
    }
}

And you can use it like this.

//Arrange
var data = new List<Model.WorkflowState>();
//you would populate your list as needed.
//convert it to a mock DbSet that uses the list as its datasource
var workflowStateSet = data.AsDbSetMock(); 
var dbSet = workflowStateSet.Object;

//Act
var items = dbSet.Where("Your expression here");

//Assert
//....

Answer 2

Use the repository pattern to add a layer of abstraction to the data retrieval. This abstraction can then be mocked.

If, for example, you were trying to retrieve all of the workflows with a stateId equal to 1, then rather than calling something like this

var result = DbSet.WorkflowState.Where(w => w.stateId == 1);

move this code into another class and then create an interface of the method signature.

public interface IWorkflowStateSetRepository{

     IQueryable<Model.WorkflowState> GetAllWorkflows(int state);
}

implementation

public class WorkflowStateSetRepository : IWorkflowStateSetRepository{

    public IQueryable<Model.WorkflowState> GetAllWorkflows(int state){
        return DbSet.WorkflowState .Where(w => w.stateId == state);
    }
}

In the calling code get an instance of IWorkflowStateSetRepository (probably from your IoC container) and call the GetAllWorkflows() method instead. This will give you the same results as before but you can now mock the interface in your tests and setup calls to that methods.

this.MockedIWorkflowStateSetRepository.Setup(m => m.GetAllWorkflows(It.IsAny<int>()))
        .Returns(new List<Model.WorkflowState>().AsQueryable());

This code is more maintainable and (with appropriately named variables and methods) also conveys the intent a lot better.

---

The repository pattern is discussed in greater detail here;

http://www.asp.net/mvc/overview/older-versions/getting-started-with-ef-5-using-mvc-4/implementing-the-repository-and-unit-of-work-patterns-in-an-asp-net-mvc-application

Answer 3

Are you trying to Mock up a real DbSet instance ? Cause this won't work, as the error message try to explain you. To mock a type, it must either be an interface or have virtual members (abstract members are also virtual).

You can try to mock up IDbSet or to create a custom DbSet class, for instance something like the following class

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Entity;
using System.Linq;
using System.Linq.Expressions;

public class DbSetMock<T> : DbSet<T>, IDbSet<T>
    where T : class
{
    private readonly ICollection<T> _contentCollection;

    public DbSetMock(IList<T> contentCollection = null)
    {
        _contentCollection = new Collection<T>(contentCollection ?? new List<T>());
        AddedEntities = new List<T>();
        RemovedEntities = new List<T>();
        AttachedEntities = new List<T>();
    }

    public void OverrideContentCollection(IEnumerable<T> newData)
    {
        _contentCollection.Clear();
        _contentCollection.AddRange(newData);
    }

    public IList<T> AddedEntities { get; private set; }

    public IList<T> AttachedEntities { get; private set; }

    public override ObservableCollection<T> Local
    {
        get
        {
            throw new NotImplementedException();
        }
    }

    public IList<T> RemovedEntities { get; private set; }

    public Type ElementType
    {
        get
        {
            return typeof(T);
        }
    }

    public Expression Expression
    {
        get
        {
            return _contentCollection.AsQueryable().Expression;
        }
    }

    public IQueryProvider Provider
    {
        get
        {
            return _contentCollection.AsQueryable().Provider;
        }
    }

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

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

    public override T Add(T entity)
    {
        AddedEntities.Add(entity);
        _contentCollection.Add(entity);
        return entity;
    }

    public override T Attach(T entity)
    {
        AttachedEntities.Add(entity);

        var matchingEntity = _contentCollection.SingleOrDefault(x => x.Id == entity.Id);
        if (matchingEntity != null)
        {
            _contentCollection.Remove(matchingEntity);
        }

        _contentCollection.Add(entity);

        return entity;
    }

    public override TDerivedEntity Create<TDerivedEntity>()
    {
        throw new NotImplementedException();
    }

    public override T Create()
    {
        throw new NotImplementedException();
    }

    public override T Find(params object[] keyValues)
    {
        throw new NotImplementedException();
    }

    public override T Remove(T entity)
    {
        RemovedEntities.Add(entity);
        _contentCollection.Remove(entity);
        return entity;
    }
}

You can use constructor parameter to setup content that will be retrieved by the db set.

Hope this helps.