TDD - Want to test my Service Layer with a fake Repository, but how?

Question

I've designed an application that uses the repository pattern, and then a separate service layer such as this:

public class RegistrationService: IRegistrationService
{
    public void Register(User user)
    {
        IRepository<User> userRepository = new UserRepository();
        // add user, etc
    }
}

As you can see, I am instantiating my repository inside of the Register method. Now as I want to write some unit tests, I can't really get to it and replace it with a fake repository can I?

I don't want to add the repository as class variable though (and set it through a constructor) because I think that would make my code "smelly" (not all repositories are needed for all methods, and I don't need the calling layer to know about repositories etc.).

Suggestions?

Answer 1

You need to use Dependency Injection. UserRepository is a dependency of your RegistrationService class. To make your classes properly unit testable (i.e. in isolation of their dependencies), you need to "invert" what controls your dependency creation. Currently, you have direct control, and are creating them internally. Just invert that control, and allow something external (such as an IoC container like Castle Windsor) inject them:

public class RegistrationService: IRegistrationService
{
    public RegistrationService(IRepository<User> userRepo)
    {
        m_userRepo = userRepo;
    }

    private IRepository<User> m_userRepo;

    public void Register(User user)
    {
        // add user, etc with m_userRepo
    }
}

I think I forgot to add. Once you allow your dependencies to be injected, you open up the possability of them being mockable. Since your RegistrationService now takes its dependent user repository as input to its constructor, you can create a mock repository and pass that in, instead of an actual repository.

Answer 2

Dependency Injection can come in really handy for these kinds of things:

public class RegistrationService: IRegistrationService
{
    public void Register(User user)
    {
        this(user, new UserRepository());
    }

    public void Register(User user, IRepository<User> userRepository)
    {
        // add user, etc
    }

}

This way you get the ability to use UserRepository as your default, and pass in a custom (Mock or Stub for testing) IRepository for whatever else you need. You may also want to change the scoping of the 2nd register method in case you don't want to expose it to everything.

An even better alternative would be to use an IoC container which would buy you syntax that is even more decoupled than the above example. You could get something like this:

public class RegistrationService: IRegistrationService
{
    public void Register(User user)
    {
        this(user, IoC.Resolve<IRepository<User>>());
    }

    public void Register(User user, IRepository<User> userRepository)
    {
        // add user, etc
    }

}

There are many IoC containers out there, as listed by other people's answers, or you could roll your own.