Ninject依赖注入用于自动化测试

Question

Context:

I have a WebAPI application that serves multiple Angular applications. The WebAPI application uses Ninject to facilitate dependency injection. We mostly use it in the constructors of the controllers

At the moment the binding looks like this:

public static class NinjectWebCommon
{
    private static readonly Bootstrapper bootstrapper = new Bootstrapper();

    public static void Start()
    {
        DynamicModuleUtility.RegisterModule(typeof(OnePerRequestHttpModule));
        DynamicModuleUtility.RegisterModule(typeof(NinjectHttpModule));
        bootstrapper.Initialize(CreateKernel);
    }

    public static void Stop()
    {
        bootstrapper.ShutDown();
    }

    public static IKernel CreateKernel()
    {
        var kernel = new StandardKernel();
        kernel.Bind<Func<IKernel>>().ToMethod(ctx => () => new Bootstrapper().Kernel);
        kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();

        RegisterServices(kernel);
        return kernel;
    }
    private static void RegisterServices(IKernel kernel)
    {
        kernel.Bind<IDataContextAsync>().To<StContext>().InRequestScope();

        // FileExtensionService
        kernel.Bind<IFileExtensionService>().To<FileExtensionService>().InRequestScope();
        kernel.Bind<IFileExtensionRepository>().To<FileExtensionRepository>().InRequestScope();
        kernel.Bind<IEntityMapper<Domain.FileExtension, FileExtension>>().To<FileExtensionEntityMapper>().InRequestScope();

        // ...etc
    }
}

An example of a controller would look like this:

[RoutePrefix("api/fileextension")]
public class FileExtensionController : ApiController
{
    private readonly IFileExtensionService service;

    /// <summary>
    /// Initializes a new instance of the <see cref="BestandsextensieController"/> class.
    /// </summary>
    /// <param name="service">The service.</param>
    /// <exception cref="System.ArgumentNullException">service</exception>
    public FileExtensionController(IFileExtensionService service)
    {
        if (service == null)
        { 
            throw new ArgumentNullException(nameof(service));
        }

        this.service = service;
    }

    [HttpGet]
    [Route("getFileextensions")]        
    public IHttpActionResult GetFileExtensions()
    {
        return Ok(service.GetAll());
    }
}

And a Unittest class would look like this:

public class FileExtensionControllerTests
{
    private readonly Mock<IFileExtensionService> mockService;

    public FileExtensionControllerTests()
    {
        mockService = new Mock<IFileExtensionService>();
    }

    private FileExtensionController CreateSut()
    {
        return new FileExtensionController(mockService.Object);
    }

    // ... Unittests using CreateSut etc
}

Question

I would like to add automated testing to our Continuous Integration triggers. In order to do this, we decided to mock the Repositories (using moq, or something custom that just returns fake data). Would it be possible to create a conditional situation in which the NinjectWebCommon class injects a mock repository instead of the real one, when it sees it's being called by an automated test?

I don't need any suggestions for mocking, just for Dependancy Injection. Though, feel free to make them anyway if you think I'm doing something wrong. I just wanted to make sure to set a clear scope.

What would be best-practice in this case? I'm open for changes to our current way of working if you feel they are appropriate.

Edit

So the matter of automated testing is something like Specflow in combination with Selenium. The actual clicking of the buttons on the webapp as specified in the specflow tests. The only thing different from browsing the site by hand as you normally would, is the "person" controlling the client (browser). Selenium instead of a human being.

Answer 1

Your web application and the unit test application are two different applications. You can just create two different Ninject registrations:

1) NinjectWebCommon will run when the web application will start

2) Something like NinjectUnitTestsCommon that will be run by an unit test framework before all tests