NSubstitute DbSet / IQueryable

Question

So EntityFramework 6 is a lot better testable then previous versions. And there are some nice examples on the internet for frameworks like Moq, but the case is, I prefer using NSubstitute. I've got the "non-query" examples translated to work with the use of NSubstitute, but I can't get my head around the 'query-test'.

How does Moq's items.As<IQueryable<T>>().Setup(m => m.Provider).Returns(data.Provider); translate to NSubstitute? I thought something like ((IQueryable<T>) items).Provider.Returns(data.Provider); but that didn't work. I've also tried items.AsQueryable().Provider.Returns(data.Provider); but that didn't work either.

The exeption I'm getting is:

"System.NotImplementedException : The member 'IQueryable.Provider' has not been implemented on type 'DbSet1Proxy' which inherits from 'DbSet1'. Test doubles for 'DbSet`1' must provide implementations of methods and properties that are used."

So let me quote the code example from the link above. This code sample uses Moq to mock the DbContext and DbSet.

public void GetAllBlogs_orders_by_name()
{
  // Arrange
  var data = new List<Blog>
  {
     new Blog { Name = "BBB" },
     new Blog { Name = "ZZZ" },
     new Blog { Name = "AAA" },
  }.AsQueryable();

  var mockSet = new Mock<DbSet<Blog>>();
  mockSet.As<IQueryable<Blog>>().Setup(m => m.Provider).Returns(data.Provider);
  mockSet.As<IQueryable<Blog>>().Setup(m => m.Expression).Returns(data.Expression);
  mockSet.As<IQueryable<Blog>>().Setup(m => m.ElementType).Returns(data.ElementType);
  mockSet.As<IQueryable<Blog>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

  var mockContext = new Mock<BloggingContext>();
  mockContext.Setup(c => c.Blogs).Returns(mockSet.Object);

  // ...
}

And this is how far I come with NSubstitute

public void GetAllBlogs_orders_by_name()
{
  // Arrange
  var data = new List<Blog>
  {
     new Blog { Name = "BBB" },
     new Blog { Name = "ZZZ" },
     new Blog { Name = "AAA" },
  }.AsQueryable();

  var mockSet = Substitute.For<DbSet<Blog>>();
  // it's the next four lines I don't get to work
  ((IQueryable<Blog>) mockSet).Provider.Returns(data.Provider);
  ((IQueryable<Blog>) mockSet).Expression.Returns(data.Expression);
  ((IQueryable<Blog>) mockSet).ElementType.Returns(data.ElementType);
  ((IQueryable<Blog>) mockSet).GetEnumerator().Returns(data.GetEnumerator());

  var mockContext = Substitute.For<BloggingContext>();
  mockContext.Blogs.Returns(mockSet);

  // ...
}

So the question is; How does one Substitute a property of IQueryable (like Provider)?

Answer 1

This happens because of NSubstitute syntax specific. For example in:

((IQueryable<Blog>) mockSet).Provider.Returns(data.Provider);

NSubstitute calls the Provider's getter, then it specifies the return value. This getter call isn't intercepted by the substitute and you get an exception. It happens because of explicit implementation of IQueryable.Provider property in DbQuery class.

You can explicitly create substitutes for multiple interfaces with NSub, and it creates a proxy which covers all specified interfaces. Then calls to the interfaces will be intercepted by the substitute. Please use the following syntax:

// Create a substitute for DbSet and IQueryable types:
var mockSet = Substitute.For<DbSet<Blog>, IQueryable<Blog>>();
    
// And then as you do:
((IQueryable<Blog>) mockSet).Provider.Returns(data.Provider);
((IQueryable<Blog>) mockSet).Expression.Returns(data.Expression);
((IQueryable<Blog>) mockSet).ElementType.Returns(data.ElementType);
((IQueryable<Blog>) mockSet).GetEnumerator().Returns(data.GetEnumerator());

Answer 2

Thanks to Kevin, I've found the problem in my code translation.

The unittest code samples are mocking DbSet, but NSubstitute requires the interface implementation. So the equivalent of Moqs new Mock<DbSet<Blog>>() for NSubstitute is Substitute.For<IDbSet<Blog>>(). You're not always required to provide the Interface, so that's why I was confused. But in this specific case, it turned out to be crucial.

