What's the best way to create unit tests for services that uses IoC.Resolve()

Question

I'm using an IoC container instead of DI via constructor injection. Some may ask why I'm using IoC containers instead of constructor injection. Well for reasons stated here: Why do I need an IoC container as opposed to straightforward DI code?. However, I'm finding it difficult to create unit tests for my services. I'm not sure how to mock the repositories used by my services during runtime since I'm not using constructor injection (a conundrum). Anyone have any solutions?

For example:

public class SomeService
{
    private ISomeServiceRepository someServiceRepository;

    public GetSomeThing()
    {
        //how do I mock this repository in my unit test
        someServiceRepository = IoC.Resolve<ISomeServiceRepository>();

        someData = someServiceRepository.getData();

        someOtherService = new SomeOtherService();
        someThing = someOtherService.GetSomeThing();

        return FigureOutSomeThingElse(someData, someThing);
    }

    public FigureOutSomeThingElse(someData, someThing)
    {
        //do some figuring
        return somethingElse;
    }
} 

public class SomeOtherService
{
    private ISomeServiceRepository someOtherServiceRepository;

    public GetSomeThing()
    {
        //how do I mock this repository in my unit test
        someOtherServiceRepository = IoC.Resolve<ISomeOtherServiceRepository>();

        var someData = someOtherServiceRepository.getData();
        return someData;
    }
}

Answer 1

_{People can easily launch into a diatribe about how "you're doing it wrong" with resolve as needed, but I have experienced the pain of old code bases that cannot grok the register-resolve-release pattern altruistically. I would, however, advise against using a static container reference (as in IoC.) and try to make the container itself at least injected.}

In this situation, you simply provide a test version of the IoC registration container, but instead of the normal app configuration you code a test configuration.

This won't be mocking or stubbing in any true sense and in fact these terms can confuse the solution quite a bit.

In essence it'll just be a different active configuration when in the unit tests. You'll still have to register types manually and you might have difficulty disabling the current configuration code if it is in the execution path of the unit tests.

We have a container that we resolve from as needed in an IoC pattern (for a handful of types), and for testing we simply created a new container (basically, one configuration for code and another for unit tests). Our use case was slightly different in that we injected the container into classes instead of having a static accessible type as in your case.

Answer 2

You really should not be using IOC.Resolve inside of your class methods. It is very close to newing up your code anyway, which is part of what you are trying to avoid using DI. A better, and more testable way to write this would be something like this.

Public Class SomeService
{

  ISomeServiceRepository someServiceRepository;

  public SomeService(ISomeServiceRepository someServiceRepository)
  {
    this.someServiceRepository = someServiceRepository
  }

  Public GetSomeThing()
  {

    someData = someServiceRepository.getData();
    ...
  }
}

By doing it this way, you can just mock your interface and inject it directly.

If you must use .Resolve, then Adam's approach is the best you can do

Answer 3

I got it, this is what I did...

(I'm using Unity.Net & RhinoMock)

• Created a baseUnitTest class that implements the IContainerAccessor

• Created and initialized a new instance of the UnityContainer in the constructor

• Created a "UnityContainer" readonly public property which implements IContainerAccessor.Container

• Created a unit test class that inherits baseUnitTest

• Added the following code in a test method...

  Mocker = New Rhino.Mocks.MockRepository()

  SomeRepository = Mocker.DynamicMock(Of ISomeRepository)()

  MyBase.UnityContainer.RegisterInstance(Of ISomeRepository)(SomeRepository)

  Rhino.Mocks.Expect.Call(Of SomeResult)(SomeRepository.SomeMethod("someArg")).Return(New SomeResult())

  Mocker.ReplayAll()

  someService = New SomeService()

  'this method uses IOC.Resolve(ISomeRepository) and calls the SomeRepository.SomeMethod someResult = someService.someMethod()

  Assert.IsNotNull(someResult)

• Done