C# 实体框架最小起订量异常

Question

I have IDataService that contains generic crud operations

public interface IDataService<T>
{
    Task<IEnumerable<T>> GetAll();
    Task<IEnumerable<T>> GetAll(string[] includes = null);
    Task<T> GetById(int id);
    Task<T> Create(T entity);
    Task<T> Update(int id, T entity);
    Task<bool> Delete(int id); 
}

and I have class GenericDataService<T> that implements the IDataService interface:

public class GenericDataService<T> : IDataService<T> where T : DomainObject 
{
    private readonly DeployToolDBContexFactory _contexFactory;

    public GenericDataService(DeployToolDBContexFactory contexFactory)
    {
        _contexFactory = contexFactory;
    }

    public async Task<T> Create(T entity)
    {
        using (DeployToolDBContex contex = _contexFactory.CreateDbContext())
        {
            EntityEntry<T> createdResult = await contex.Set<T>().AddAsync(entity);
            await contex.SaveChangesAsync();
            return createdResult.Entity;
        }
    }

    public async Task<bool> Delete(int id)
    {
        using (DeployToolDBContex contex = _contexFactory.CreateDbContext())
        {
            T entity = await contex.Set<T>().FirstOrDefaultAsync((e) => e.Id == id);
            contex.Set<T>().Remove(entity);
            await contex.SaveChangesAsync();
            return true;
        }
    }
    
    public async Task<IEnumerable<T>> GetAll()
    {
        using (DeployToolDBContex contex = _contexFactory.CreateDbContext())
        {
            IEnumerable<T> entities = await contex.Set<T>().ToListAsync();
            return entities;
        }
    }
   
    public async Task<T> GetById(int id)
    {
        using (DeployToolDBContex contex = _contexFactory.CreateDbContext())
        {
            T entity = await contex.Set<T>().FirstOrDefaultAsync((e) => e.Id == id);
            return entity;
        }
    }
   
    public async Task<T> Update(int id, T entity)
    {
        using (DeployToolDBContex contex = _contexFactory.CreateDbContext())
        {
            entity.Id = id;
            contex.Set<T>().Update(entity);
            await contex.SaveChangesAsync();
            return entity;
        }
    }

    public async Task<IEnumerable<T>> GetAll(string[] includes = null)
    {
        using (DeployToolDBContex contex = _contexFactory.CreateDbContext())
        {
            var query = contex.Set<T>().AsQueryable();

            foreach (var include in includes)
                query = query.Include(include);

            return query.ToList();
        }
    }
}

To create objects I'm using a data store class that executes operations with the DataService object:

public class DataStore
{
    private static DataStore instance = null;

    public static DataStore Instance
    {
        get
        {
            instance = instance == null ? new DataStore() : instance;
            return instance;
        }
    }

    public IDataService<User> userDataService;

    public DataStore()
    {
        this.userDataService = new GenericDataService<User>(new DeployToolDBContexFactory());  
    }
}

For example, user creation:

private async void AddUser()
{
    User user = new User()
                    {
                        UserName = UserNameTxt,
                        RoleId = RoleSelected.Id
                    };
    await DataStore.Instance.userDataService.Create(user);
}

I'm new to Moq and I want to write unit tests, for example, test of user creation

[Test]
public async Task CreateUser()
{
    Mock<DeployToolDBContexFactory> dbContextFactory = new Mock<DeployToolDBContexFactory>();
    Mock<DeployToolDBContex> dbContextMock = new Mock<DeployToolDBContex>(dbContextFactory.Object);

    var user = new User()
                   {
                       UserName = "testName"
                   };
    var mock = new Mock<GenericDataService<User>>(new DeployToolDBContexFactory());
    mock.Setup(m => m.Create(user)).ReturnsAsync(new User() { UserName = user.UserName}).Verifiable();
        var service = new GenericDataService<User>(dbContextFactory.Object);
        User u = await service.Create(user);
        Assert.AreEqual(u.UserName , user.UserName);
}

I'm getting this error:

System.NotSupportedException: Unsupported expression: m => m.Create(user)
Non-overridable members (here: GenericDataService.Create) may not be used in setup / verification expressions.

I tried to set DbSet as virtual.

Thanks for any help.

Answer 1

It looks like you are a bit mixed up with mocking and what exactly you should be testing. Your GenericDataService is essentially a Generic Repository pattern. This is actually an anti-pattern for EF, but there is plenty to read up on why you shouldn't use it with EF... Repository patterns in general are a good thing for facilitating unit testing, however this is because they serve as a boundary to avoid needing to try and mock a DbContext and its DbSets .

Firstly, your Test is testing the wrong thing. The test should be testing whatever method that will be calling your AddUser method. Whether this is in a Controller or a Service, etc. That controller would have a dependency of IDataService<User> declared which we would be mocking in order to test the controller:

For the sake of argument I've made AddUser() a public method. In your case you should have a public action or method that calls AddUser and would set up a test for that method. You should also structure your code to avoid being dependent on module-level state. For instance an AddUser method should not be reliant on private/protected state, it should ultimately be getting parameters to do things like perform actions or modify state. (kept to a minimum)

So let's assume we want to test a method that should call the DataService Create method and Create is expected to have added the item to the DBContext and assigned an ID. The purpose of the unit test is not to assert what EF actually does, but rather what the code under test should do with the results:

[Test]
public void EnsureAddUserCreatesUser()
{
    const string userName = "New User";
    const int roleId = 4;
    const int UserId = 101;
    var mockUserDataService = new Mock<IDataService<User>>();
    mockUserDataService.Setup(m => m.Create(It.IsAny<User>())).Callback(m => {m.UserId = userId;});

    var testController = new UserController(mockUserDataService.Object);
    var user = await testController.AddUser(userName, roleId);
    Assert.IsNotNull(user);
    Assert.AreEqual(userId, user.UserId);
    Assert.AreEqual(userName, user.UserName);
    Assert.AreEqual(roleId, user.RoleId);
    mockUserDataService.Verify(m => m.Create(It.IsAny<User>()), Times.Once);        
}

What a test like this does is set up a mock of our repository/data service telling it to expect its input parameter. Since our AddUser method will be creating a new user based on some values, we tell it to expect It.IsAny<User>() which says "expect a user". From there we can have the mock perform some basic actions as if the DbContext added our user successfully such as populating a PK. This example populates the PK using the Callback method which accepts whatever User was passed in then sets our known PK. The value itself does not matter since we aren't actually inserting data, we just want a known value to get back that we can assert that the mock was actually called. Normally the AddUser might also expect to check the resulting data and return something like a success state with an ID. In this example I had the AddUser return the User. Other tests you might want to assert the behaviour if the AddUser attempts to add a duplicate user. In these cases the Moq might Throw an exception or otherwise return a different result.

From there we have returned the User, so we just assert the values are what were expected, including the PK, and that our mocked method was actually called.

Ultimately when it comes to unit testing, the key points are:

• Your DataService/Repository serves as the boundary for the tests. (What you mock)
• Your tests test business logic above this boundary.
• Your tests mock the boundary, capturing all expected calls to that boundary, and either return known state, take action on passed in state, or throw exceptions based on what behaviour you want to test.
• Your tests can then assert the mocks to verify that methods that were expected to be called were called, and any methods that were not expected to be called were not called. ( Times.None )