Tips on how to check your Java purposes with JUnit 5

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("Connect 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 check prints the next:

Connect 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’ll be able to see from this output, the beforeAll methodology 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 information for every check; for instance, by populating a check database with an anticipated set of knowledge. The primary check then runs, adopted by the afterEach methodology. This course of (beforeEach—> check—>afterEach) continues till all of the exams have accomplished. Lastly, the afterAll methodology cleans up the check atmosphere, probably by disconnecting from a database.

Earlier than wrapping up this preliminary introduction to testing with JUnit 5, I’ll present you the best way to use tags to selectively run totally different sorts of check circumstances. Tags are used to determine and filter particular exams that you simply need to run in varied situations. For instance, you would possibly tag one check class or methodology as an integration check 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 check lessons and tag two of them as improvement and one as integration, presumably to distinguish between exams you need to run when constructing for various environments. Listings 6, 7, and eight present these three easy exams.

Itemizing 6. JUnit 5 tags, check 1 (TestOne.java)

package deal com.javaworld.geekcap.tags;

import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Check;

@Tag("Improvement")
class TestOne {
    @Check
    void testOne() {
        System.out.println("Check 1");
    }
}

Itemizing 7. JUnit 5 tags, check 2 (TestTwo.java)

package deal com.javaworld.geekcap.tags;

import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Check;

@Tag("Improvement")
class TestTwo {
    @Check
    void testTwo() {
        System.out.println("Check 2");
    }
}

Itemizing 8. JUnit 5 tags, check 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 via annotations, and you may annotate both a whole check class or particular person strategies in a check class; moreover, a category or a way can have a number of tags. On this instance, TestOne and TestTwo are annotated with the “Improvement” tag, and TestThree is annotated with the “Integration” tag. We will filter check runs in several methods primarily based on tags. The best of those is to specify a check in your Maven command line; for instance, the next solely executes exams tagged as “Improvement”:

mvn clear check -Dgroups="Improvement"

The teams property permits you to specify a comma-separated listing of tag names for the exams that you really want JUnit 5 to run. Executing this yields the next output:

[INFO] -------------------------------------------------------
[INFO]  T E S T S
[INFO] -------------------------------------------------------
[INFO] Operating com.javaworld.geekcap.tags.TestOne
Check 1
[INFO] Checks run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.029 s - in com.javaworld.geekcap.tags.TestOne
[INFO] Operating com.javaworld.geekcap.tags.TestTwo
Check 2
[INFO] Checks run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.001 s - in com.javaworld.geekcap.tags.TestTwo

Likewise, we might execute simply the combination exams as follows:

mvn clear check -Dgroups="Integration"

Or, we might execute each improvement and integration exams:

mvn clear check -Dgroups="Improvement, Integration"

Along with the teams property, JUnit 5 permits you to use an excludedGroups property to execute all exams that do not need the required tag. For instance, in a improvement atmosphere, we don’t need to execute the combination exams, so we might execute the next:

mvn clear check -DexcludedGroups="Integration"

That is useful as a result of a big utility can have actually 1000’s of exams. If you happen to wished to create this environmental differentiation and add some new manufacturing exams, you wouldn’t need to have to return and add a “Improvement” tag to the opposite 10,000 exams.

Lastly, you’ll be able to add these identical teams and excludedGroups fields to the surefire plugin in your Maven POM file. You too can management these fields utilizing Maven profiles. I encourage you to assessment the JUnit 5 consumer information to be taught extra about tags.

Conclusion

This text launched a few of the highlights of working with JUnit 5. I confirmed you the best way to configure a Maven undertaking to make use of JUnit 5 and the best way to write exams utilizing the @Check and @ParameterizedTest annotations. I then launched the JUnit 5 lifecycle annotations, adopted by a have a look at the use and advantages of filter tags.