Mocking EF6 with validation that occurs on SaveChanges

Question

I found a decent article to get me started on unit testing my Entity Framework-based application using Moq: https://msdn.microsoft.com/en-us/data/dn314429.aspx

This issue I'm having is that the SaveChanges method of the Mock does not appear to trigger the ValidateEntity method like it normally would. None of the validation settings I configured in the EntityTypeConfiguration are being thrown as a DbEntityValidationException.

For example, my AddRoles_Fails_For_Empty_Name tests to make sure that the service cannot add a role with an empty name. Either the IsRequired() configuration is not being applied, or the ValidateEntity method is not being called. I should mention that it works correctly if I use the actual context in the web app.

I've included some of my relevant unit testing, DbContext, and Service code below.

Am I doing something incorrectly? Are there any known issues or workarounds?

Role DB Map

public class RoleMap : EntityTypeConfiguration<Role>
{
    public RoleMap()
    {
        ToTable("bm_Roles");
        HasKey(r => r.Id);
        Property(r => r.Name).IsRequired().HasMaxLength(100).HasIndex(new IndexAttribute("UX_Role_Name") { IsUnique = true });
        Property(r => r.Description).HasMaxLength(500);
    }
}

DbContext

public class BlueMoonContext : DbContext, IBlueMoonContext
{
    public BlueMoonContext() : base("name=BlueMoon")
    {

    }

    public DbSet<Role> Roles { get; set; }
    public DbSet<User> Users { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Configurations.AddFromAssembly(typeof(BlueMoonContext).Assembly);
    }

    public void MarkAsModified<T>(T entity) where T : class
    {
        entity.ThrowIfNull("entity");
        Entry<T>(entity).State = EntityState.Modified;
    }

    protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry, IDictionary<object, object> items)
    {
        var result = base.ValidateEntity(entityEntry, items);

        if (entityEntry.State == EntityState.Added || entityEntry.State == EntityState.Modified)
        {
            // Perform validations that require database lookups
            if (entityEntry.Entity is Role)
            {
                ValidateRole((Role)entityEntry.Entity, result);
            }
            else if (entityEntry.Entity is User)
            {
                ValidateUser((User)entityEntry.Entity, result);                    
            }
        }

        return result;
    }

    private void ValidateRole(Role role, DbEntityValidationResult result)
    {
        if (role.Name.HasValue() && !Roles.NameAvailable(role.Name, role.Id))
        {
            result.ValidationErrors.Add(new DbValidationError("Name", "Already in use"));
        }
    }

    private void ValidateUser(User user, DbEntityValidationResult result)
    {
        if (user.UserName.HasValue() && !Users.UserNameAvailable(user.UserName, user.Id))
        {
            result.ValidationErrors.Add(new DbValidationError("UserName", "Already in use"));
        }
        if (user.Email.HasValue() && !Users.UserNameAvailable(user.UserName, user.Id))
        {
            result.ValidationErrors.Add(new DbValidationError("Email", "Already in use"));
        }
    }
}

Account Service

public class AccountService : BaseService, IAccountService
{
    private IPasswordHasher _passwordHasher;

    public AccountService(IBlueMoonContext context, IPasswordHasher passwordHasher) : base(context)
    {
        _passwordHasher = passwordHasher;
    }

    public ServiceResult CreateRole(Role role)
    {
        role.ThrowIfNull("role");
        Context.Roles.Add(role);
        return Save();
    }

    // Copied from base service class
    protected ServiceResult Save()
    {
        var result = new ServiceResult();
        try
        {
            Context.SaveChanges();
        }
        catch (DbEntityValidationException validationException)
        {

            foreach (var validationError in validationException.EntityValidationErrors)
            {
                foreach (var error in validationError.ValidationErrors)
                {
                    result.AddError(error.ErrorMessage, error.PropertyName);
                }
            }
        }
        return result;
    }
}

Unit Test

[TestFixture]
public class AccountServiceTests : BaseTest
{
    protected Mock<MockBlueMoonContext> _context;
    private IAccountService _accountService;

    [TestFixtureSetUp]
    public void Setup()
    {
        _context = new Mock<BlueMoonContext>();

        var data = new List<Role>
        {
            new Role { Id = 1, Name = "Super Admin" },
            new Role { Id = 2, Name = "Catalog Admin" },
            new Role { Id = 3, Name = "Order Admin" }
        }.AsQueryable();

        var roleSet = CreateMockSet<Role>(data);
        roleSet.Setup(m => m.Find(It.IsAny<object[]>())).Returns<object[]>(ids => data.FirstOrDefault(d => d.Id == (int)ids[0]));

        _context.Setup(m => m.Roles).Returns(roleSet.Object);
        // _context.Setup(m => m.SaveChanges()).Returns(0);
        _accountService = new AccountService(_context.Object, new CryptoPasswordHasher());
    }

    [Test]
    public void AddRole_Fails_For_Empty_Name()
    {
        var role = new Role { Id = 4, Name = "" };

        var result = _accountService.CreateRole(role);
        Assert.False(result.Success);
    }
}

Answer 1

SaveChanges is a virtual method which means you invoke a fake method....

You can create your mock CallBase = true, but it is not a good idea(it miss the idea of UT):

_context = new Mock<BlueMoonContext>(){ CallBase = true };

The above code will use the real implementation of BlueMoonContext for any method/property which is not explicitly setup.

RoleMap is responsible for your DB stracture, you should test it as a part of integration test(with DB).

In my opinion you should create an integration tests to verify the integrity(for example; cover RoleMap) with your DB, And create a UT using the Throw setup to cover the catch section(it's a part of your unit):

_contest.Setup(x => x.SaveChanges())
          .Throws(new DbEntityValidationException());

Edit to answer the OP question in the comment

no, you don't have to separate the built in validation, you have to create another test(integration test). In this test you'll verify the validation behaviour: insert an illegal entity, expect that exception will raise(using ExpectedExceptionAttribute) and then verify that the DB is empty... to apply this behaviour use this pattern:

try
{
    \\...
    \\try to commit
}
catch(DbEntityValidationException ex)
{
    \\do some validation, then: 
    throw;\\for ExpectedExceptionAttribute
}

I looked over the api of EntityTypeConfiguration, I didn't saw any contact which allows to UT the rules(unless you use tools like MsFakes, TypeMock Isolator there is no way to verify the ToTable/HasKey/Property was called). The class is being in used inside EntityFramework(which is a part of the BCL) in the integration test you don't have to verify that EntityFramework work properly, you are going to verify that your custom rules was integrated and works as you expect(In this answer you can read the reason not to test a BCL classes).

So use Moq in the UTs of AccountService. Create an integration tests for BlueMoonContext and RoleMap(without Moq).

By the way @LadislavMrnka offer an interesting way to test(integration test) EntityTypeConfiguration