Mockito Annotations

The Mockito framework provides a variety of annotations to make the code simple and easy to understand. Also, it reduces the lines of code that helps in focusing on the business logic. In Mockito, annotations are useful when we want to use the mocked object at different places to avoid calling the same methods multiple times.

The Mockito annotations are given below:

@Mock: It is used to mock the objects that helps in minimizing the repetitive mock objects. It makes the test code and verification error easier to read as parameter names (field names) are used to identify the mocks. The @Mock annotation is available in the org.mockito package.
Following code snippet shows how to use the @mock annotation:

Note: The @Mock annotation is always used with the @RunWith annotation.

@RunWith: It is a class-level annotation. It is used to keep the test clean and improves debugging. It also detects the unused stubs available in the test and initialize mocks annotated with @Mock annotation. The @RunWith annotation is available in the org.mockito.junit package.
Following code snippet shows how to use the @RunWith annotation:

In the above code snippet, the MockitoJUnitRunner class is used to check that all the mocks are created and autowired when needed.

@InjectMocks: It marks a field or parameter on which the injection should be performed. It allows shorthand mock and spy injections and minimizes the repetitive mocks and spy injection. In Mockito, the mocks are injected either by setter injection, constructor injection, and property injection. The @InjectMocks annotation is available in the org.mockito package.
Following code snippet shows how to use the @InjectMocks annotation:

@Captor: It allows the creation of a field-level argument captor. It is used with the Mockito’s verify() method to get the values passed when a method is called. Like other annotations, @Captor annotation is also available in the org.mockito package.
Following code snippet shows how to use the @Captor annotation:

@Spy – It allows the creation of partially mock objects. In other words, it allows shorthand wrapping of the field instances in a spy object. Like other annotations, @Spy annotation is also available in the org.mockito package.
Following code snippet shows how to use the @Spy annotation:

Example of Mockito annotations (@Mock, @RunWith, @InjectMocks, @Captor, @Spy)

Here, we are going to create an example of testing by using the annotations @Mock, @RunWith, @InjectMocks, @Captor, @Spy. Following are the steps to create an example of Mockito annotations:

Step 1: Create an interface named ToDoService that contains two unimplemented methods.

ToDoService.java

  import java.util.List;    public interface ToDoService {     public List<String> getTodos(String user);  public void deleteTodos(String doString);    }  

Step 2: Create an implementation class named ToDoBusiness.

ToDoBusiness.java

  import java.util.ArrayList;  import java.util.List;    // ToDoBusiness is a SUT (system under test)   // ToDoService is a Dependency (as ToDoBusiness is dependent on it)    public class ToDoBusiness {    public ToDoService doService;    public ToDoBusiness(ToDoService doService) {  this.doService = doService;  }    public List<String> getTodosforHibernate(String user) {        List<String> hibernatelist = new ArrayList<String>();     List<String> Combinedlist = doService.getTodos(user);        for(String todo:Combinedlist) {     if(todo.contains(“Hibernate”))    {    hibernatelist.add(todo);     }     } return hibernatelist;    }     public void deleteTodosNotRelatedToHibernate(String user) {    List<String> Combinedlist = doService.getTodos(user);    for(String todos:Combinedlist) {  if(!todos.contains(“Hibernate”))   {  doService.deleteTodos(todos);  }  }  }   }  

Step 3: Create a mock test named ToDoBusinessMock for testing purposes. In the following code, we will use all the annotations that we have discussed above.

ToDoBusinessMock.java

  import static junit.framework.Assert.assertEquals;  import static org.hamcrest.CoreMatchers.is;  import static org.junit.Assert.assertThat;  import static org.mockito.BDDMockito.given;  import static org.mockito.BDDMockito.then;  import static org.mockito.Mockito.never;  import static org.mockito.Mockito.times;  import static org.mockito.Mockito.verify;    import java.util.ArrayList;  import java.util.Arrays;  import java.util.List;    import org.junit.Test;  import org.junit.runner.RunWith;  import org.mockito.ArgumentCaptor;  import org.mockito.Captor;  import org.mockito.InjectMocks;  import org.mockito.Mock;  import org.mockito.Spy;  import org.mockito.runners.MockitoJUnitRunner;    @RunWith(MockitoJUnitRunner.class)  public class ToDoBusinessMock {    @Mock  ToDoService servicemock;    @InjectMocks  ToDoBusiness business;     @Captor  ArgumentCaptor<String> argumentCaptor;    @Spy  ArrayList<String> arraylistSpy;        @Test            public void deleteTodosusing_BDD() {        // Given     List<String> combinedlist = Arrays.asList(“Use Hibernate Java”,    “Use Hibernate Core”, “Use Hibernate”, “Use Spring MVC”);       given(servicemock.getTodos(“dummy”)).willReturn(combinedlist);        arraylistSpy.add(“Mockito1”);    arraylistSpy.add(“Mockito2”);        // When     business.deleteTodosNotRelatedToHibernate(“dummy”);        // Then     verify(arraylistSpy).add(“Mockito1”);    verify(arraylistSpy).add(“Mockito2”);    verify(servicemock, times(1)).deleteTodos(“Use Spring MVC”);    verify(servicemock, never()).deleteTodos(“Use Hibernate Java”);    verify(servicemock, never()).deleteTodos(“Use Hibernate”);        assertEquals(2, arraylistSpy.size());    System.out.println(“test is working..”);   }       @Test     public void deleteTodosusing_BDD_usingArgumentCaptor() {       //Given     List<String> combinedlist = Arrays.asList(“Use Hibernate Java”,    “Use Hibernate Core”, “Use Hibernate”, “Use Spring MVC”);        given(servicemock.getTodos(“dummy”)).willReturn(combinedlist);        //When     business.deleteTodosNotRelatedToHibernate(“dummy”);        //Then    then(servicemock).should().deleteTodos(argumentCaptor.capture());    assertThat(argumentCaptor.getValue(),is(“Use Spring MVC”));    System.out.println(“test is working..”);   }   }  

Output

The following output shows that the test is successfully running using Mockito annotations.

Mockito Annotations

Next TopicJUnit Rules

Mockito Annotations

Mockito Annotations

Note: The @Mock annotation is always used with the @RunWith annotation.

Example of Mockito annotations (@Mock, @RunWith, @InjectMocks, @Captor, @Spy)

Applications of Wireless Communication

Bold, Italic and Underline Command in MS Word

You may also like