It also turned out that we don't have to cast to Queryable when using the interface IDbSet.

So the working test code:

public void GetAllBlogs_orders_by_name()
{
  // Arrange
  var data = new List<Blog>
  {
    new Blog { Name = "BBB" },
    new Blog { Name = "ZZZ" },
    new Blog { Name = "AAA" },
  }.AsQueryable();

  var mockSet = Substitute.For<IDbSet<Blog>>();
  mockSet.Provider.Returns(data.Provider);
  mockSet.Expression.Returns(data.Expression);
  mockSet.ElementType.Returns(data.ElementType);
  mockSet.GetEnumerator().Returns(data.GetEnumerator());

  var mockContext = Substitute.For<BloggingContext>();
  mockContext.Blogs.Returns(mockSet);

  // Act and Assert ...
}

I've written a small extention method to cleanup the Arrange section of the unit tests.

public static class ExtentionMethods
{
    public static IDbSet<T> Initialize<T>(this IDbSet<T> dbSet, IQueryable<T> data) where T : class
    {
        dbSet.Provider.Returns(data.Provider);
        dbSet.Expression.Returns(data.Expression);
        dbSet.ElementType.Returns(data.ElementType);
        dbSet.GetEnumerator().Returns(data.GetEnumerator());
        return dbSet;
    }
}

// usage like:
var mockSet = Substitute.For<IDbSet<Blog>>().Initialize(data);

Not the question, but in case you also need to be able to support async operations:

public static IDbSet<T> Initialize<T>(this IDbSet<T> dbSet, IQueryable<T> data) where T : class
{
  dbSet.Provider.Returns(data.Provider);
  dbSet.Expression.Returns(data.Expression);
  dbSet.ElementType.Returns(data.ElementType);
  dbSet.GetEnumerator().Returns(data.GetEnumerator());

  if (dbSet is IDbAsyncEnumerable)
  {
    ((IDbAsyncEnumerable<T>) dbSet).GetAsyncEnumerator()
      .Returns(new TestDbAsyncEnumerator<T>(data.GetEnumerator()));
    dbSet.Provider.Returns(new TestDbAsyncQueryProvider<T>(data.Provider));
  }

  return dbSet;
}

// create substitution with async
var mockSet = Substitute.For<IDbSet<Blog>, IDbAsyncEnumerable<Blog>>().Initialize(data);
// create substitution without async
var mockSet = Substitute.For<IDbSet<Blog>>().Initialize(data);

Answer 3

This is my static generic static method to generate fake DbSet. It may by useful.

 public static class CustomTestUtils
{
    public static DbSet<T> FakeDbSet<T>(List<T> data) where T : class
    {
        var _data = data.AsQueryable();
        var fakeDbSet = Substitute.For<DbSet<T>, IQueryable<T>>();
        ((IQueryable<T>)fakeDbSet).Provider.Returns(_data.Provider);
        ((IQueryable<T>)fakeDbSet).Expression.Returns(_data.Expression);
        ((IQueryable<T>)fakeDbSet).ElementType.Returns(_data.ElementType);
        ((IQueryable<T>)fakeDbSet).GetEnumerator().Returns(_data.GetEnumerator());

        fakeDbSet.AsNoTracking().Returns(fakeDbSet);

        return fakeDbSet;
    }

}

Answer 4

I wrote a wrapper about a year ago around the same code you are referencing from Testing with Your Own Test Doubles (EF6 onwards). This wrapper can be found on GitHub DbContextMockForUnitTests. The purpose of this wrapper is to reduce the amount of repetitive/duplicate code needed to setup unit tests that make use of EF where you want to mock that DbContext and DbSets. Most of the mock EF code you have in the OP can reduced down to a 2 lines of code (and only 1 if you are using DbContext.Set<T> instead of DbSet properties) and the mock code is then called in the wrapper.

To use it copy and include the files in folder MockHelpers to your Test project.

Here is an example test using what you had above, notice that there is now only 2 Lines of code are needed to setup the mock DbSet<T> on the mocked DbContext.

