Unit Testing with Mockito

INTRODUCTION

Mockito is one of the testing framework which provides easy way to test the DAO and Service layer API methods.

It provides set of APIs which helps to avoid the actual call to the database or any external service to fetch the data and verify the data.

The idea is to mock the required object and test the methods with the mocked object.

Refer Page: http://code.google.com/p/mockito/ for more information.

IMPLEMENTATION

Consider I am having a service method which actually performs the addition of new employee into the existing system.

Create a Model for Person.

1. package java2ranjith.mokito.dto;  
2.   
3. public class Person {  
4.   
5.   private String id;  
6.   private String name;  
7.   private String age;  
8.   private String address;  
9.   
10.   public String getId() {  
11.     return id;  
12.   }  
13.   
14.   public void setId(String id) {  
15.     this.id = id;  
16.   }  
17.   
18.   public String getName() {  
19.     return name;  
20.   }  
21.   
22.   public void setName(String name) {  
23.     this.name = name;  
24.   }  
25.   
26.   public String getAge() {  
27.     return age;  
28.   }  
29.   
30.   public void setAge(String age) {  
31.     this.age = age;  
32.   }  
33.   
34.   public String getAddress() {  
35.     return address;  
36.   }  
37.   
38.   public void setAddress(String address) {  
39.     this.address = address;  
40.   }  
41. }

Create a Service.

1. package java2ranjith.mokito.service;  
2.   
3. import java2ranjith.mokito.dao.DataHolder;  
4. import java2ranjith.mokito.dto.Person;  
5.   
6. public class PersonService {  
7.   
8.   DataHolder dataholder = new DataHolder();  
9.   
10.   public void add(Person person) {  
11.     dataholder.add(person);  
12.   }  
13.   
14.   public void remove(String id) {  
15.     dataholder.remove(id);  
16.   }  
17.   
18.   public Person get(String id) {  
19.     return dataholder.get(id);  
20.   }  
21. }  

Create a Data Holder which actually stores the data into the map instead storing into the specific database.

1. package java2ranjith.mokito.dao;  
2.   
3. import java.util.HashMap;  
4. import java.util.Map;  
5. import java2ranjith.mokito.dto.Person;  
6.   
7. public class DataHolder {  
8.   
9.   public static Map<String, Person> data = new HashMap<>();  
10.   
11.   public void add(Person person) {  
12.     data.put(person.getId(), person);  
13.   }  
14.   
15.   public Person get(String id) {  
16.     return data.get(id);  
17.   }  
18.   
19.   public void remove(String id) {  
20.     data.remove(id);  
21.   }  
22. }  

And finally, my test class is MockitoTest.java which contains the list of test methods to test the actual service methods.

1. package java2ranjith.mokito.test;  
2.   
3. import static org.mockito.Matchers.anyString;  
4.   
5. import java2ranjith.mokito.dao.DataHolder;  
6. import java2ranjith.mokito.dto.Person;  
7. import java2ranjith.mokito.service.PersonService;  
8.   
9. import junit.framework.Assert;  
10.   
11. import org.junit.Before;  
12. import org.junit.Test;  
13. import org.junit.runner.RunWith;  
14. import org.mockito.InjectMocks;  
15. import org.mockito.Mock;  
16. import org.mockito.Mockito;  
17. import org.mockito.Spy;  
18. import org.powermock.api.mockito.PowerMockito;  
19. import org.powermock.core.classloader.annotations.PrepareForTest;  
20. import org.powermock.modules.junit4.PowerMockRunner;  
21. import org.powermock.reflect.Whitebox;  
22.   
23.   
24. @RunWith(PowerMockRunner.class)  
25. @PrepareForTest({ PersonService.class, Person.class, DataHolder.class })  
26. public class MockitoTest {  
27.   
28.   @Before  
29.   public void setUp() throws Exception {  
30.     mockPrivateClasses();  
31.   }  
32.   
33.   @Spy  
34.   @InjectMocks  
35.   PersonService personService = initPersonService();  
36.   
37.   @Mock  
38.   DataHolder mockedDataHolder;  
39.   
40.   @Test  
41.   public void testAdd() {  
42.     final String empId = "1000";  
43.     // GIVEN (do the required things before the actual service method called.)  
44.     /** 
45.      * Here i am building the required object to  
46.      * be stored into the database. 
47.      */  
48.     Person person = buildPerson();  
49.     person.setId(empId); // setting my own id.  
50.   
51.     /** 
52.      * Mocking the return object of the DAO method. The meaning of  
53.      * the below code is, when any service method which calls  
54.      * the dao method get() with any string, i.e any empId, then return 
55.      * my constructed(mocked) object. 
56.      */  
57.     Mockito.doReturn(person).when(mockedDataHolder).get(anyString());  
58.   
59.     // WHEN (fire the service method)  
60.     personService.add(person); // calling the service method  
61.     // to check retrieve the Person object with the empId.  
62.     Person newPersonObject = personService.get(empId);  
63.   
64.     // THEN (do the necessary testing on the retrived object.)  
65.     Assert.assertNotNull(newPersonObject);  
66.     Assert.assertEquals(newPersonObject.getName(), person.getName());  
67.   }  
68.   
69.   /** 
70.    * Construct the Person object with required values. 
71.    * 
72.    * @return 
73.    */  
74.   private Person buildPerson() {  
75.     Person person1 = new Person();  
76.     person1.setId("1");  
77.     person1.setName("one");  
78.     person1.setAge("10");  
79.     person1.setAddress("OneOneOne");  
80.   
81.     return person1;  
82.   }  
83.   
84.   /** 
85.    * Mock the private classes for the testing. 
86.    */  
87.   private void mockPrivateClasses() {  
88.     PowerMockito.mockStatic(PersonService.class);  
89.     PowerMockito.mockStatic(Person.class);  
90.     PowerMockito.mockStatic(DataHolder.class);  
91.   }  
92.   
93.   private PersonService initPersonService() {  
94.     return Whitebox.newInstance(PersonService.class);  
95.   }  
96. }