This newsletter contains news and updates about Java development tools, and in particular topics related to the Java Power Tools Bootcamp course. In this issue, we will look at mocking and stubbing, and how to use them together to write more effective and comprehensive unit tests. 

Mocks, Stubs, and why you probably need both

Proximo: Can any of them fight? I've got a match coming up.
Slave Trader: Some are good for fighting, others for dying. You need both, I think.
- Gladiator, Ridley Scott

Although integration and acceptance tests have their uses, it is in fact much easier to write thorough and comprehensive tests using unit tests and mocking libraries. This is especially true when you apply Test-Driven Design techniques such as TDD and BDD to help elucidate a clean, flexible and reliable design for your application. Let's see how this might work. We will be using Mockito, a new and very promising mocking framework for Java.

Mock testing comes in two flavours: Stubbing and Mocking. As the guy said in the film, you need both, I think.

Stubbing is in many ways more intuitive than mocking. A stub is essentially a cheap imitation of a real class, that returns predictable data under controlled circumstances. You use a stubbed-out object to return a known result or set of data, so that you can make sure your class handles this use case correctly. 

Let's look at a simple example. Imagine your application has a servlet that lets people register on your site. This servlet uses a service layer to do the actual registration business logic. What might our tests look like?

Let's keep things simple, and assume that a user need only provide a unique username to register. Our UserManager class has a register() method that registers a user in the database. Now we already have unit tests for the UserManager class, so we don't need to test it again here - at this stage we are interested in the RegisterUser servlet class. We will be using Mockito to stub out our domain class: we just want the register() method to return a valid User object when the servlet registers a new user. We will also use the Spring mock objects library to mock out the HTTPServlet request and response objects. Let's look at the code:

import static org.hamcrest.MatcherAssert.assertThat;

import static org.hamcrest.Matchers.*;

import static org.mockito.Mockito.*;
import static org.mockito.BDDMockito.*; 

...
/**

 * Using Mockito to mock out the UserManager class.

 */

UserManager userManager = mock(UserManager.class);                 

@Test 

public void registerNewUserShouldPlaceBabblerInSession()
              throws Exception {

  RegisterServlet servlet = new RegisterServlet();
  servlet.setUserManager(userManager);

  servlet.init(new MockServletConfig());

  // 
  // Now we use Mockito to set up a UserManager
  // stub that returns a valid User object when
  // the register() method is called (note the
  // BDD terminology)
  // 
  given(userManager.register("Joe"))
                   .willReturn(new User("Joe"));

         
  // 
  // Now we use the Spring mock objects to prepare
  // a mock HTTP request and response...

  MockHttpServletRequest request
     = new MockHttpServletRequest();

  HttpServletResponse response
     = mock(HttpServletResponse.class);

        
  request.setParameter("username", "Joe");

  servlet.doGet(request, response);

         
  //
  // Finally, we ensure that the user has been
  // saved in the mocked-out HTTP session
  //

  User loggedInUser
    = (User) request.getSession()
                    .getAttribute("user");

  assertThat(loggedInUser, notNullValue());

  assertThat(loggedInUser.getName(), is("Joe"));

}

@Test 

public void registerNewUserShouldGoToHomePage()
     throws Exception {

  //
  // Set up the servlet as before
  //
  RegisterServlet servlet = new RegisterServlet();

  servlet.setUserManager(userManager);

  servlet.init(new MockServletConfig());
 

  //
  // Here we use a more traditional mocking style
  // to mock out the userManager class
  //
  when(userManager.register("Joe"))
                  .thenReturn(new User("Joe"));

  //
  // Now we call the servlet as before.
  //
  MockHttpServletRequest request
    = new MockHttpServletRequest();

  HttpServletResponse response
    = mock(HttpServletResponse.class);

  
  request.setParameter("username", "Joe");

  servlet.doGet(request, response);

  //
  // This time we want to ensure that 
  // the register() method was correctly
  // invoked.
  //
  verify(userManager).register("Joe");

  //
  // We can also verify other classes,
  // such as the HTTPResponse.
  //
  verify(response).sendRedirect("/home");

}  

Training and Bootcamp updates