Junit Test with Mockito

Mockito is a testing framework for Java which allows the creation of Test Double objects called "Mock Objects" for use in automated unit testing in conjunction with framework like Junit. 
For more details, Check here.

This blog will show you step by step working of Mockito.

Step 1 : You need mockito-all and Junit jars into you project classpath which you can download it from here.
If you are using maven, add following dependency into your pom.xml file.

<dependency>
            <groupid>org.mockito</groupid>
            <artifactid>mockito-all</artifactid>
            <version>1.9.5</version>
</dependency>
<dependency>
            <groupid>junit</groupid>
            <artifactid>junit</artifactid>
            <version>4.11</version>
</dependency>

Step 2 : Below is the main service method which we are going to test using Mockito.

import java.util.Iterator;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * Provide methods to work with Employees.
 *
 * @author abdul
 *
 */
@Service
public class EmployeeServiceImpl implements EmployeeService {

    private EmployeeDao employeeDao;

  
    @Override
    @Transactional
    public Employee getEmployee(long employeeId) throws Exception {
        Employee employee = employeeDao.getEmployee(employeeId);
        if(employee == null) throw new Exception("Employee not found");
        return employee;
    }
}

Step 3: Now create the test with Mockito

package com.waheed.spring.hibernate.test;

import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

import com.waheed.spring.hibernate.Employee;
import com.waheed.spring.hibernate.EmployeeDao;
import com.waheed.spring.hibernate.EmployeeServiceImpl;

@RunWith(MockitoJUnitRunner.class)
public class EmployeeTest {
   
    @Mock EmployeeDao mockDao;

    @InjectMocks EmployeeServiceImpl employeeServiceImpl;
   
    private Employee employee;
   
    @Before
    public void setup() {
        employee = new Employee();
        setEmployee();
    }
   
    private void setEmployee() {
        employee.setId(1);
        employee.setGender("M");
        employee.setCountry("INDIA");
        employee.setAboutYou("CRICKEETER");
        employee.setName("Sachin");
    }
   
    @Test
    public void employeeTest() throws Exception {
        when(mockDao.getEmployee(1)).thenReturn(employee);
        Employee emp =employeeServiceImpl.getEmployee(1);
        System.out.println(emp.toString());
       
        //Verify if getEmployee method was invoked on employeeServiceImpl call
        verify(mockDao).getEmployee(1);
        assertEquals("Tesing",emp.getName(),"Sachin");
    }
   
    @Test(expected=Exception.class)
    public void employeeTestFailure() throws Exception {
        when(mockDao.getEmployee(10)).thenReturn(null);
        Employee emp = employeeServiceImpl.getEmployee(10);
       
    }
}

Step 4 : Let me explain in few words, what's going on in my test class. 

• As I am testing the EmployeeDao so I have created the mocks for EmployeeDao using @Mock Annotation. 
• @InjectMocks : Use this annotation on the class you are testing. The mock classes are injected into the @InjectMocks class.
• To create mocks, we need to add @RunWith(MockitoJUnitRunner.class) annotation to the test class or you can use MockitoAnnotations.initMocks(this) in your class in @Before method. 
• When(...)thenReturn(...) : It specify what should be returned after the particular method was called. 
• verify() : It ensure that specified conditions are met.

You can download the above source code from here

References:

https://code.google.com/p/mockito/