NUnit 测试项目的 .NET Core 容器定义

Question

I am quite new to .NET Core. How can I define a DI container within the NUnit class library project?

I know that it is done through IServiceCollection , but since there isn't any Startup method, I don't know where to get the instance implementing this interface.

Also I would like to be able to load definitions from other class libraries (being the subject of testing). That should be simpler as I can just create a static method in that class library with one parameter that is IServiceCollection , but again, how do I get it?

A side question is: I presume some of the interfaces could be mocked for the purpose of tests, but how can I replace a mapping already created using of of IServiceCollection 's methods like AddSingleton or AddTransient ?

There is a Remove method, but it is not documented.

Answer 1

IServiceCollection is implemented by the ServiceCollecion class. So if you want to do this for integration tests then you can use the ServiceCollection class to create your own ServiceProvider .

var services = new ServiceCollection();

services.AddTransient<IMyInterface, MyClass>();
services.AddScoped<IMyScopedInteface, MyScopedClass>();
...

var serviceProvider = sc.BuildServiceProvider();

You can now use the serviceProvider instance in your tests to get your classes:

var myClass = serviceProvider.GetService<IMyInterface>();

If you want to mock some of the interfaces instead of using the real ones then, instead of adding the real class/interface into the service collection you can add a mock instead:

mockInterface = new Mock<IMyInterface>();

sc.AddScoped<IMyInterface>(factory => mockInterface.Object);

Answer 2

Generally you don't want to create a DI container for your tests but, as you realise, you want to mock them instead. So, for example, if this is a class you want to test:

public class UserService
{
    private readonly IUserDatabase _userDatabase;

    public UserService(IUserDatabase userDatabase)
    {
        _userDatabase = userDatabase;
    }

    public bool DoesUserExist(int userId)
    {
        return _userDatabase.UserExists(userId);
    }
}

And this is the definition of the interface used:

public interface IUserDatabase
{
    bool UserExists(int userId);
}

In our tests we can mock the interface to return a specific value we want for our test:

[TestClass]
public class UserServiceTests
{
    [TestMethod]
    public void DoesUserExist_ForValidUserId_ReturnsTrue()
    {
        var fakeUserId = 123;

        var mockUserDatabase = new Mock<IUserDatabase>();
        mockUserDatabase.Setup(udb => udb.UserExists(fakeUserId)).Returns(true);

        var userService = new UserService(mockUserDatabase.Object);

        var result = userService.DoesUserExist(fakeUserId);

        Assert.IsTrue(result);
        mockUserDatabase.VerifyAll();
    }
}

So in this test we have used Moq to create a mock of our interface. We don't need to use a DI container because we are in controller of creating the class we are testing. The DI container is of more use in production as it enables the application to create any dependencies it needs without your code having to call new - which is a big problem if you are trying to unit test your classes.

The .VerifyAll() method checks that any methods set up on the mock object, in this case we setup a call to UserExists , was actually called.

There are plenty of examples of how to use Moq and mocking interfaces in general. A quickstart guide to Moq is here .