UnitTest Simple Java Command
1. What you will learn
In this guide you will learn how to write Unit Tests for simple Java Commands. This allows you to test the Command before shipping it to an application.
2. Prerequisites
To complete this guide you need:
-
Roughly 10 minutes
-
JDK11+ installed with JAVA_HOME configured appropriately
-
An IDE (we recommend IntelliJ)
-
Some kind of build tool (like gradle, maven or ant)
-
Read the Step by Step Simple Java Command guide
-
JUnit 5 environment
3. Dependencies
To write Unit Tests for a Command we need to have some dependencies included:
| Dependencies | Reason to include |
|---|---|
|
de.asap.pak.jlcint:jlcint-commandapi |
Provides annotations used to develop a Java Command |
|
de.asap.pak.jlcint:jlcint-testutils |
Utilities that allow the testing of Java Commands |
|
org.junit.jupiter:junit-jupiter |
Allows the writing of JUnit5 tests |
|
org.junit.jupiter:junit-jupiter-engine |
4. The Unit Test
We want to test the Java Command we have written in the Step by Step Simple Java Command guide.
4.1. The Unit Test Base
In this chapter it is explained how the base structure of a Command Unit Test has to look like before even writing the first test. On the left side of the table below we have our simple Java Command, on the right we have their respective test class.
| Command Class | Test Class |
|---|---|
|
|
| 1 | To simulate flow of inputs and outputs of the Command, we need to extend our JUnit test with the JlcintExtension provided by the jlcint-testutils dependency. |
| 2 | The @Persistent fields of the Command class are mirrored inside the test class. This allows to assign inputs and read outputs during a test. |
| 3 | The Provider from the jlcint-testutils is parametrized to the Command we want to test, in our case it is the Adding Command. The provider allows us to run the Command during a test with all their inputs set beforehand. |
The @Persistent-Annotation of the Command Fields need not be mirrored 1 to 1. For the test class it is sufficient to have a simple annotation over the input and output fields.
|
4.2. The First Test
Now that we established a base, we can continue with writing our first test. We want to test if the Adding Command does truly add numbers according our expectations. Therefore, we write the following test.
@ExtendWith(JlcintExtension.class)
class AddingTest {
@Persistent
private int numberOne;
@Persistent
private int numberTwo;
@Persistent
private int result;
private Provider<Adding> command;
/**
* Tests if 1 + 2 = 3
*/
@Test (1)
void test_adding() throws Exception{
// Define inputs (2)
this.numberOne = 1;
this.numberTwo = 2;
// Run Command (3)
this.command.execute();
// Verify outputs (4)
assertEquals(3,this.result);
}
}| 1 | We added the test method test_adding(), so we can test the command. |
| 2 | Before the Command is run, we need to set the inputs beforehand. The inputs for the Command are our test class fields numberOne and numberTwo accordingly. |
| 3 | After everything is set, we run the Command by calling execute() on the Provider field command. |
| 4 | When the Command runs without an exception we can verify their outputs. Here we assert that result does equal the expected result 3. |
Now you can run the test and see if the Command runs as expected.
5. Summary
In this guide we have learned how to write a Unit Test for a simple Java Command. How the input and output fields can be accessed and how the Command can be run from within a test method.
6. What to do next?
-
The guide Build and Run your first Command could interest you, when you want to build and use the tested Command in the executor.