Moq - 模拟 DbSet<T> .AddAsync 不引发任何调用

Question

I have a unit test that is basically testing the behaviour of EF Core. The class I am trying to test looks like this:

namespace MusicPortal.Repository.Repository
{
    public class ArtistRepository : IArtistRepository
    {
        private readonly MusicPortalDbContext _context;

        public ArtistRepository(MusicPortalDbContext context)
        {
            _context = context;
        }

        public async Task<MusicPortalDatabaseResponse<bool>> AddNewArtist(Artist artist)
        {
            try
            {
                await _context.Artists.AddAsync(new Artist
                {
                    ArtistType = ArtistTypes.Band,
                    City = artist.City,
                    Country = artist.Country,
                    Genre = artist.Genre,
                    Name = artist.Name,
                    ProfileImageUrl = artist.ProfileImageUrl
                });

                _context.SaveChanges();
                return new MusicPortalDatabaseResponse<bool>
                {
                    HasError = false,
                    Exception = null,
                    Response = true
                };
            }
            catch (Exception e)
            {
                return new MusicPortalDatabaseResponse<bool>
                {
                    HasError = true,
                    Exception = e,
                    Response = false
                };
            }
        }
    }
}

And I have the following Unit Test for it using Moq

namespace MusicPortal.Tests.Repository.ArtistRepository.AddNewArtist
{
    [TestFixture]
    public class GivenAddingANewArtistToADatabaseFails
    {
        private Mock<DbSet<Artist>> _mockArtistDbSet;
        private Mock<MusicPortalDbContext> _mockContext;

        private IArtistRepository _artistRepository;
        private MusicPortalDatabaseResponse<bool> _addArtistToDbResponse;

        [OneTimeSetUp]
        public async Task Setup()
        {
            _mockArtistDbSet = new Mock<DbSet<Artist>>();
            _mockContext = new Mock<MusicPortalDbContext>();

            _mockArtistDbSet
                .Setup(x => x.AddAsync(It.IsAny<Artist>(), It.IsAny<CancellationToken>()))
                .Callback((Artist artist, CancellationToken token) => { })
                .ReturnsAsync(It.IsAny<EntityEntry<Artist>>());
            _mockContext
                .Setup(x => x.SaveChanges())
                .Throws(new Exception("Cannot save new Artist to Database"));

            _artistRepository = new MusicPortal.Repository.Repository.ArtistRepository(_mockContext.Object);
            _addArtistToDbResponse = await _artistRepository.AddNewArtist(It.IsAny<Artist>());
        }

        [Test]
        public void ThenANegativeResultIsReturned() // pass
        {
            Assert.IsFalse(_addArtistToDbResponse.Response);
            Assert.IsTrue(_addArtistToDbResponse.HasError);
            Assert.IsInstanceOf<Exception>(_addArtistToDbResponse.Exception);
        }

        [Test]
        public void ThenTheArtistContextAddMethodIsCalledOnce() //fail
        {
            _mockArtistDbSet.Verify(x => x.AddAsync(It.IsAny<Artist>(), It.IsAny<CancellationToken>()), Times.Once);
        }

        [Test]
        public void ThenTheArtistsContextSaveMethodIsNeverCalled() //pass
        {
            _mockContext.Verify(x => x.SaveChanges(), Times.Never);
        }
    }
}

The first and last assertion pass but ThenTheArtistContextAddMethodIsCalledOnce() fails due to the following error:

MusicPortal.Tests.Repository.ArtistRepository.AddNewArtist.GivenAddingANewArtistToADatabaseFails.ThenTheArtistContextAddMethodIsCalledOnce

Moq.MockException : Expected invocation on the mock once, but was 0 times: x => x.AddAsync(It.IsAny(), It.IsAny())

Performed invocations:

Mock:1> (x): No invocations performed.

