JUnit 5 - Novidades e mudanças da nova versão

1. JUnit 5

2. JUnit 5
=
JUnit Platform
+
JUnit Jupiter
+
JUnit Vintage

3. ➔ JUnit Platform: É o responsável pela descoberta e execução de testes na
JVM, definindo a relação entre os testes e plataforma de execução (IDEs,
console, ferramentas de build). Esse módulo também expõe a interface
TestEngine, que define o contrato de execução de qualquer ferramenta de
testes sobre a plataforma do JUnit.
➔ JUnit Jupiter: Este módulo contém os novos recursos para construção de
testes usando o JUnit, e fornece uma implementação de TestEngine para
execução dos testes escritos com o JUnit Jupiter.
➔ JUnit Vintage: Fornece um TestEngine para execução de testes escritos em
JUnit 3 e 4.

4. JUnit Jupiter

5. import org.junit.jupiter.api.Test;
import static
org.junit.jupiter.api.Assertions.assertEquals;
public class Sample1 {
@Test
public void myFirstJUnit5Test() {
assertEquals(2, 1 + 1);
}
}

6. public class Sample2 {
@SlowTest
public void testWithMyAnnotation() {
assertEquals(2, verySlowComputation());
}
}
@Test
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface SlowTest {
}

7. import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
public class Sample3 {
@BeforeAll
public static void beforeAll() {
System.out.println("Hello, i'm running 'before all'");
}
@BeforeEach
public void beforeEach() {
System.out.println("Hello, i'm running 'before each'");
}
@Test
public void sample() {
System.out.println("Hello, i'm a test!");
}
}

8. import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.AfterAll;
public class Sample3 {
@Test
public void sample() {
System.out.println("Hello, i'm a test!");
}
@AfterEach
public void afterEach() {
System.out.println("Hello, i'm running 'after each'");
}
@AfterAll
public static void afterAll() {
System.out.println("Hello, i'm running 'after all'");
}
}

9. import org.junit.jupiter.api.TestInstance;
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
//@TestInstance(TestInstance.Lifecycle.PER_METHOD)
public class Sample4 {
@Test
public void sample() {
System.out.println("Hello, i'm a test!, on instance " +
this);
}
@Test
public void sample2() {
System.out.println("Hello, i'm a another test!, on instance "
+ this);
}
}

10. import org.junit.jupiter.api.DisplayName;
public class Sample5 {
@Test
@DisplayName("The sum (1 + 1) must be 2")
public void testWithDisplayName() {
assertEquals(2, 1 + 1);
}
@Test
@DisplayName("The sum (1 + 1) must be 2, with emoji 😃!")
public void testWithDisplayName2() {
assertEquals(2, 1 + 1);
}
}

11. @DisplayName - output

12. Assertions

13. import static org.junit.jupiter.api.Assertions.assertEquals;
public class Sample6 {
@Test
public void sample() {
assertEquals(2, 1 + 1, “The sum (1 + 1) must be 2”);
}
@Test
public void sample2() {
assertEquals(2, 1 + 1, () -> “The sum (1 + 1) must be
2”);
}
}

14. Assertions
assertAll

15. class Person {
String name;
int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
}

16. import static org.junit.jupiter.api.Assertions.assertAll;
public class Sample7 {
@Test
public void sample() {
Person person = new Person("Tiago de Freitas Lima", 20);
assertAll(
() -> assertEquals("Tiago Lima", person.name),
() -> assertEquals(32, person.age));
}
@Test
public void sample2() {
Person person = new Person("Tiago de Freitas Lima", 20);
assertAll("Something is wrong...",
() -> assertEquals("Tiago Lima", person.name),
() -> assertEquals(32, person.age));
}
}

17. Expected :Tiago Lima
Actual :Tiago de Freitas Lima
Expected :32
Actual :20
org.opentest4j.MultipleFailuresError:
Multiple Failures (2 failures)
expected: <Tiago Lima> but was: <Tiago de
Freitas Lima>
expected: <32> but was: <20>

18. Assertions
exceptions

