In the previous tutorial, we passed the Mock object to the class which we are writing the Unit Test using the Setter method of this class. However, in case you are using the Spring framework in your application, the dependent objects are injected into the object we are writing Unit Test using the @Autowire annotation, so we will not have Setter methods for passing Mock objects. In this case, you can use @InjectMocks annotation of Mockito to do this. How is it in details? We will learn together in this tutorial!
First, I will create a Maven project:
with Spring framework, Mockito and JUnit dependencies as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.0</version> </dependency> <dependency> <groupId>org.mockito</groupId> <artifactId>mockito-junit-jupiter</artifactId> <version>3.6.0</version> <scope>test</scope> </dependency> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-engine</artifactId> <version>5.7.0</version> <scope>test</scope> </dependency> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>5.7.0</version> <scope>test</scope> </dependency> |
With JUnit 5, to run Unit Test with Maven, we need to declare the maven-surefire-plugin plugin of Maven with the latest version as follows:
|
1 2 3 4 5 6 7 8 |
<build> <plugins> <plugin> <artifactId>maven-surefire-plugin</artifactId> <version>2.22.2</version> </plugin> </plugins> </build> |
And compile source with target using Java 8 onwards:
|
1 2 3 4 |
<properties> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> </properties> |
In the example of this tutorial, I am going to create a small application with a Calculation class that defines a method for calculating the subtraction of two numbers, declared with the @Component annotation of Spring as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
package com.huongdanjava.mockito; import org.springframework.stereotype.Component; @Component public class Calculation { public int sub(int a, int b) { return a - b; } } |
And an Application class defines a method that uses the method of class Calculation to calculate the subtraction of two numbers, if the result is greater than 0 then returns true, otherwise false. This class injects the object bean of the Calculation class using the Spring @Autowire annotation and is declared with the @Service annotation as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
package com.huongdanjava.mockito; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.stereotype.Service; @Service public class Application { @Autowired private Calculation calculation; public boolean check(int a, int b) { int result = calculation.sub(a, b); return result > 0; } public static void main(String[] args) { ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml"); Application a = ac.getBean(Application.class); if (a.check(2, 4)) { System.out.println("Positive"); } else { System.out.println("Negative"); } } } |
with Spring’s configuration file located in the src/main/resources directory with the following contents:
|
1 2 3 4 5 6 7 8 |
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:component-scan base-package="com.huongdanjava.mockito" /> </beans> |
Result:
Now, we will write Unit Test for the Application class!
Because currently, the class Application does not have a Setter method for the Calculation object, I will use Mockito’s @InjectMocks annotation to inject this object into the Application class as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
package com.huongdanjava.mockito; import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension; @ExtendWith(MockitoExtension.class) public class ApplicationTest { @Mock private Calculation calculation; @InjectMocks private Application application; @Test public void testCheck() { Mockito.when(calculation.sub(2, 12)).thenReturn(-10); int a = 2; int b = 12; boolean c = application.check(a, b); assertEquals(false, c); } } |
As you can see, I have declared using the Application class with @InjectMocks annotation. This declaration will allow us to inject all objects declared with the @Mock annotation in the ApplicationTest class into the Application object, here is the Calculation class.
If you now run Maven test then you will see the following result:
