JUnit 5 at Heisenbug 2017

JUnit 5 at Heisenbug 2017

Over the last decade a lot has happened in the world of Java and testing, but JUnit 4 hasn't kept up. Now JUnit 5 is here to help shape the future of testing on the JVM with a focus on Java 8 language features, extensibility, and a modern programming API for testing in Java. Moreover, JUnit isn't just a Java testing framework anymore. Third parties are already developing test engines for Scala, Groovy, Kotlin, etc. that run on the new JUnit Platform.

In this session, we will start off with an example-driven tour of the new Jupiter programming model and learn how to migrate our existing JUnit 4 based tests. Then, we will discuss the inspiration for JUnit 5, look more closely at its architecture, and discuss compatibility with JUnit 4. Next, we will explore the Jupiter extension model, learn about the extension points it provides, and see how custom extensions for conditional tests, method parameter resolution, lifecycle callbacks etc. are authored and registered. To round off the session, we will look at the roadmap of what's still to come and when you can expect the GA release.

956c7d246841e8507a1e1b96842994db?s=128

Marc Philipp

June 04, 2017
Tweet

Transcript

  1. JUnit 5

  2. Marc Philipp • Senior Software Engineer @ in Germany •

    JUnit Maintainer since 2012 • Twitter: @marcphilipp • Web: http://www.marcphilipp.de
  3. Programming Model

  4. DEMO https://github.com/marcphilipp/junit5-demo/tree/20170604-heisenbug

  5. Meta Annotations Annotations can be combined to enable re-use:
 


    @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 @Tag("integration")
 @Test
 public @interface IntegrationTest {} Usage:
 
 @IntegrationTest
 void test() {}
 Equivalent:
 
 @Tag("integration")
 @Test
 void test() {}
  6. @ParameterizedTest Sources • @ValueSource(ints = { 1, 2, 3 })

    • @EnumSource(TimeUnit.class) • @MethodSource(names = "myProviderMethod") • @CsvSource({ "foo, 1", "bar, 2", "'baz, qux', 3" }) • @CsvFileSource(resources = "/two-column.csv") • @ArgumentsSource(MyArgumentsProvider.class) • @YourCustomSource
  7. @Nested Tests @DisplayName("A stack") class TestingAStackDemo { @Test @DisplayName("is instantiated

    with new Stack()") void isInstantiatedWithNew() {/* ... */} @Nested @DisplayName("when new") class WhenNew { @BeforeEach void createNewStack() {/* ... */} @Test @DisplayName("is empty") void isEmpty() {/* ... */} // ... @Nested @DisplayName("after pushing an element") class AfterPushing { @BeforeEach void pushAnElement() {/* ... */} @Test @DisplayName("it is no longer empty") void isNotEmpty() {/* ... */} // ... } } }
  8. Dynamic Tests @TestFactory Stream<DynamicTest> dynamicTestsFromStream() { return IntStream.iterate(0, n ->

    n + 2).limit(100) .mapToObj(n -> dynamicTest("test" + n, () -> { assertTrue(n % 2 == 0); })); }
  9. @RepeatedTest @RepeatedTest(10) void repeatedTest() { // ... }

  10. Why do we need a new JUnit?

  11. Runner • Very powerful: Almost every aspect of test execution

    can be changed • But: You can only have one Runner per test class! • You can’t combine Runners, e.g.
 SpringJUnit4ClassRunner + Parameterized
  12. Rules • Extension mechanism introduced in JUnit 4.7 • Wraps

    execution of a test (@Rule) or a test class (@ClassRule) • Designed to be combined — great for simple use cases • But: a single rule cannot be used for method-level and class-level callbacks, no support for instance-level callbacks
  13. http://blog.takipi.com/the-top-100-java-libraries-in-2016-after-analyzing-47251-dependencies/

  14. Existing Architecture Everyone uses the junit.jar.

  15. Renaming a private field should not break anything, right? 4.11

    4.12-beta-1
  16. –Johannes Link, https://jaxenter.com/crowdfunding-for-junit-lambda-is- underway-119546.html „The success of JUnit as a

    platform prevents the development of JUnit as a tool.“
  17. Design Goals for JUnit 5 • Modern programming model for

    writing tests (Java 8!) • Powerful extension model with a focus on composability • API Segregation: Decouple test execution/reporting from test definition • Compatibility with older releases + migration path • Modularization + no external dependencies
  18. Modularization

  19. Separation of Concerns 1. An API to write tests (Jupiter

    API) 2. Extensible mechanisms to discover and execute tests (Test Engine SPI) 3. An API for test execution by tools (Launcher API)
  20. P L AT F O R M J U P

    I T E R V I N TA G E P A R T Y T H I R D
  21. P L AT F O R M J U P

    I T E R V I N TA G E P A R T Y T H I R D
  22. JUnitPlatform Runner for a single class import org.junit.jupiter.api.Test; @RunWith(JUnitPlatform.class) public

    class JupiterTest { @Test void someTest() { // test something } }
  23. JUnitPlatform Runner in suite mode @RunWith(JUnitPlatform.class) @SelectPackages("com.acme") @IncludeEngines({"junit-jupiter", "junit-vintage"}) public

    class JUnit4SuiteDemo { // this class can be run using JUnit 4 }
  24. Test Execution • IDEs: • IntelliJ supports JUnit 5 ≥

    M2 since 2016.2 • Eclipse support is available on a branch (see Instructions).
 Official release slated for Oxygen.1. • Interim solution for other IDEs: JUnitPlatform Runner • Gradle/Maven: Plugin/Provider available • see https://github.com/junit-team/junit5-samples • Manually: ConsoleLauncher
  25. Compatibility • Backward compatibility (junit-vintage-engine) enables gradual migration of tests

    to Jupiter API • Forward compatibility (JUnitPlatform Runner) allows test execution with “old” tools
  26. Extensions

  27. Registration via @ExtendWith • Annotate your test classes or methods

    to register extensions • Supports an arbitrary number of extensions at the same time • May be used as a meta-annotation • Opt-in support for registration via ServiceLoader
  28. DEMO https://github.com/marcphilipp/junit5-demo/tree/20170604-heisenbug

  29. Extension Points • Conditional Test Execution • ContainerExecutionCondition • TestExecutionCondition

    • General Purpose • TestInstancePostProcessor • ParameterResolver • TestTemplateInvocationContext- Provider • Test Lifecycle Callbacks • BeforeAllCallback • BeforeEachCallback • BeforeTestExecutionCallback • TestExecutionExceptionHandler • AfterTestExecutionCallback • AfterEachCallback • AfterAllCallback
  30. Roadmap • 5.0 M4 (April 2017): parameterized and repeated tests

    ✔ • 5.0 M5 (June 2017): dynamic containers and minor API changes • 5.0 M6 (July 2017): Java 9 compatibility, scenario tests, additional extension APIs for JUnit Jupiter • 5.0 RC1 (July 2017): Last fixes before GA • 5.0 GA (August 2017): First general availability release
  31. Summary

  32. What’s in it for me? • Modern programming model •

    Powerful extension points • Gentle migration path • Good tool support • Flexible platform/plugin architecture
  33. Getting Started User Guide:
 http://junit.org/junit5/docs/current/user-guide/ Sample projects for Gradle and

    Maven:
 https://github.com/junit-team/junit5-samples Javadoc:
 http://junit.org/junit5/docs/current/api/
  34. Wanted: Feedback! Website:
 http://junit.org/junit5/ Code & Issues:
 https://github.com/junit-team/junit5/ Twitter:
 https://twitter.com/junitteam