How to mock Nhibernate .ToListAsync() in Unit-test with moq?

Question

I'm trying create unit-tests in ASP.NET Core MVC application with moq. Unfortunately, Nhibernate.ToListAsync() is not supported Linq IQueryable dataset and throw System.NotSupportedException: 'Source Provider must be a INhQueryProvider'. In this code I mock INhQueryProvider, but it's not enough:

var entities = new List<RequestRole>
{
    new RequestRole()
    {
       Id = 0,
       RequestOperator = new RequestOperator() { Id = 1 }
    },
    new RequestRole()
    {
       Id = 1,
       RequestOperator = new RequestOperator() { Id = 2 }
     }
}
.AsQueryable();

// for ToListAsync Mock INhQueryProvider and set it into IQueryable
var queryableProviderMock = new Mock<INhQueryProvider>();
queryableProviderMock.Setup(x => x.ExecuteAsync<IEnumerable<RequestRole>>(It.IsAny<Expression>(), It.IsAny<CancellationToken>()))
                                 .ReturnsAsync(entities);

var queryableMock = new Mock<IQueryable<RequestRole>>();
queryableMock.Setup(x => x.Provider).Returns(queryableProviderMock.Object);
queryableMock.Setup(x => x.Expression).Returns(entities.Expression);
queryableMock.Setup(x => x.GetEnumerator()).Returns(entities.GetEnumerator());
queryableMock.Setup(x => x.ElementType).Returns(entities.ElementType);

// mock CreateQuery, without this Linq.Where throwing "System.NotSupportedException: 'Source Provider must be a INhQueryProvider'"
queryableProviderMock.As<INhQueryProvider>()
    .Setup(x => x.CreateQuery<RequestRole>(It.IsAny<Expression>()))
    .Returns(queryableMock.Object);

var session = new Mock<ISession>();
session.Setup(s => s.Query<RequestRole>()).Returns(queryableMock.Object);
var returns = session.Object.Query<RequestRole>();

// check work
var tolistasync = await returns
    .Where(x => x.Id != 0)
    .ToListAsync();

In this case Linq.Where conditions not working, because I set same object instead of filtered. Seems like I should correctly mock INhQueryProvider.CreateQuery, but how?

Answer 1

You'll need to instruct CreateQuery to use the expression. Just returning the mocked queryable isn't going to do anything as you've seen. Additionally CreateQuery is going to need to return an IQueryable with a provider that implements INhQueryProvider. The problem with that is the Provider property doesn't have a setter so you can't set it on an existing queryable.

The way I've solved a similar problem is to create my own sequence where I can set the provider.

Start with creating classes that implement IQueryable<T> and INhQueryProvider; for brevity I'm only implementing what is required to pass the OP use case. Note that CreateQuery<T> returns a queryable with a provider that implements INhQueryProvider:

public class TestingQueryable<T> : IQueryable<T>
{
    private readonly IQueryable<T> _queryable;

    public TestingQueryable(IQueryable<T> queryable)
    {
        _queryable = queryable;     
        Provider = new TestingQueryProvider<T>(_queryable);
    }

    public Type ElementType => _queryable.ElementType;

    public Expression Expression =>  _queryable.Expression;

    public IQueryProvider Provider { get; }

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

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

public class TestingQueryProvider<T> : INhQueryProvider
{
    public TestingQueryProvider(IQueryable<T> source)
    {
        Source = source;
    }

    public IQueryable<T> Source { get; set; }

    public IQueryable CreateQuery(Expression expression)
    {
        throw new NotImplementedException();
    }

    public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
    {
        return new TestingQueryable<TElement>(Source.Provider.CreateQuery<TElement>(expression));
    }

    public object Execute(Expression expression)
    {
        throw new NotImplementedException();
    }

    public TResult Execute<TResult>(Expression expression)
    {
        return Source.Provider.Execute<TResult>(expression);
    }

    public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken)
    {
        return Task.FromResult(Execute<TResult>(expression));
    }

    public int ExecuteDml<T1>(QueryMode queryMode, Expression expression)
    {
        throw new NotImplementedException();
    }

    public Task<int> ExecuteDmlAsync<T1>(QueryMode queryMode, Expression expression, CancellationToken cancellationToken)
    {
        throw new NotImplementedException();
    }

    public IFutureEnumerable<TResult> ExecuteFuture<TResult>(Expression expression)
    {
        throw new NotImplementedException();
    }

    public IFutureValue<TResult> ExecuteFutureValue<TResult>(Expression expression)
    {
        throw new NotImplementedException();
    }

    public void SetResultTransformerAndAdditionalCriteria(IQuery query, NhLinqExpression nhExpression, IDictionary<string, Tuple<object, IType>> parameters)
    {
        throw new NotImplementedException();
    }
}

Update your query provider setup to use your IQueryable implementation:

queryProviderMock
        .Setup(x => x.CreateQuery<RequestRole>(It.IsAny<Expression>()))
        .Returns((Expression providedExpression) =>
        {           
            return new TestingQueryable<RequestRole>(queryable.Provider.CreateQuery<RequestRole>(providedExpression));
        });

Run .Where(x => x.Id != 0).ToListAsync() and get the expected result:

Working example

You could take it further and just set up the ISession mock to use your IQueryable implementation, do away with mocking the query provider if you don't need to specifically mock it. I don't normally mock what a mock returns if you know what I mean so this would meet my peer review standards.

[Test]
public async Task Test2()
{
    var requestRoles = new List<RequestRole>();
    requestRoles.Add(new RequestRole { Id = 0, RequestOperator = new RequestOperator { Id = 1 } });
    requestRoles.Add(new RequestRole { Id = 1, RequestOperator = new RequestOperator { Id = 2 } });

    var sessionMock = new Mock<ISession>();
    sessionMock.Setup(s => s.Query<RequestRole>()).Returns(new TestingQueryable<RequestRole>(requestRoles.AsQueryable()));
    var query = sessionMock.Object.Query<RequestRole>();

    var result = await query.Where(x => x.Id != 0).ToListAsync();

    Assert.Multiple(() =>
    {
        Assert.That(result.Count, Is.EqualTo(1));
        Assert.That(result.Single(), Is.EqualTo(requestRoles.Last()));
    });
}