How you can check your Java functions 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("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");
    }

    @Take a look at
    void testOne() {
        System.out.println("Take a look at One");
    }

    @Take a look at
    void testTwo() {
        System.out.println("Take a look at Two");
    }
}

The output from working this check prints the next:

Hook up with the database
Load the schema
Take a look at One
Drop the schema
Load the schema
Take a look at Two
Drop the schema
Disconnect from the database

As you may see from this output, the beforeAll methodology known as first and should do one thing like hook up with a database or create a big information 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 surroundings, presumably by disconnecting from a database.

Earlier than wrapping up this preliminary introduction to testing with JUnit 5, I’ll present you methods to use tags to selectively run completely different sorts of check instances. Tags are used to determine and filter particular exams that you just need to run in varied eventualities. For instance, you may 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.Take a look at;

@Tag("Growth")
class TestOne {
    @Take a look at
    void testOne() {
        System.out.println("Take a look at 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.Take a look at;

@Tag("Growth")
class TestTwo {
    @Take a look at
    void testTwo() {
        System.out.println("Take a look at 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.Take a look at;

@Tag("Integration")
class TestThree {
    @Take a look at
    void testThree() {
        System.out.println("Take a look at 3");
    }
}

Tags are carried out by way of 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 “Growth” tag, and TestThree is annotated with the “Integration” tag. We will filter check runs in numerous methods based mostly on tags. The only of those is to specify a check in your Maven command line; for instance, the next solely executes exams tagged as “Growth”:

mvn clear check -Dgroups="Growth"

The teams property means that you can 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] Working com.javaworld.geekcap.tags.TestOne
Take a look at 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
Take a look at 2
[INFO] Exams 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 mixing exams as follows:

mvn clear check -Dgroups="Integration"

Or, we might execute each improvement and integration exams:

mvn clear check -Dgroups="Growth, Integration"

Along with the teams property, JUnit 5 means that you can use an excludedGroups property to execute all exams that do not need the desired tag. For instance, in a improvement surroundings, we don’t need to execute the mixing 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 hundreds of exams. In case you wished to create this environmental differentiation and add some new manufacturing exams, you wouldn’t need to have to return and add a “Growth” tag to the opposite 10,000 exams.

Lastly, you may add these identical teams and excludedGroups fields to the surefire plugin in your Maven POM file. You may also management these fields utilizing Maven profiles. I encourage you to evaluation the JUnit 5 user guide to study extra about tags.

Conclusion

This text launched among the highlights of working with JUnit 5. I confirmed you methods to configure a Maven challenge to make use of JUnit 5 and methods to write exams utilizing the @Take a look at 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.