Moqing Enity Framework 6 .Include() using DbSet<>

entity-framework linq unit-testing


I'd want to explain the context of this query. If you'd rather, skip. I've been paying close attention to the ongoing discussions about code testing as it applies to EF on stackoverflow and other forums for a while now. One group advises testing directly against a database due to variations in Linq to Objects and Sql implementations. Another advises to fake the test.

The question of employing repositories or acknowledging that DbContext and DbSet already offer a unit of work and repository structure has also generated disagreement. I've tried just about every combination of viewpoints offered by these camps during the period I've used EF. Despite all I've tried, EF continues to be challenging to test.

I was happy to discover that the EF team had created More mockable DbSet in EF 6. Additionally, they provide instructions on how to fake DbSet, including async functions utilizing Moq. When working on my most recent Web API project, I came to the realization that I could avoid constructing repositories because their primary purpose is to make things testable if I could mock EF. After reading a few blog entries like this..., inspiration struck.

Background complete

The true issue is that whenever.Include() is used in any code after the example code provided by the EF team on how to utilize Moq DbSet, an ArgumentNullException is issued.

Various linked SO post

Here is my DbContext interface:

public interface ITubingForcesDbContext
    DbSet<WellEntity> Wells { get; set; }

    int SaveChanges();

    Task<int> SaveChangesAsync();

    Task<int> SaveChangesAsync(CancellationToken cancellationToken);

My controller primarily interacts with this thing.

public class WellEntity
    public int Id { get; set; }
    public DateTime DateUpdated { get; set; }
    public String UpdatedBy { get; set; }

    public string Name { get; set; }
    public string Location { get; set; }

    public virtual Company Company { get; set; }

    public virtual ICollection<GeometryItem> GeometryItems
        get { return _geometryItems ?? (_geometryItems = new Collection<GeometryItem>()); }
        protected set { _geometryItems = value; }
    private ICollection<GeometryItem> _geometryItems;

    public virtual ICollection<SurveyPoint> SurveyPoints
        get { return _surveyPoints ?? (_surveyPoints = new Collection<SurveyPoint>()); }
        protected set { _surveyPoints = value; }
    private ICollection<SurveyPoint> _surveyPoints;

    public virtual ICollection<TemperaturePoint> TemperaturePoints
        get { return _temperaturePoints ?? (_temperaturePoints = new Collection<TemperaturePoint>()); }
        protected set { _temperaturePoints = value; }
    private ICollection<TemperaturePoint> _temperaturePoints;

Here is the controller that makes use of an EF DbContext directly.

 public async Task<IHttpActionResult> Get(int id)
        var query = await TheContext.Wells.
                                   Include(x => x.GeometryItems).
                                   Include(x => x.SurveyPoints).
                                   Include(x => x.TemperaturePoints).
                                   SingleOrDefaultAsync(x => x.Id == id);
        if (query == null)
            return NotFound();
        var model = ModelFactory.Create(query);
        return Ok(model);

Here is the test that failed, finally...

the test setup

   public static void ClassInitialize(TestContext testContest)

            var well1 = new WellEntity { Name = "Well 1" };
            var well2 = new WellEntity { Name = "Well 2" };
            var well3 = new WellEntity { Name = "Well 3" };
            var well4 = new WellEntity { Name = "Well 4" };

            well1.GeometryItems.Add(new GeometryItem());
            well1.TemperaturePoints.Add(new TemperaturePoint());
            well1.SurveyPoints.Add(new SurveyPoint());

            well2.GeometryItems.Add(new GeometryItem());
            well2.TemperaturePoints.Add(new TemperaturePoint());
            well2.SurveyPoints.Add(new SurveyPoint());

            well3.GeometryItems.Add(new GeometryItem());
            well3.TemperaturePoints.Add(new TemperaturePoint());
            well3.SurveyPoints.Add(new SurveyPoint());

            well4.GeometryItems.Add(new GeometryItem());
            well4.TemperaturePoints.Add(new TemperaturePoint());
            well4.SurveyPoints.Add(new SurveyPoint());

            var wells = new List<WellEntity> { well1, well2, well3, well4 }.AsQueryable();

            var mockWells = CreateMockSet(wells);

            _mockContext = new Mock<ITubingForcesDbContext>();
            _mockContext.Setup(c => c.Wells).Returns(mockWells.Object);

   private static Mock<DbSet<T>> CreateMockSet<T>(IQueryable<T> data) where T : class
        var mockSet = new Mock<DbSet<T>>();

            .Setup(m => m.GetAsyncEnumerator())
            .Returns(new TestDbAsyncEnumerator<T>(data.GetEnumerator()));

               .Setup(m => m.Provider)
               .Returns(new TestDbAsyncQueryProvider<T>(data.Provider));

        mockSet.As<IQueryable<T>>().Setup(m => m.Expression).Returns(data.Expression);
        mockSet.As<IQueryable<T>>().Setup(m =>m.ElementType).Returns(data.ElementType);

        return mockSet;

   public async Task Get_ById_ReturnsWellWithAllChildData()
        // Arrange
        var controller = new WellsController(_mockContext.Object);

        // Act
        var actionResult = await controller.Get(1);

        // Assert
        var response = actionResult as OkNegotiatedContentResult<WellModel>;

TestDbAsyncQueryProvider and TestDbAsyncEnumerator are taken straight from the EF team documentation that is cited. I've tried a number of different approaches to how I generate the data for the mock, but I've never been successful.

6/11/2019 10:46:54 AM

Accepted Answer

For anyone who runs across this problem and is curious about how to fix the.Include("Foo") Using Entity Framework 6+ with NSubstitute issue, I was able to get around myInclude using the following calls:

var data = new List<Foo>()
    /* Stub data */

var mockSet = Substitute.For<DbSet<Foo>, IQueryable<Foo>>();

// The following line bypasses the Include call.
1/8/2016 11:15:59 PM

Popular Answer


Related Questions


Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow