how to write unit test case for controller class using mockito

Question

I am very new to Mockito and jUnit and I try to learn the right way to do TDD. I need couples of example so that i can write unit test using mockito

Following is my controller class which upload file and perform some action on this file inputs.

@Controller
@RequestMapping("/registration")
public class RegistrationController {

    @Autowired
    private RegistrationService RegistrationService;

    @Value("#{Properties['uploadfile.location']}")
    private String uploadFileLocation;

    public RegistrationController() {

    }

    @RequestMapping(method = RequestMethod.GET)
    public String getUploadForm(Model model) {
        model.addAttribute(new Registration());
        return "is/Registration";
    }

    @RequestMapping(method = RequestMethod.POST)
    public String create(Registration registration, BindingResult result,ModelMap model)
            throws NumberFormatException, Exception {

        File uploadedFile = uploadFile(registration);
        List<Registration> userDetails = new ArrayList<Registration>();
        processUploadedFile(uploadedFile,userDetails);

        model.addAttribute("userDetails", userDetails);

        return "registration";
    }

    private File uploadFile(Registration registration) {

        Date dt = new Date();
        SimpleDateFormat format = new SimpleDateFormat("MM_dd_yyyy_HH_mm_ss");
        File uploadedFile = new File(uploadFileLocation
                + registration.getFileData().getOriginalFilename() + "."
                + format.format(dt));

            registration.getFileData().transferTo(uploadedFile);

        return uploadedFile;
    }

    private void processUploadedFile(File uploadedFile, List<Registration> userDetails)
            throws NumberFormatException, Exception {

        registrationService.processFile(uploadedFile, userDetails);
    }

}

can any body please suggest some example how can I write test case for this using mockito?

Edit I have write down following test class but how to proceed further

@RunWith(MockitoJUnitRunner.class)
@ContextConfiguration(locations = { "/META-INF/spring/applicationContext.xml"})
public class BulkRegistrationControllerTest {

    @InjectMocks
    private RegistrationService registrationService= new RegistrationServiceImpl();
    @Mock
    private final ModelMap model=new ModelMap(); 

    @InjectMocks
    private ApplicationContext applicationContext;

    private static MockHttpServletRequest request;
    private static MockHttpServletResponse response;

    private static RegistrationController registrationController;

    @BeforeClass
    public static void init() {

           request = new MockHttpServletRequest();
           response = new MockHttpServletResponse();           
           registrationController = new RegistrationController();

    }
    public void testCreate()
    {
        final String target = "bulkRegistration";
        BulkRegistration bulkRegistration=new BulkRegistration();
        final BindingResult result=new BindingResult();     

        String nextPage=null;       
        nextPage = bulkRegistrationController.create(bulkRegistration, result, model);
        assertEquals("Controller is not requesting the correct form",nextPage,
                target);

    }

}

Answer 1

There are a couple things you seem to have crossed up in your test. There are integration tests and unit tests. Integration tests will test everything (or almost everything) all hooked up - so you use Spring configuration files very close to the real ones and real examples of objects get injected to your class under test. That's mostly what I use @ContextConfiguration but I use that in conjunction with @RunWith(SpringJUnit4ClassRunner.class)

If you are using Mockito (or any mocking framework), it is usually because you want to isolate the class you are testing from real implementations of other classes. So instead of, for example, having to contrive a way to get your RegistrationService to throw a NumberFormatException to test that code path, you just tell the mock RegistrationService to do it. There are lots of other examples where it is more convenient to use mocks than to use real class instances.

So, that mini-lesson finished. Here is how I would re-write your test class (with an extra example and commented along the way).

@RunWith(MockitoJUnitRunner.class)
public class RegistrationControllerTest {

    // Create an instance of what you are going to test.
    // When using the @InjectMocks annotation, you must create the instance in
    // the constructor or in the field declaration.
    @InjectMocks
    private RegistrationController controllerUT = new RegistrationController();

    // The @Mock annotation creates the mock instance of the class and
    // automatically injects into the object annotated with @InjectMocks (if
    // possible).
    @Mock
    private RegistrationService registrationService;
    // This @Mock annotation simply creates a mock instance. There is nowhere to
    // inject it. Depending on the particular circumstance, it may be better or
    // clearer to instantiate the mock explicitly in the test itself, but we're
    // doing it here for illustration. Also, I don't know what your real class
    // is like, but it may be more appropriate to just instantiate a real one
    // than a mock one.
    @Mock
    private ModelMap model;
    // Same as above
    @Mock
    private BulkRegistration bulkRegistration;
    // Same as above
    @Mock
    private FileData fileData;

    @Before
    public void setUp() {
        // We want to make sure that when we call getFileData(), it returns
        // something non-null, so we return the mock of fileData.
        when(bulkRegistration.getFileData()).thenReturn(fileData);
    }

    /**
     * This test very narrowly tests the correct next page. That is why there is
     * so little expectation setting on the mocks. If you want to test other
     * things, such as behavior when you get an exception or having the expected
     * filename, you would write other tests.
     */
    @Test
    public void testCreate() throws Exception {
        final String target = "bulkRegistration";
        // Here we create a default instance of BindingResult. You don't need to
        // mock everything.
        BindingResult result = new BindingResult();

        String nextPage = null;
        // Perform the action
        nextPage = controllerUT.create(bulkRegistration, result, model);
        // Assert the result. This test fails, but it's for the right reason -
        // you expect "bulkRegistration", but you get "registration".
        assertEquals("Controller is not requesting the correct form", nextPage,
                target);

    }

    /**
     * Here is a simple example to simulate an exception being thrown by one of
     * the collaborators.
     * 
     * @throws Exception
     */
    @Test(expected = NumberFormatException.class)
    public void testCreateWithNumberFormatException() throws Exception {
        doThrow(new NumberFormatException()).when(registrationService)
                .processFile(any(File.class), anyList());
        BindingResult result = new BindingResult();
        // Perform the action
        controllerUT.create(bulkRegistration, result, model);
    }
}

Answer 2

The real question is:
How to set up an integration testing environment of your application which is using Spring?
The answer to this question is not simple, it really depends on how your web application works .

You should first focus on how to JUnit a Java web application, then on how to use Mockito .

Answer 3

It's definitely possible to write pure unit tests for Spring MVC controllers by mocking their dependencies with Mockito (or JMock) as jherricks showed above. The challenge that remains is that with annotated POJO controllers there is a lot that remains untested -- essentially everything that's expressed in annotations and done by the framework when the controller is invoked.

Support for testing Spring MVC controllers is under way (see the spring-test-mvc project ). While the project will still undergo changes it's usable in its present form. If you're sensitive to change however you should not depend on it. Either way I felt it was worth pointing out if you want to track it or participate in its development. There is a nightly snapshot and there will be a milestone release this month if you want to lock into a specific version.

Answer 4

Mockito is a mocking framework which is used to mock objects. This is usually feasible when you're testing a method which depends and on some other object's method result. For example, when testing your create method, you would want to mock the uploadedFile variable, as here you're not interested to test if the uploadFile(Registration registration) is working correctly(you test it in some other test), but you're interested to test if the method is processing the uploaded file and if it is adding the details in the model. To mock the upload file, you could go: when(RegistrationController.uploadFile(anyObject()).thenReturn(new File());

But then you see this shows a design issue. Your method uploadFile() should't reside in the Controller, but instead in some other utility class. And then you could @Mock that utility class instead of controller.

You have to remember that if your code is hard to test, that indicates you didn't do your best to keep it simple.

Answer 5

Looking at your code sample above I see a few issues:

1. The point of using Mockito is to mock the dependencies of your class. This will enable you to use a simple JUnit test case. Therefore there is no need to use @ContextConfiguration. You should be able to instantiate the class being tested using the new operator and then provide the required dependencies.

2. You're using Autowiring to provide your Registration service. In order to inject a mock instance of this service you will need to use the Spring testing private field access utilities.

3. I can't see from your code whether RegistrationService is an interface. If it's not you're going to have problems mocking it.

Answer 6

I am not familiar with Mockito (because I use JMock ), but the general approach of writing tests with mocks is the same.

First you need an instance of the class under test (CUT) ( RegistrationController ). That must NOT be a mock - because you want to test it.

For testing getUploadForm the CUT-instance does not need any dependencies, so you can create it via new RegistrationController .

Then you should have a test hat looks a bit like this

RegistrationController controller = new RegistrationController();
Model model = new Model();
String result = controller(model);
assertEquals("is/Registration", result);
assertSomeContstrainsFormodel

That was easy.

The next method you want to test is create Method. That is much more difficult.

• You need to have instance of the parameter objects ( BindingResult ) may be a bit more complicated
• You need to handle the files in the test (delete them afterwards) - I will not discuss that problem. But may you should think of a way to use Temporary Files for the test instead.
• You use the both variables registrationService and uploadFileLocation -- thats the interesting part.

uploadFileLocation is just a field that must be set in the test. The easyest way would be adding a (getter and) setter to set that filed in the test. You can also use the org.springframework.test.util.ReflectionTestUtils to set this field. -- both ways have pros and conns.

More interesting is registrationService . This should be a Mock! You need to create a Mock for that class, and then "inject" that mock in the CUT instance. Like for the uploadFileLocation you have at least the same two choices.

Then you need to define the exceptions you have for the mock: that registrationService.processFile(uploadedFile, userDetails) is invoked with the correct file and user details. (how exact this exception is defined is part of Mockito - and I have not enough knowlege).

Then you need to invoke the method you want to test on CUT.

BTW: If you need to "inject" mocks on Spring beans very often, then you can build your own util. That get an instance of an object, scan that object for fields with @Inject annotations, create Mocks for that and "inject" that mocks. (Then you only need getter to access the mocks to define there expections.) -- I have build such an tool for JMock, and it helped me a lot.

Answer 7

Try this.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "/META-INF/spring/applicationContext.xml"})
public class BulkRegistrationControllerTest {

    @Mock
    private RegistrationService registrationService;

    //Controller that is being tested.
    @Autowired
    @InjectMocks
    private RegistrationController registrationController;

    @Before
    public void setUp() {
       MockitoAnnotations.initMocks(this);
       ...
    }
    ...

Answer 8

Alternative suggestion: don't use Mockito. Spring comes with its own testing classes that you can use to mock, and you can use the SpringJUnit4ClassRunner . Using the Spring JUnit test runner allows you to load a full Spring configuration (via @ContextConfiguration ) as well as to mock objects. In your case, much of your instantiation code goes away, because you will be running Spring, not mimicking its DI.