public void GetAllBlogs_orders_by_name()
{
  // Arrange
  var data = new List<Blog>
  {
     new Blog { Name = "BBB" },
     new Blog { Name = "ZZZ" },
     new Blog { Name = "AAA" },
  };

  var mockContext = Substitute.For<BloggingContext>();

  // Create and assign the substituted DbSet
  var mockSet = data.GenerateMockDbSet();
  mockContext.Blogs.Returns(mockSet);

  // act
}

It is just as easy to make this a test that invokes something that uses the async/await pattern like .ToListAsync() on the DbSet<T>.

public async Task GetAllBlogs_orders_by_name()
{
  // Arrange
  var data = new List<Blog>
  {
     new Blog { Name = "BBB" },
     new Blog { Name = "ZZZ" },
     new Blog { Name = "AAA" },
  };

  var mockContext = Substitute.For<BloggingContext>();

  // Create and assign the substituted DbSet
  var mockSet = data.GenerateMockDbSetForAsync(); // only change is the ForAsync version of the method
  mockContext.Blogs.Returns(mockSet);

  // act
}

Answer 5

Using MockQueryable.NSubstitute it is very easy to mock DbSet.

You can do it as follows:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using AutoMapper;
using Fridge.API.Core.Entities;
using Fridge.API.Core.Interfaces.Persistence;
using Fridge.Application.Features.UserManagement.Queries.GetUser;
using Microsoft.EntityFrameworkCore;
using MockQueryable.NSubstitute;
using NSubstitute;
using NSubstitute.Core;
using NUnit.Framework;

namespace Fridge.Application.UnitTests.Features.UserManagement.Queries.GetUser;

[TestFixture]
public class GetUserQueryHandlerTests
{
    private IAppDbContext _dbContext = null!;
    private IMapper _mapper = null!;

    private GetUserQueryHandler _handler = null!;


    [SetUp]
    protected void BeforeEach()
    {
        _dbContext = Substitute.For<IAppDbContext>();
        _mapper = Substitute.For<IMapper>();

        _handler = new GetUserQueryHandler(_dbContext, _mapper);
    }

    [Test]
    public async Task Handler_WhenUserDoesNotExists_ReturnsResponseFailure()
    {
        // Arrange
        var users = Array.Empty<User>().AsQueryable();
        var usersDbSet = users.BuildMockDbSet();
        _dbContext.Users.Returns(usersDbSet);

        // Act
        var response = await _handler.Handle(new GetUserQuery(Guid.NewGuid()), CancellationToken.None);

        // Assert
        Assert.Multiple(() =>
        {
            Assert.That(response.Succeed, Is.False);
            Assert.That(response.Value, Is.Null);
            Assert.That(response.Error.Code, Is.EqualTo((int)HttpStatusCode.NotFound));
            Assert.That(response.Error.Message, Is.EqualTo("Could not found user"));
            Assert.That(response.Error.Name, Is.EqualTo(nameof(HttpStatusCode.NotFound)));
        });
    }
}

I wanted to mock an empty array but you can fill it with entries and mock return data the same way.

Answer 6

You shouldn't need to mock all of the pieces of the IQueryable. When I use NSubstitute for mocking an EF DbContext I do something like so:

interface IContext
{
  IDbSet<Foo> Foos { get; set; }
}

var context = Substitute.For<IContext>();

context.Foos.Returns(new MockDbSet<Foo>());

With a simple implementation of IDbSet around a list or something for my MockDbSet().

In general you should be mocking interfaces, not types as NSubstitute will only override virtual methods.

Answer 7

When you use something like

MyDbContext.CounterpartyDbSet.AsQuariable()    // or AsNoTracking()
    .bla().bla().bla()

you can walk by simple way:

var counterpartyList = new List<Counterparty>()
{ 
    // some items here;
}

var myDbContext = Substitute.For<IMyDbContext>();
var counterpartySet = Substitute.For<DbSet<Counterparty>>();
counterpartySet.AsQueryable()    // or AsNoTracking()
    .Returns(counterpartyList.AsQueryable());
myDbContext.CounterpartyDbSet.Returns(counterpartySet);