19. class MyObject {
void dangerous(String arg) {
throw new
IllegalArgumentException("Invalid argument:
" + arg);
}
void safe() {
}
}

20. import static org.junit.jupiter.api.Assertions.assertThrows;
public class Sample8 {
@Test
public void sample() {
MyObject myObject = new MyObject();
assertThrows(IllegalArgumentException.class, () ->
myObject.dangerous("bla"));
}
@Test
public void sample2() {
MyObject myObject = new MyObject();
assertThrows(IllegalStateException.class, () ->
myObject.dangerous("bla"));
}
}

21. import static org.junit.jupiter.api.Assertions.assertThrows;
public class Sample8 {
@Test
public void sample3() {
MyObject myObject = new MyObject();
assertThrows(IllegalStateException.class, myObject::safe);
}
@Test
public void sample4() {
MyObject myObject = new MyObject();
IllegalArgumentException exception =
assertThrows(IllegalArgumentException.class,
() -> myObject.dangerous("bla"));
assertEquals("Invalid argument: bla", exception.getMessage());
}
}

22. Assertions
timeouts

23. class MyObject {
String slow() {
//...very slow…
return “”;
}
}

24. import static org.junit.jupiter.api.Assertions.assertTimeout;
public class Sample9 {
@Test
public void sample() {
MyObject myObject = new MyObject();
assertTimeout(Duration.ofMillis(2000), myObject::slow);
}
@Test
public void sample2() {
MyObject myObject = new MyObject();
String output = assertTimeout(Duration.ofMillis(2000), myObject::slow);
assertEquals("slow...", output);
}
}

25. import static
org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;
public class Sample9 {
@Test
public void sample3() {
MyObject myObject = new MyObject();
assertTimeoutPreemptively(Duration.ofMillis(2000),
myObject::slow);
}
}

26. Parameterized Tests

27. <dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-params</artifactId>
<version>5.0.0</version>
<scope>test</scope>
</dependency>

28. import org.junit.jupiter.params.ParameterizedTest;
import
org.junit.jupiter.params.provider.ValueSource;
public class Sample10 {
@ParameterizedTest
@ValueSource(strings = { "Hello", "World" })
public void parameterizedTest(String argument) {
assertNotNull(argument);
}
}

29. import
org.junit.jupiter.params.ParameterizedTest;
import
org.junit.jupiter.params.provider.EnumSource;
public class Sample11 {
@ParameterizedTest
@EnumSource(TimeUnit.class)
public void parameterizedTest(TimeUnit
timeUnit) {
assertNotNull(timeUnit);
}
}

30. import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
public class Sample12 {
@ParameterizedTest
@MethodSource("parameterFactory")
public void parameterizedTest(String argument) {
assertNotNull(argument);
}
static Collection<String> parameterFactory() {
return Arrays.asList("Hello", "World");
}
}

31. import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
public class Sample13 {
@ParameterizedTest
@MethodSource("parameterFactory")
public void parameterizedTest(String argument, int count) {
assertNotNull(argument);
assertTrue(count > 0);
}
static Collection<Arguments> parameterFactory() {
return Arrays.asList(Arguments.of("Hello", 1),
Arguments.of("World", 1));
}
}

32. import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
public class Sample14 {
@ParameterizedTest
@CsvSource({ "Hello, 1", "World, 2"})
public void parameterizedTest(String argument,
int count) {
assertNotNull(argument);
assertTrue(count > 0);
}
}

33. import org.junit.jupiter.params.ParameterizedTest;
import
org.junit.jupiter.params.provider.CsvFileSource;
public class Sample15 {
@ParameterizedTest
@CsvFileSource(resources = "/parameters.csv")
public void parameterizedTest(String argument,
int count) {
assertNotNull(argument);
assertTrue(count > 0);
}
}

34. Parameterized Tests
custom argument
provider

35. import org.junit.jupiter.params.ParameterizedTest;
import
org.junit.jupiter.params.provider.ArgumentsSource;
public class Sample16 {
@ParameterizedTest
@ArgumentsSource(CustomArgumentProvider.class)
public void parameterizedTest(String argument, int
count) {
assertNotNull(argument);
assertTrue(count > 0);
}
}

36. import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.ArgumentsProvider;
class CustomArgumentProvider implements ArgumentsProvider {
@Override
public Stream<? extends Arguments>
provideArguments(ExtensionContext context) throws Exception {
return Stream.of(Arguments.of("Hello", 1),
Arguments.of("World", 1));
}
}

37. import org.junit.jupiter.params.ParameterizedTest;
public class Sample17 {
@ParameterizedTest
@ExcelSource(file = "test.xls")
public void parameterizedTest(String argument) {
assertNotNull(argument);
}
}

38. import org.junit.jupiter.params.provider.ArgumentsSource;
@ArgumentsSource(ExcelArgumentProvider.class)
@interface ExcelSource {
String file();
}

39. import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.ArgumentsProvider;
import org.junit.jupiter.params.support.AnnotationConsumer;
class ExcelArgumentProvider implements ArgumentsProvider,
AnnotationConsumer<ExcelSource> {
private String fileName;
@Override
public void accept(ExcelSource excelSource) {
this.fileName = excelSource.file();
}
@Override
public Stream<? extends Arguments> provideArguments(ExtensionContext
context) throws Exception {
return Stream.empty();
}
}

40. Nested Tests

41. public class Sample18 {
private Stack<String> stack;
@Test
@DisplayName("is instantiated with new Stack()")
void isInstantiatedWithNew() {
new Stack<>();
}
@Nested
@DisplayName("when new")
class WhenNew {
@BeforeEach
void createNewStack() {
stack = new Stack<>();
}
...

42. @Test
@DisplayName("is empty")
void isEmpty() {
assertTrue(stack.isEmpty());
}
@Test
@DisplayName("throws EmptyStackException when popped")
void throwsExceptionWhenPopped() {
assertThrows(EmptyStackException.class, () -> stack.pop());
}
@Nested
@DisplayName("after pushing an element")
class AfterPushing {
String anElement = "an element";
@BeforeEach
void pushAnElement() {
stack.push(anElement);
}
...

43. ...
@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());
}
}
}
}

44. Nested tests - output

45. Test interfaces

46. public interface Testable<T> {
T createValue();
}

47. public interface EqualsContract<T> extends Testable<T> {
T createNotEqualValue();
@Test
default void valueEqualsItself() {
T value = createValue();
assertEquals(value, value);
}
@Test
default void valueDoesNotEqualNull() {
T value = createValue();
assertFalse(value.equals(null));
}
@Test
default void valueDoesNotEqualDifferentValue() {
T value = createValue();
T differentValue = createNotEqualValue();
assertNotEquals(value, differentValue);
assertNotEquals(differentValue, value);
}
}

48. public class Sample20 implements EqualsContract<String> {
@Override
public String createValue() {
return "Hello";
}
@Override
public String createNotEqualValue() {
return "World";
}
}

49. Tags

50. import org.junit.jupiter.api.Tag;
public class Sample21 {
@Test
@Tag("slow")
@Tag("whatever")
public void sample() {
assertNotNull("...");
}
}

51. O que mais?
https://engenharia.elo7.com.br/novidades-do-junit-5-parte-1/
https://engenharia.elo7.com.br/novidades-do-junit-5-parte-2/

52. Obrigado!
github.com/ljtfreitas/junit-5-samples