Itemizing 5. Logging the invocations of JUnit 5 lifecycle strategies (LifecycleDemoTest.java)
package deal com.javaworld.geekcap.lifecycle;
import org.junit.jupiter.api.*;
public class LifecycleDemoTest {
@BeforeAll
static void beforeAll() {
System.out.println("Hook up with the database");
}
@BeforeEach
void beforeEach() {
System.out.println("Load the schema");
}
@AfterEach
void afterEach() {
System.out.println("Drop the schema");
}
@AfterAll
static void afterAll() {
System.out.println("Disconnect from the database");
}
@Check
void testOne() {
System.out.println("Check One");
}
@Check
void testTwo() {
System.out.println("Check Two");
}
}
The output from working this take a look at prints the next:
Hook up with the database
Load the schema
Check One
Drop the schema
Load the schema
Check Two
Drop the schema
Disconnect from the database
As you may see from this output, the beforeAll methodology is known as first and should do one thing like connect with a database or create a big knowledge construction into reminiscence. Subsequent, the beforeEach methodology prepares the info for every take a look at; for instance, by populating a take a look at database with an anticipated set of information. The primary take a look at then runs, adopted by the afterEach methodology. This course of (beforeEach—> take a look at—>afterEach) continues till all of the checks have accomplished. Lastly, the afterAll methodology cleans up the take a look at atmosphere, presumably by disconnecting from a database.
Earlier than wrapping up this preliminary introduction to testing with JUnit 5, I’ll present you the right way to use tags to selectively run totally different sorts of take a look at circumstances. Tags are used to determine and filter particular checks that you simply wish to run in numerous eventualities. For instance, you may tag one take a look at class or methodology as an integration take a look at and one other as improvement code. The names and makes use of of the tags are all as much as you.
We’ll create three new take a look at courses and tag two of them as improvement and one as integration, presumably to distinguish between checks you wish to run when constructing for various environments. Listings 6, 7, and eight present these three easy checks.
Itemizing 6. JUnit 5 tags, take a look at 1 (TestOne.java)
package deal com.javaworld.geekcap.tags;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Check;
@Tag("Growth")
class TestOne {
@Check
void testOne() {
System.out.println("Check 1");
}
}
Itemizing 7. JUnit 5 tags, take a look at 2 (TestTwo.java)
package deal com.javaworld.geekcap.tags;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Check;
@Tag("Growth")
class TestTwo {
@Check
void testTwo() {
System.out.println("Check 2");
}
}
Itemizing 8. JUnit 5 tags, take a look at 3 (TestThree.java)
package deal com.javaworld.geekcap.tags;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Check;
@Tag("Integration")
class TestThree {
@Check
void testThree() {
System.out.println("Check 3");
}
}
Tags are carried out by way of annotations, and you’ll annotate both a complete take a look at class or particular person strategies in a take a look at class; moreover, a category or a technique can have a number of tags. On this instance, TestOne and TestTwo are annotated with the “Growth” tag, and TestThree is annotated with the “Integration” tag. We are able to filter take a look at runs in several methods based mostly on tags. The best of those is to specify a take a look at in your Maven command line; for instance, the next solely executes checks tagged as “Growth”:
mvn clear take a look at -Dgroups="Growth"
The teams property permits you to specify a comma-separated listing of tag names for the checks that you really want JUnit 5 to run. Executing this yields the next output:
[INFO] -------------------------------------------------------
[INFO] T E S T S
[INFO] -------------------------------------------------------
[INFO] Working com.javaworld.geekcap.tags.TestOne
Check 1
[INFO] Exams run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.029 s - in com.javaworld.geekcap.tags.TestOne
[INFO] Working com.javaworld.geekcap.tags.TestTwo
Check 2
[INFO] Exams run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.001 s - in com.javaworld.geekcap.tags.TestTwo
Likewise, we may execute simply the mixing checks as follows:
mvn clear take a look at -Dgroups="Integration"
Or, we may execute each improvement and integration checks:
mvn clear take a look at -Dgroups="Growth, Integration"
Along with the teams property, JUnit 5 permits you to use an excludedGroups property to execute all checks that shouldn’t have the desired tag. For instance, in a improvement atmosphere, we don’t wish to execute the mixing checks, so we may execute the next:
mvn clear take a look at -DexcludedGroups="Integration"
That is useful as a result of a big software can have actually hundreds of checks. For those who needed to create this environmental differentiation and add some new manufacturing checks, you wouldn’t wish to have to return and add a “Growth” tag to the opposite 10,000 checks.
Lastly, you may add these similar teams and excludedGroups fields to the surefire plugin in your Maven POM file. You may as well management these fields utilizing Maven profiles. I encourage you to evaluate the JUnit 5 consumer information to be taught extra about tags.
Conclusion
This text launched a number of the highlights of working with JUnit 5. I confirmed you the right way to configure a Maven venture to make use of JUnit 5 and the right way to write checks utilizing the @Check and @ParameterizedTest annotations. I then launched the JUnit 5 lifecycle annotations, adopted by a take a look at the use and advantages of filter tags.