at Moq.Mock.Verify(Mock mock, LambdaExpression expression, Times times, String failMessage) at Moq.Mock 1.Verify[TResult](Expression 1 expression, Func`1 times) at MusicPortal.Tests.Repository.ArtistRepository.AddNewArtist.GivenAddingANewArtistToADatabaseFails.ThenTheArtistContextAddMethodIsCalledOnce() in MusicPortal.Tests\\Repository\\ArtistRepository\\AddNewArtist\\GivenAddingANewArtistToADatabaseFails.cs:line 53

I'm understanding that the problem code is c# _mockArtistDbSet .Setup(x => x.AddAsync(It.IsAny<Artist>(), It.IsAny<CancellationToken>())) .Callback((Artist artist, CancellationToken token) => { }) .ReturnsAsync(It.IsAny<EntityEntry<Artist>>());

And I know the problem is most likely due to async issue but I don't know why, or what the actual problem is. Any advice, solutions?

Answer 1

You declare and setup _mockArtistDbSet, but you don't use/attach it to the _mockContext. I think you need to add something like:

_mockContext.Setup(m => m.Artist).Returns(_mockArtistDbSet.Object);

Answer 2

So it looks like EF Core is not so easily tested with async tasks such as SaveChangesAsync and AddAsync . In the end, I followed the MS guide for testing EF core and created a mock context. The only downside being I can only test happy path. Although error paths are tested by the service which consumes the repository, I was hoping for more test coverage on the repository layer.

Anyway, here's the spec

using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using MusicPortal.Core.Context;
using MusicPortal.Core.Repository;
using MusicPortal.Tests.Repository.ArtistRepository.TestHelpers;
using MusicPortal.Tests.Repository.ArtistRepository.TestHelpers.MockDB;
using NUnit.Framework;
using MockArtistRepository = MusicPortal.Repository.Repository.ArtistRepository;

namespace MusicPortal.Tests.Repository.ArtistRepository.AddNewArtist 
{
    [TestFixture]
    public class GivenANewArtistToInsertIntoTheDb
    {
        private DbContextOptions<MusicPortalDbContext> _options;
        private MusicPortalDatabaseResponse<bool> _mockResponse;

        [OneTimeSetUp]
        public async Task Setup()
        {
            _options = new MockDbFactory("MusicPortalDB").Options;

            using (var context = new MusicPortalDbContext(_options))
            {
                var artistRepository = new MockArtistRepository(context);
                _mockResponse = await artistRepository.AddNewArtist(MockRepositoryData.Artist);
            }
        }

        [Test]
        public void AndThenAPositiveResultIsReturned()
        {
            Assert.Null(_mockResponse.Exception);
            Assert.IsTrue(_mockResponse.Response);
            Assert.IsFalse(_mockResponse.HasError);
        }

        [Test]
        public void ThenTheArtistShouldBeSavedWithNoProblem()
        {
            using (var context = new MusicPortalDbContext(_options))
            {
                Assert.AreEqual(1, context.Artists.Count());
            }
        } 
    }
}

and the Mock Database:

using System;
using Microsoft.EntityFrameworkCore;
using MusicPortal.Core.Context;
using MusicPortal.Core.DBModels;

namespace MusicPortal.Tests.Repository.ArtistRepository.TestHelpers.MockDB
{
    public sealed class MockDbFactory
    {
        public DbContextOptions<MusicPortalDbContext> Options { get; }

        public MockDbFactory(string dbName)
        {
            Options = new DbContextOptionsBuilder<MusicPortalDbContext>()
                .UseInMemoryDatabase(dbName)
                .Options;
        }

        public void AddArtistsToContext()
        {
            using (var context = new MusicPortalDbContext(Options))
            {
                context.Artists.Add(new Artist
                {
                    City = "Orange County",
                    Country = "USA",
                    Events = null,
                    Genre = "Pop Punk",
                    Id = Guid.Parse("8a07504b-8152-4d8b-8e21-74bf64322ebc"),
                    Merchandise = null,
                    Name = "A Day To Remember",
                    ArtistType = "Band",
                    ProfileImageUrl = "https://placehold.it/30x30"
                });

                context.SaveChanges();
            }
        }    
    }
}

I hope this helps anyone looking at the same issue. The lesson learned is don't use Async unless you absolutely have to.