Mockito JUnit Rules - Javatpoint

JUnit Rules

In the above examples, we have used the JUnit runner (MockitoJUnitRunner). It makes the test dependent on that particular runner.

We cannot use multiple runners in the same test. To overcome this problem, we should follow JUnit rules that makes the test more flexible. It allows us to use multiple rules in the same test.

A JUnit rule is defined as a component that is used to obstruct the test method calls and allows us to perform something before and after the test method is invoked. The JUnit provides the following rules to:

Create directories/files that are deleted after a test method has been run.
Fail a test, if the described timeout has exceeded before a test method is invoked.
Establish an external resource like a socket or a database connection before a test method is invoked.
Free the configured external resource after a test method is invoked.

To use the JUnit rules, we need to add the @Rule annotation in the test.

@Rule: It annotates the fields. It refer to the rules or methods that returns a rule. The annotated fields must be public, non-static, and subtypes of the TestRule or MethodRule.

@Rule
public MockitoRule mockitorule = MockitoJUnit.rule();

In the above code snippet, we have used the MockitoRule class. You can use any JUnit rule as per your requirement.

Example of JUnit Rule (MockitoRule)

Here, we are going to create an example using the JUnit rule. In this example, we are using the MockitoRule, and we can use any JUnit rule as per your requirement.

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 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 test class named ToDoBusinessMock in which business logic is defined.

ToDoBusinessMock.java

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.Arrays;
import java.util.List;

import org.junit.Rule;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;

public class ToDoBusinessMock {

       @Rule
	public MockitoRule mockitorule = MockitoJUnit.rule();
	
	@Mock
	ToDoService servicemock;
	
	@InjectMocks
	ToDoBusiness business; 
	
	@Captor
	ArgumentCaptor<String> argumentCaptor;
	 
             @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);
	  
	  // When 
	  business.deleteTodosNotRelatedToHibernate("dummy");
	  
	  // Then 
	  verify(servicemock, times(1)).deleteTodos("Use Spring MVC");
	  verify(servicemock, never()).deleteTodos("Use Hibernate Java");
	  verify(servicemock, never()).deleteTodos("Use Hibernate"); 
               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 the JUnit rule (MockitoRule).