What

Description

Version 5 of the popular testing framework JUnit was first released in September 2017. Since then, JUnit 5 is in constant evolution and maintenance. It has been designed using a modular architecture made up of three main components:

• Platform: Foundation component providing generic capabilities to discover and execute test cases in a Java Virtual Machine (JVM).
• Vintage: Engine for legacy tests (JUnit 3 and 4).
• Jupiter: Engine for the new programming and extension model.

Jupiter tests can be executed using a build tool such as Maven, Gradle, or Ant. Besides, modern Integrated Development Environments (IDEs) such as IntelliJ IDEA, Eclipse, or Visual Studio, are shipped with built-in capabilities to execute JUnit tests out of the box.

Java annotations are one of the main building blocks of the Jupiter programming and extension model. For instance, we can specify the logic to exercise and verify a System Under Test (SUT), i.e., a test case (or simply test), using the annotation @Test at method-level in a Java class. Other basic annotations to define the rest of the basic test lifecycle are @BeforeEach/@BeforeAll (setup logic, executed before the test) and (@AfterEach/@AfterAll (teardown logic, executed after the test). When coming to data verification, Jupiter provides a rich API for assertions (e.g., assertTrue, assertFalse, assertEquals, assertArrayEquals, among many others). Besides, we can use a third-party advanced assertions library in conjunction with Jupiter, for example, Hamcrest, Truth, or AssertJ, to name a few.

Jupiter provides a wide variety of additional features to develop different types of tests. In this workshop, we review some of the most relevant, for instance:

• Tagging and filtering: Label and execute a group of tests.
• Parameterized tests: Implement data-driven tests.
• Parallel execution: Use a thread-pool to execute a test suite in parallel.

Finally, we introduce the extension model of Jupiter. An extension in Jupiter is a Java class that allows developers to incorporate extra features into Jupiter. The building blocks of the Jupiter extension model are the so-called extension points. These extension points are Java interfaces implemented to enhance test lifecycle, carry out parameter resolution on test methods, manage test templates, conditional test execution, exception handling, manage test instances, and invocation intercepting.

Takeaways

• Tagging and filtering: Label and execute a group of tests
• Parameterized tests: Implement data-driven tests
• Parallel execution: Use a thread-pool to execute a test suite in parallel
• Describe the modular architecture of JUnit 5
• Execute basic test cases with JUnit 5
• Develop advanced test cases using Jupiter

Prerequisites

Knowledge requirements:

• Basic knowledge of Java language.

Software requirements:

• Java 8+ (JDK preferred).
• Some modern IDE such as Eclipse, IntellijIDEA, Visual Studio, or NetBeans.
• To clone/fork the code examples GitHub repo: https://github.com/bonigarcia/mastering-junit5
• A build tool such as Maven or Gradle (optional).

Speaker

Boni García

Visiting Professor

I am Visiting Professor at Universidad Carlos III de Madrid (UC3M) in Spain. My research interests include software engineering and automated testing. I am the author of more than 35 research papers in different journals, magazines, and international conferences. In 2017 I wrote the book "Mastering Software Testing with JUnit 5". I am the creator and maintainer of several open-source projects, such as WebDriverManager (a helper library for Selenium WebDriver) or Selenium-Jupiter (a JUnit 5 extension for Selenium WebDriver).