JUnit 5
a new Major Release

Historie

Sommer 2015

    Start "JUnit Lambda"

    Integration Java 8 Features

Crowdfunding campaign

    leads to JUnit 5

Systemarchitektur

Empty Test (JUnit 5 Style)

package de.mike.tests;

import org.junit.jupiter.api.Test;

public class NameDerTestKlasse {

   @Test
   public void irgendeinBeliebigerMethodenname() {
   }

}

Unterschiede

package de.mike.tests;

import org.junit.jupiter.api.Test;

class NameDerTestKlasse {

   @Test
   void irgendeinBeliebigerMethodenname() {
   }

}

Meta Annotations

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.junit.jupiter.api.Tag;

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Tag("integration")
public @interface IntegrationTest {
}

Displayname

@DisplayName("Dies ist ein Spezialtestfall")
class DisplayNameDemo {

   @Test
   @DisplayName("Mein Name mit Leerzeichen 😱")
   void testWhatever() {
      ...
   }
}

Timeouts

Als harter Abbruch...

... oder weiche Prüfung

Assertions mit Supplier

(Un-) abhängige Assertions

@Test
void testMyPerson() {

   assertAll("Failure", 
      () -> {
            assertThat(...); /* If this fails, */
            assertThat(...); /* this will not be checked */
            },
      () -> assertNotNull(...); /* but this anyway */
   }

}

Assumptions

import static org.junit.jupiter.api.Assumptions.assumeTrue;

@Test
void testOnlyOnITestServer() {
    assumeTrue("ITest".equals(System.getenv("Staging")));
    ...
}

@Test
void testOnlyOnCTestServer() {
    assumeTrue("CTest".equals(System.getenv("Staging")),
        () -> "Aborting test: not on CTest server");
     ...
}

assume that...

import static org.junit.jupiter.api.Assumptions.assumeTrue;
import static org.junit.jupiter.api.Assumptions.assumeThat;

@Test
void testInAllEnvironments() {
    assumingThat("CTest".equals(System.getenv("Staging")),
        () -> {
            // perform these assertions only on CTest server
            assertThat(...);
        });

    // perform these assertions in all environments
    assertThat(...);
}

Test Lifecycle

@TestInstance(Lifecycle.PER_CLASS)
public class TestLifecycleDemo {

   private int index = 0;

   @Test
   public void test1() throws Exception {
      index++;
      System.out.println("Ich bin Objekt " + index + " mit ID <" + this + ">");
   }

   ...
}

Standardmäßig ist der Lifecycle wie bei älteren JUnit-Versionen:

Pro Testmethode wird eine neue Instanz der Testklasse erzeugt.

Dies kann nun durch @TestInstance(Lifecycle.PER_CLASS) geändert werden.

Nested Tests

@DisplayName("A stack")
class TestingAStackDemo {

    Stack<Object> stack;

    @Test
    @DisplayName("is instantiated with new Stack()")
    void isInstantiatedWithNew() {
        new Stack<>();
    }

    @Nested
    @DisplayName("when new")
    class WhenNew {

        @BeforeEach
        void createNewStack() {
            stack = new Stack<>();
        }

        @Test
        @DisplayName("is empty")
        void isEmpty() {
            assertTrue(stack.isEmpty());
        }

        @Test
        @DisplayName("throws EmptyStackException when popped")
        void throwsExceptionWhenPopped() {
            assertThrows(EmptyStackException.class, () -> stack.pop());
        }

        @Test
        @DisplayName("throws EmptyStackException when peeked")
        void throwsExceptionWhenPeeked() {
            assertThrows(EmptyStackException.class, () -> stack.peek());
        }

        @Nested
        @DisplayName("after pushing an element")
        class AfterPushing {

            String anElement = "an element";

            @BeforeEach
            void pushAnElement() {
                stack.push(anElement);
            }

            @Test
            @DisplayName("it is no longer empty")
            void isNotEmpty() {
                assertFalse(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when popped and is empty")
            void returnElementWhenPopped() {
                assertEquals(anElement, stack.pop());
                assertTrue(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when peeked but remains not empty")
            void returnElementWhenPeeked() {
                assertEquals(anElement, stack.peek());
                assertFalse(stack.isEmpty());
            }
        }
    }
}

Tests können nun in Tests integriert werden;
natürlich als innere Klassen.

Parameter Resolver

Die Klasse

org.junit.jupiter.api.extension.ParameterResolver 

ist eine dynamische Schnittstelle, um Tests via Konstruktor oder Methoden, Parameter zu injizieren.

Repeated Tests

Tests können mit Wiederholungsangabe definiert werden.

Unterschiedliche Quellen

• ValueSource
• EnumSource
• MethodSource
  (Return: Stream, Iterator, Iterable, array of elements)
• CsvSource
• CsvFileSource
• @ArgumentsSource
  (durch ArgumentProvider)

Konvertierung der Argumente

• Implizite Konvertierung für Standarddatentypen
• Explizite Konvertierung (@ConvertWith(...))