I have a Repository pattern that interacts with Entity Framework.
I'd like to run some unit tests on the repository, and for this reason, I would like to mock DbContext.
So I've created a unit test project (.Net Core 3.1), using Moq as package for unit testing, everything seems to be ok, but when I perform a .ToListAsync() on my repository it throws the following exception:
System.NotImplementedException : The method or operation is not
implemented. Stack Trace:
IAsyncEnumerable.GetAsyncEnumerator(CancellationToken cancellationToken)
ConfiguredCancelableAsyncEnumerable1.GetAsyncEnumerator() EntityFrameworkQueryableExtensions.ToListAsync[TSource](IQueryable1
source, CancellationToken cancellationToken)
The source code:
public class Customer
{
public Guid Id { get; set; }
public string Name { get; set; }
}
public class CustomersDbContext : DbContext
{
public virtual DbSet<Customer> Customers { get; set; }
public CustomersDbContext(DbContextOptions<Customer> options) : base(options) { }
}
public interface ICustomerRepository
{
Task<IEnumerable<Customer>> GetCustomersAsync(Guid? customerId);
}
public class CustomerRepository : ICustomerRepository
{
private readonly CustomersDbContext _dbContext;
public CustomerRepository(CustomersDbContext dbContext)
{
_dbContext = dbContext;
_dbContext.Database.EnsureCreated();
}
public async Task<IEnumerable<Customer>> GetCustomersAsync(Guid? customerId)
{
IEnumerable<Customer> customers = null;
if (customerId.HasValue)
{
var customer = await _dbContext.Customers.FindAsync(new object[] { customerId.Value }, CancellationToken.None);
if (customer != null)
customers = new List<Customer>() { customer };
}
else
{
customers = await _dbContext.Customers.ToListAsync(CancellationToken.None);
}
return customers;
}
}
public class CustomerServiceUnitTests
{
private Mock<CustomersDbContext> GetCustomerDbContextMock()
{
var data = new List<Customer>()
{
new Customer()
{
Id = Guid.NewGuid(),
Name = "Name 1"
},
new Customer()
{
Id = Guid.NewGuid(),
Name = "Name 2"
}
}.AsQueryable();
var mockSet = new Mock<DbSet<Customer>>();
mockSet.As<IQueryable<Customer>>().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As<IQueryable<Customer>>().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As<IQueryable<Customer>>().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As<IQueryable<Customer>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var optionsBuilder = new DbContextOptions<CustomersDbContext>();
var mockContext = new Mock<CustomersDbContext>(optionsBuilder);
Mock<DatabaseFacade> databaseFacade = new Mock<DatabaseFacade>(mockContext.Object);
databaseFacade.Setup(d => d.EnsureCreatedAsync(CancellationToken.None)).Returns(Task.FromResult(true));
mockContext.Setup(c => c.Database).Returns(databaseFacade.Object);
mockContext.Setup(c => c.Customers).Returns(mockSet.Object);
return mockContext;
}
[Fact]
public async Task Infrastructure_CustomerRepository_GetAll()
{
var mockContext = this.GetCustomerDbContextMock();
ICustomerRepository customerRepository = new CustomerRepository(mockContext.Object);
var customers = await customerRepository.GetCustomersAsync(null);
Assert.NotNull(customers);
Assert.Equal(2, customers.Count());
}
}
If I send an ID filled to the repository it works fine, so this seems to be not ok only for .ToListAsync().
I'm kinda stuck here, what can I do to overcome this?
You cannot mock DbSet query functionality. This is explained in the docs:
Properly mocking DbSet query functionality is not possible, since queries are expressed via LINQ operators, which are static
extension method calls over IQueryable. As a result, when some
people talk about "mocking DbSet", what they really mean is that they
create a DbSet backed by an in-memory collection, and then evaluate
query operators against that collection in memory, just like a simple
IEnumerable. Rather than a mock, this is actually a sort of fake,
where the in-memory collection replaces the the real database.
In order to execute Asynchronous read operation (ToListAsync()) you need to mock an additional interface called "IDBAsyncQueryProvider".
Here's is the required link you can follow. It is under the heading "Testing with async queries"
Related
I got the following error when I try to test an update operation using Entity Framework core:
System.InvalidOperationException : The instance of entity type 'Companies' cannot be tracked because another instance with the key value '{Id: 1}' is already being tracked. When attaching existing entities, ensure that only one entity instance with a given key value is attached.
After doing some research, I tried everything that I found:
Create in scope DB context
deattach and attached the object I want to update from the DB context
Return the object to be updated using "AsNoTracking()" , my repository actually do this.
For the testing I am using EF in-memmory database with it fixture, I am using XUnit and .NET 5.
Can I get any help with this please?
Here is my code:
// The repository I am trying to test
public class RepositoryBase<T> : ICrudRepository<T> where T : class, IModel
{
protected PrjDbContext DatabaseContext { get; set; }
public RepositoryBase(PrjDbContext databaseContext) => DatabaseContext = databaseContext;
protected IQueryable<T> FindAll() => DatabaseContext.Set<T>().AsNoTracking();
protected IQueryable<T> FindBy(Expression<Func<T, bool>> expression) => DatabaseContext.Set<T>().Where(expression).AsNoTracking();
public void Create(T entity) => DatabaseContext.Set<T>().Add(entity);
public void Update(T entity) => DatabaseContext.Set<T>().Update(entity);
public void Delete(T entity) => DatabaseContext.Set<T>().Remove(entity);
public async Task<IEnumerable<T>> ReadAllAsync() => await FindAll().ToListAsync().ConfigureAwait(false);
public async Task<T> ReadByIdAsync(int id) => await FindBy(entity => entity.Id.Equals(id)).FirstOrDefaultAsync().ConfigureAwait(false);
}
//The Database context
public partial class PrjDbContext : DbContext
{
public PrjDbContext()
{
}
public PrjDbContext(DbContextOptions<PrjDbContext> options)
: base(options)
{
}
public virtual DbSet<Companies> Companies { get; set; }
}
// This is my fixture with the in-memory Database
public sealed class PrjSeedDataFixture : IDisposable
{
public PrjDbContext DbContext { get; }
public PrjSeedDataFixture(string name)
{
string databaseName = "PrjDatabase_" + name + "_" + DateTime.Now.ToFileTimeUtc();
DbContextOptions<PrjDbContext> options = new DbContextOptionsBuilder<PrjDbContext>()
.UseInMemoryDatabase(databaseName)
.EnableSensitiveDataLogging()
.Options;
DbContext = new PrjDbContext(options);
// Load Companies
DbContext.Companies.Add(new Companies { Id = 1, Name = "Customer 1", Status = 0, Created = DateTime.Now, LogoName = "FakeLogo.jpg", LogoPath = "/LogoPath/SecondFolder/", ModifiedBy = "Admin" });
DbContext.Companies.AsNoTracking();
DbContext.SaveChanges();
}
public void Dispose()
{
DbContext.Dispose();
}
}
The test method "Update_WhenCalled_UpdateACompanyObject", is not working for me.
// And finally, this is my test class, Create_WhenCalled_CreatesNewCompanyObject pass the test, but Update_WhenCalled_UpdateACompanyObject isn't passing the test.
public class RepositoryBaseCompanyTests
{
private Companies _newCompany;
private PrjDbContext _databaseContext;
private RepositoryBase<Companies> _sut;
public RepositoryBaseCompanyTests()
{
_newCompany = new Companies {Id = 2};
_databaseContext = new PrjSeedDataFixture("RepositoryBase").DbContext;
_sut = new RepositoryBase<Companies>(_databaseContext);
}
[Fact]
public void Create_WhenCalled_CreatesNewCompanyObject()
{
//Act
_sut.Create(_newCompany);
_databaseContext.SaveChanges();
//Assert
Assert.Equal(2, _databaseContext.Companies.Where( x => x.Id == 2).FirstOrDefault().Id);
}
[Fact]
public async void Update_WhenCalled_UpdateACompanyObject()
{
//Arrange
var company = await _sut.ReadByIdAsync(1);
company.Name = "Customer 2";
//_databaseContext.Entry(company).State = EntityState.Detached;
//_databaseContext.Attach(company);
//_databaseContext.Entry(company).State = EntityState.Modified;
//Act
_sut.Update(company);
await _databaseContext.SaveChangesAsync();
//Assert
Assert.Equal("Customer 2", _databaseContext.Companies.Where(x => x.Id == 1).FirstOrDefault().Name);
}
}
If you are using EF Core 5.0 then call DbContext.ChangeTracker.Clear() (or go through DbContext.Entries collection and set state to Detached for earlier ones) after DbContext.SaveChanges(); in PrjSeedDataFixture ctor. Adding/Updating an entry makes it tracked and you are reusing the context that created an entry with Id = 1, so when _sut.Update(company); is called it will try to track it again (since ReadByIdAsync should return an untracked one).
P.S.
Adding an extra repository abstraction layer around EF can be considered as antipattern (because EF already implements repository/UoW patterns) and the issue you are having can be one of the examples of why that is true and why this abstraction can be a leaky one. So if you still decide that having one is a good idea - you need to proceed with caution.
I am trying to setup tests using Moq + Nunit.
I am using the Repository pattern
public interface IRepository<T> where T : class
{
Task<List<T>> FindByConditionAsync(Expression<Func<T, bool>> expression);
Task<List<T>> GetAllAsync();
//...
}
public class Repository<TEntity, TContext> : IRepository<TEntity>
{
//...Omitted other code from this snippet
public async Task<List<TEntity>> FindByConditionAsync(Expression<Func<TEntity, bool>> expression)
{
return await _context.Set<TEntity>().Where(expression).ToListAsync();
}
}
public interface IUserRepository : IRepository<User>
{
}
public class UserRepository : Repository<User, MyDatabase>, IUserRepository
{
public UserRepository(MyDatabase context) : base(context)
{
}
}
My test file
public class UserProviderTests
{
private IMapper _mapper;
private UserProvider _userProvider;
private Mock<MyDatabase> _mockContext;
private UserRepository _userRepository;
[SetUp]
public void Setup()
{
var user1Guid = Guid.NewGuid();
var user2Guid = Guid.NewGuid();
var data = new List<User>
{
new User
{
Id = user1Guid,
FirstName = "Optimus",
LastName = "Prime"
},
new User
{
Id = user2Guid,
FirstName = "John",
LastName = "Doe",
}
}.AsQueryable();
var mockSet = new Mock<DbSet<User>>();
mockSet.As<IQueryable<User>>().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As<IQueryable<User>>().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As<IQueryable<User>>().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As<IQueryable<User>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var options = new DbContextOptionsBuilder<MyDatabase>()
.UseSqlServer("fakestring")
.Options;
_mockContext = new Mock<MyDatabase>(options);
_mockContext.Setup(c => c.Users).Returns(mockSet.Object);
_userRepository = new UserRepository(_mockContext.Object);
var config = new MapperConfiguration(cfg => {
cfg.AddProfile<MappingProfile>();
});
_mapper = new Mapper(config);
_userProvider = new UserProvider(_mapper, _userRepository);
}
[Test]
public async Task GetUsers_ReturnsSingleUser()
{
var users = await _userProvider.FindUser("xxx");
Assert.AreEqual("xxx", users.FirstOrDefault()?.FirstName);
}
}
UserProvider is a service I am using that uses UserRepository to perform CRUD operations.
But When I try to run this test, I get error saying -
System.ArgumentNullException : Value cannot be null. (Parameter 'source')
Stack Trace:
Queryable.Where[TSource](IQueryable'1 source, Expression'1 predicate)
Repository'2.FindByConditionAsync(Expression'1 expression) line 48
Sorry for the long question, but am I missing something here? I don't understand why TSource(USer object) is null.
In my opinion, you should write a test for services in your project. In fact, you shouldn't write any business in the RepositoryLayer because there isn't any business rule in the Repository. If you need to help more please contact me.
dpournabi#gmail.com
I have recently began to dig into Entity Framework unit-testing with Entity Framework 6 mocking.
I have noticed the following thing:
Entity Framework mocking forces me to create a global context in my BL class, for example:
public class RefundRepayment : IDisposable
{
protected DbContext _dbContext = new DbContext();
/* more properties and class code */
public void Dispose()
{
_dbContext.Dispose();
}
}
I can't quite figure it out, as I'd rather implement the using statement in every method in order to deal with the DbContext, my code will look like:
public class RefundRepayment
{
/* more properties and class code */
public void AccessDb()
{
using(DbContext dbContext = new DbContext())
{
/* db code here */
}
}
}
Is there any specific reason why should we initialize a global context instead of implementing the using statement?
First off, you need to be using DI (via ninject, Unity, Core, etc) to pull this off.
Let me show you a simple sample of an EF GetAll() testing my MVC controller.
[Fact]
public void GetAllOk()
{
// Arrange
// Act
var result = _controller.GetAll() as OkObjectResult;
// Assert
Assert.NotNull(result);
var recordList = result.Value as List<DTO.Account>;
Assert.NotNull(recordList);
Assert.Equal(4, recordList.Count);
}
It relies on this startup code...
public class AccountsControllerTests
{
DatabaseFixture _fixture;
AccountsControllerV1 _controller;
public AccountsControllerTests(DatabaseFixture fixture)
{
_fixture = fixture;
_controller = new AccountsControllerV1(_fixture._uow);
}
What is DatabaseFixture? Glad you asked...
public class DatabaseFixture : IDisposable
{
public ApplicationDbContext _context;
public DbContextOptions<ApplicationDbContext> _options;
public IUoW _uow;
public DatabaseFixture()
{
var x = Directory.GetCurrentDirectory();
var config = new ConfigurationBuilder()
.AddJsonFile("appsettings.Tests.json", optional : true)
.Build();
_options = new DbContextOptionsBuilder<ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "ProviderTests")
.Options;
_context = new ApplicationDbContext(_options);
_context.Database.EnsureCreated();
Initialize();
_uow = new UoW(_context);
}
private void Initialize()
{
_context.Accounts.Add(new Entities.Account() { AccountNumber = "Number 1", AccountID = "", AccountUniqueID = "" });
_context.Accounts.Add(new Entities.Account() { AccountNumber = "Number 2", AccountID = "", AccountUniqueID = "" });
_context.Accounts.Add(new Entities.Account() { AccountNumber = "Number 3", AccountID = "", AccountUniqueID = "" });
_context.Accounts.Add(new Entities.Account() { AccountNumber = "Number 4", AccountID = "", AccountUniqueID = "" });
_context.SaveChanges();
}
public void Dispose()
{
// Clean Up
_context.Database.EnsureDeleted();
}
}
[CollectionDefinition("Database Collection")]
public class DatabaseCollection : ICollectionFixture<DatabaseFixture>
{
}
A few definitions used in the above code. I used a Unit of Work Pattern that contains references to all my EF repositories. I kept Entity (Database) classes and DTO (Data Transfer Object) Classes separate. I used an in-memory replacement for the EF database that I initialize at the beginning of each run and/or test so that my data is always known. I inject the Database Fixture into my test class (not each test) so I am not creating/destroying constantly. Then I create my controller passing in my database UoW definition.
You're real controller requires injection of the UoW container you've created with the real database. You are merely substituting a controlled database environment for your test.
public AccountsControllerV1(IUoW uow)
{
_uow = uow;
}
And yes, I use versioning for the sharp-eyed. And yes, this is a Core 2 example. Still applicable for EF 6, just need 3rd party DI ;)
And the controller method I am testing?
[HttpGet("accounts", Name ="GetAccounts")]
public IActionResult GetAll()
{
try
{
var recordList = _uow.Accounts.GetAll();
List<DTO.Account> results = new List<DTO.Account>();
if (recordList != null)
{
results = recordList.Select(r => Map(r)).ToList();
}
log.Info($"Providers: GetAccounts: Success: {results.Count} records returned");
return Ok(results);
}
catch (Exception ex)
{
log.Error($"Providers: GetAccounts: Failed: {ex.Message}");
return BadRequest($"Providers: GetAccounts: Failed: {ex.Message}");
}
}
In a few words. Wpf app, ef used. I need to test model behavior using mock and unity. Unity and mock seem to me to be clear.
The question is following:
Model doesn't get the context through it constructor. It uses the context while execute the methods like this:
public Toys[] Get()
{
using (Context context = new Context())
{
return context.Toys.ToArray();
}
}
This is how I try to test:
[TestClass]
public class TestToyModel
{
[TestMethod]
public void TestToyCreate()
{
List<Toy> toys = new List<Toy>();
toys.Add(new Toy{ Id = "1234", Name = "Toy1" });
DbSet<Toy> dbToys = GetQueryableMockDbSet(toys);
Mock<ToyModel> model = new Mock<ToyModel>();
Mock<Context> context = new Mock<Context>();
context.Setup(x => x.Toys).Returns(dbToys);
//it' s all for now
}
private static DbSet<T> GetQueryableMockDbSet<T>(List<T> sourceList) where T : class
{
var queryable = sourceList.AsQueryable();
var dbSet = new Mock<DbSet<T>>();
dbSet.As<IQueryable<T>>().Setup(m => m.Provider).Returns(queryable.Provider);
dbSet.As<IQueryable<T>>().Setup(m => m.Expression).Returns(queryable.Expression);
dbSet.As<IQueryable<T>>().Setup(m => m.ElementType).Returns(queryable.ElementType);
dbSet.As<IQueryable<T>>().Setup(m => m.GetEnumerator()).Returns(() => queryable.GetEnumerator());
dbSet.Setup(d => d.Add(It.IsAny<T>())).Callback<T>((s) => sourceList.Add(s));
return dbSet.Object;
}
}
How can I supply my mock model with mock context ?
The context is being created manually so the class is tightly coupled to context which makes it difficult to unit test in isolation.
context is a dependency. abstract it out so that it can be mocked and injected into the subject under test.
public interface IContext : IDisposable {
public DbSet<Toy> Toys { get; }
//...other properties and methods
}
public class Context : DbContext, IContext {
public Context() { ... }
public DbSet<Toy> Toys { get; set; }
//...other properties and methods
}
Assuming system under test
public class ToyModel {
private readonly IContext context;
public MyClass(IContext context) {
this.context = context;
}
public Toys[] Get() {
return context.Toys.ToArray();
}
public void Create(Toy toy) {
context.Toys.Add(toy);
context.SaveChanges();
}
}
The class is no longer responsible for creating the dependency. That responsibility is now passed/delegated out to another class. Also note that your classes should depend on abstractions and not on concretions. This allows for more flexibility when swapping implementations. Like mocking for unit tests.
Now the context can be mocked and injected into the dependent class. Here is a simple example based on what you have done so far.
[TestClass]
public class TestToyModel {
[TestMethod]
public void TestToyCreate() {
//Arrange
var toys = new List<Toy>();
toys.Add(new Toy { Id = "1234", Name = "Toy1" });
var dbToys = GetQueryableMockDbSet(toys); //DbSet<Toy>
var contextMock = new Mock<IContext>();
contextMock.Setup(x => x.Toys).Returns(dbToys);
var sut = new ToyModel(contextMock.Object);
//Act
sut.Create(new Toy { Id = "5678", Name = "Toy2" });
//Assert
var expected = 2;
var actual = toys.Count;
Assert.AreEqual(expected, actual);
}
//...other code removed for brevity
}
If the ToyModel is the system under test, there is no need to mock it. Create an instance and pass the mocked dependencies to satisfy the test.
I'm trying to unit test some Web Api 2 Controllers that use Entity Framework 6 but having issues with the loading of the related entities after the entity has been added. I'm using Moq to create a mocked DbContext and DbSet, and have added
public virtual void MarkAsModified<T>(T item) where T : class
{
Entry(item).State = EntityState.Modified;
}
to get around the _db.Entry(foo).State = EntityState.Modified; issue on a Put action.
The Api Action is a Post in this simplified example where we need to get back 2 related entities (Bar and Qux).
[ResponseType(typeof (Foo))]
public async Task<IHttpActionResult> PostFoo(Foo foo)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
//Do other stuff
_db.Foos.Add(foo);
_db.Entry(foo).Reference(x => x.Bar).Load();
_db.Entry(foo).Reference(x => x.Qux).Load();
await _db.SaveChangesAsync();
return CreatedAtRoute("DefaultApi", new {id = foo.Id},foo);
}
And then a simplified test would be
[TestMethod]
public async Task PostFoo()
{
var model = new Foo
{
Name="New Foo",
QuxId = 99,
Qux = null,
BarId = 66,
Bar = null
};
var result = await _controller.PostFoo(model) as CreatedAtRouteNegotiatedContentResult<Foo>;
Assert.IsNotNull(result);
Assert.IsNotNull(result.Qux);
Assert.IsNotNull(result.Bar);
}
Is there a more mock-friendly way of doing _db.Entry(foo).Reference(x => x.Bar).Load();
The general idea about the solution can be seen here
Mocking Entity Framework when Unit Testing ASP.NET Web API 2: dependency injection
Currently, your controller is coupled too tightly to EF so my advice would be to abstract the DbContext and DbSet dependency out of the controller so that it can become mock-friendly.
To get around _db.Entry(foo).Reference(x => x.Bar).Load() here is a simplified abstraction of the dependent actions based on what you are using in your post
public interface IUnitOfWork {
void Add<T>(T item) where T : class;
void MarkAsModified<T>(T item) where T : class;
void LoadRelatedEntity<T, TRelated>(T item, Expression<Func<T, TRelated>> exp)
where T : class
where TRelated : class;
Task SaveChangesAsync();
}
and allow a concrete implementation to be able to do this.
public void LoadRelatedEntity<T, TRelated>(T item, Expression<Func<T, TRelated>> exp)
where T : class
where TRelated : class
{
_db.Entry(item).Reference(exp).Load();
}
This dependency can now be injected into the controller and can also be mocked.
Here is a simplified version of a potential controller
public class FooController : ApiController {
IUnitOfWork unitOfWork;
public FooController (IUnitOfWork uow) {
this.unitOfWork = uow;
}
[ResponseType(typeof(Foo))]
public async Task<IHttpActionResult> PostFoo(Foo foo) {
if (!ModelState.IsValid) {
return BadRequest(ModelState);
}
//Do other stuff
unitOfWork.Add(foo);
await unitOfWork.SaveChangesAsync();
//Load related entities
unitOfWork.LoadRelatedEntity(foo, x => x.Bar);
unitOfWork.LoadRelatedEntity(foo, x => x.Qux);
return CreatedAtRoute("DefaultApi", new { id = foo.Id }, foo);
}
}
From there it's just a matter of creating your test.
[TestMethod]
public async Task TestPostFoo() {
//Arrange
bool saved = false;
var model = new Foo {
Name = "New Foo",
QuxId = 99,
Qux = null,
BarId = 66,
Bar = null
};
var mockUnitOfWork = new Moq.Mock<IUnitOfWork>();
mockUnitOfWork.Setup(x => x.SaveChangesAsync())
.Returns(() => Task.FromResult(0))
.Callback(() => {
model.Id = 1;
saved = true;
});
mockUnitOfWork
.Setup(x => x.LoadRelatedEntity<Foo, Qux>(It.IsAny<Foo>(), It.IsAny<Expression<Func<Foo, Qux>>>()))
.Callback(() => model.Qux = new Qux());
mockUnitOfWork
.Setup(x => x.LoadRelatedEntity<Foo, Bar>(It.IsAny<Foo>(), It.IsAny<Expression<Func<Foo, Bar>>>()))
.Callback(() => model.Bar = new Bar());
var controller = new TestsFooApiController(mockUnitOfWork.Object);
controller.Request = new HttpRequestMessage { };
controller.Configuration = new HttpConfiguration();
//Act
var result = await controller.PostFoo(model) as CreatedAtRouteNegotiatedContentResult<Foo>;
//Assert
result.Should().NotBeNull();
result.Content.Should().NotBeNull();
result.Content.Id.Should().BeGreaterThan(0);
result.Content.Qux.Should().NotBeNull();
result.Content.Bar.Should().NotBeNull();
saved.Should().BeTrue();
}
Hope this helps