Emad Ibrahim

Here is the situation, my controller constructors take multiple interfaces as parameters.  I do this in order to use constructor injection which allows me to inject the controllers with mocked objects in my unit tests.

For example, my AccountController takes IEmailService, IFormsAuthentication and MembershipProvider (abstract class) as parameters.

During my testing, I want to mock the email, authentication and membership calls.  For example when the user calls FormsAuthentication.Login, I don’t really care if actual call succeeded but rather that my login action works appropriately in the case FormstAuthentication.Login succeeds (or fails).  I just want to mock that call.

I started off creating a few tests and slowly they have grown to several.  There was a lot of repeated code in my unit tests and to be a good citizen of the DRY universe, I needed to refactor the code.

For IoC, I initially started with StructureMap but now I am using Ninject. 

I created this module to bind my interfaces to mocked instances.  It looks like this:

internal class TestModule : StandardModule
{
    public override void Load()
    {
        Bind<IEmailService>()
            .ToConstant(MyMocks.MockEmailService.Object);

        Bind<IFormsAuthentication>()
            .ToConstant(MyMocks.MockFormsAuthentication.Object);

        Bind<MembershipProvider>()
            .ToConstant(MyMocks.MockMembershipProvider.Object);

        Bind<IContactListService>()
            .ToConstant(MyMocks.MockContactListService.Object);
    }
}

Notice that I bind the interfaces to actual instances and not classes.  These instances are declared in a global static class that will be accessed from my unit tests.  As you can tell from the name, they are all mocked objects (I am using Moq).  Here is how the MockEmailService looks (all the others are declared the same way):

internal static class MyMocks
{
    private static Mock<IEmailService> _mockEmailService;
    public static Mock<IEmailService> MockEmailService
    {
        get
        {
            _mockEmailService = _mockEmailService ?? new Mock<IEmailService>();
            return _mockEmailService;
        }
    }

So all this is good to setup Ninject and create my mocks.  Now I want to easily and generically create a controller, so I can quickly create unit tests.  In order to do that, I created a TestControllerFactory class that basically creates a controller with all the appropriate dependencies injected.

   1: internal static class TestControllerFactory

   2: {

   3:     private static IKernel _kernel;

   4:     public static IKernel Kernel

   5:     {

   6:         get

   7:         {

   8:             if (_kernel == null)

   9:             {

  10:                 var modules = new IModule[] { new TestModule() };

  11:                 _kernel = new StandardKernel(modules);

  12:             }

  13:             return _kernel;

  14:         }

  15:         private set

  16:         {

  17:             _kernel = value;

  18:         }

  19:     }

  20:  

  21:     public static T GetControllerWithFakeContext<T>(string httpMethod) 

  22:         where T : Controller

  23:     {

  24:         var con = Kernel.Get<T>();

  25:         con.SetFakeControllerContext();

  26:         if (con != null) con.Request.SetHttpMethodResult(httpMethod);

  27:         return con;

  28:     }

  29:  

  30: }

In line #10, I use the TestModule class mentioned above to setup the Ninject Kernel.  In lines #21 to #28, I create an instance of T which must be of type Controller from the Kernel which will automatically create the Controller with all the mocked objects.  In line #25 and #26, I just set a fake/mocked context and the Http Method for the request (more info here).

Now my unit tests are very clean and easy to setup.    Using MbUnit as my unit test framework, here is a unit tests that tests the reset password functionality.

   1: [Test]

   2: public void ResetPasswordQuestion_Should_Send_Email_On_Success()

   3: {

   4:     var newpassword = "newpassword";

   5:     MyMocks.MockMembershipProvider

   6:          .Expect(p => p.ResetPassword(username, answer))

   7:          .Returns(newpassword);

   8:     MyMocks.MockEmailService

   9:          .Expect(m => m.SendPasswordReset(username, newpassword));

  10:  

  11:     var ac = TestControllerFactory

  12:                 .GetControllerWithFakeContext<AccountController>("POST");

  13:  

  14:     var results = ac.ResetPasswordQuestion(username, question, answer);

  15:     //write some asserts in here to make sure things worked

  16:  

  17:     //verify all mocks

  18:     MyMocks.MockMembershipProvider.VerifyAll();

  19:     MyMocks.MockEmailService.VerifyAll();

  20: }

Line #5: I mock the ResetPassword call on the membership provider and tell it to return the new password

Line #8: I mock the SendPasswordReset method on the email service

Line #11: Get an instance of AccountController from the Ninject Kernel

I just write some code to make sure the expected results took place and that my mocks were properly exercised and that’s pretty much it.  No need to have an SMTP server working to test this, no need to have a database, no need to have an authentication method, no need to implement the interfaces or write dummy methods.

I am like a kid in a candy store with all these things: mocking, dependency injection, inversion of control, unit testing…  I am loving it.

So what do you think?  Is this a good way to go about it?  Is there a better way and what is it?