Unit Test is a tool that helps us to ensure that the code we write, reflects what we want accurately. In the process of working with the Unit Test, one of the problems we often encounter is that our code will call the methods of other classes, outside the class, the method we are writing. We can initialize those outer classes to call the method we want, but no one knows that the methods of those outer classes also call to other methods of other external classes. And the question is: whether it is important to pay attention to these external classes when we are testing the method of this class because those external classes also have their own Unit Tests.
The answer is no. The Unit Test is a test of small code, will have a Unit Test to ensure the logic for external dependencies, to ensure that the current code we have tested. In this case, the problem is that if the method we are calling to the method of the outer class is processed, how does the code call that method? How can the returns help us cover the logic in the Unit Test.
To solve this problem, in Unit Test, one concept is called Mock, which simulates the behavior of external classes to perform the behavior we expect. Then, the code that calls the external methods will return the value we expect. Because of controlling the code by ourself, the simulator still guarantees the quality of the code we are writing Unit Test. In this tutorial, I will show you all how to use Mock in the Unit Test with a popular Java Mocking library called Mockito.
First, I will create a new Maven project as an example:
with 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 |
<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> |
Now that I’m going to create a small application that will allow users to pass in two numbers, we’ll compute those two numbers, which will return true if the result is greater than 10, otherwise false. The code will look like this:
We have a class to sum two numbers:
|
1 2 3 4 5 6 7 8 9 |
package com.huongdanjava.mockito; public class Calculation { public int sum(int a, int b) { return a + b; } } |
A main class of applications in which it has a method for checking the result of the computation and returns true, false based on the result:
|
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 |
package com.huongdanjava.mockito; public class Application { private Calculation calculation; public boolean check(int a, int b) { int sum = calculation.sum(a, b); return sum > 10; } public Calculation getCalculation() { return calculation; } public void setCalculation(Calculation calculation) { this.calculation = calculation; } public static void main(String[] args) { Application a = new Application(); a.setCalculation(new Calculation()); if (a.check(2, 9)) { System.out.println("Greater than 10"); } else { System.out.println("Less than 10"); } } } |
The results are as follows:
Now, we will write Unit Test for our classes.
I will create a class CalculationTest to test the class Calculation with the following content:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
package com.huongdanjava.mockito; import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.Test; public class CalculationTest { @Test public void testSum() { Calculation calculation = new Calculation(); int a = 2; int b = 12; int c = calculation.sum(a, b); assertEquals(14, c); } } |
Unit Test for class Calculation, it is simple, right ? 😀
For the Unit Test of the Application class, the main() method is the method to run the application, so we do not need to test. Only check() method we need to test.
Normally, I can write Unit Test for this check() method as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package com.huongdanjava.mockito; import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.Test; public class ApplicationTest { @Test public void testCheck() { Application application = new Application(); application.setCalculation(new Calculation()); int a = 2; int b = 12; boolean c = application.check(a, b); assertEquals(true, c); } } |
But if you look carefully, you will see the following code in the check() method of the Application class:
|
1 |
int sum = calculation.sum(a, b); |
we tested in the above CalculationTest class, so we will not need to test again. The only thing we need to test in this check() method is just the return code.
Now, let’s apply Mock for Calculation class.
First, you need to use Mockito to create a Mock object for the Calculation class:
|
1 |
Calculation calculationMock = Mockito.mock(Calculation.class); |
As you can see, here I have used the mock() static method of the Mockito class in the Mockito library to create a Mock object for the Calculation class. There are many overload mock() static methods in the Mockito class, depending on the needs you can use.
Once you have the Mock object of the Calculation class, you can set this mock object for use in the Application class as follows:
|
1 2 3 4 |
Calculation calculationMock = Mockito.mock(Calculation.class); Application application = new Application(); application.setCalculation(calculationMock); |
Now we will simulate the behavior of the Calculation object in the Application class using its Mock object.
Assuming now, I want to when the Application class calls the sum() method of two numbers 2 and 12 in the Calculation class, I will return 14 without regard to the logic of sum() method, then I will mock as follows:
|
1 |
Mockito.when(calculationMock.sum(2, 12)).thenReturn(14); |
You can return any value but make sure it’s the right expectation.
The entire testCheck() code will now look like this:
|
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 |
package com.huongdanjava.mockito; import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ApplicationTest { @Test public void testCheck() { Calculation calculationMock = Mockito.mock(Calculation.class); Application application = new Application(); application.setCalculation(calculationMock); Mockito.when(calculationMock.sum(2, 12)).thenReturn(14); int a = 2; int b = 12; boolean c = application.check(a, b); assertEquals(true, c); } } |
Result:
If you now modify the mock code, the sum() method returns 8:
|
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 |
package com.huongdanjava.mockito; import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ApplicationTest { @Test public void testCheck() { Calculation calculationMock = Mockito.mock(Calculation.class); Application application = new Application(); application.setCalculation(calculationMock); Mockito.when(calculationMock.sum(2, 12)).thenReturn(8); int a = 2; int b = 12; boolean c = application.check(a, b); assertEquals(true, c); } } |
The results are as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
------------------------------------------------------- T E S T S ------------------------------------------------------- Running com.huongdanjava.mockito.ApplicationTest Tests run: 1, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 0.633 sec <<< FAILURE! com.huongdanjava.mockito.ApplicationTest.testCheck() Time elapsed: 0.633 sec <<< FAILURE! org.opentest4j.AssertionFailedError: expected: <true> but was: <false> at org.junit.jupiter.api.AssertionUtils.fail(AssertionUtils.java:56) at org.junit.jupiter.api.AssertEquals.failNotEqual(AssertEquals.java:197) at org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:186) at org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:181) at org.junit.jupiter.api.Assertions.assertEquals(Assertions.java:500) at com.huongdanjava.mockito.ApplicationTest.testCheck(ApplicationTest.java:25) Running com.huongdanjava.mockito.CalculationTest Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0 sec Results : Failed tests: com.huongdanjava.mockito.ApplicationTest.testCheck(): expected: <true> but was: <false> Tests run: 2, Failures: 1, Errors: 0, Skipped: 0 |
As you can see, using Mock in the Unit Test makes it possible to determine the result from external classes without regard to their handling. Just make sure the out code, right? 🙂
