Junit 5 - Maior e melhor

JUnit 5
=
JUnit Platform
+
JUnit Jupiter
+
JUnit Vintage

➔ 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.

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);
}
}

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

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
@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!");
}
}

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.AfterAll;
@Test
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'");
}
}

import org.junit.jupiter.api.TestInstance;
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
//@TestInstance(TestInstance.Lifecycle.PER_METHOD)
@Test
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);
}
}

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

import static org.junit.jupiter.api.Assertions.assertEquals;
@Test
assertEquals(2, 1 + 1, “The sum (1 + 1) must be 2”);
}
@Test
assertEquals(2, 1 + 1, () -> “The sum (1 + 1) must be
2”);
}
}

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

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

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>

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

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

import static org.junit.jupiter.api.Assertions.assertThrows;
@Test
assertThrows(IllegalStateException.class, myObject::safe);
}
@Test
IllegalArgumentException exception =
assertThrows(IllegalArgumentException.class,
() -> myObject.dangerous("bla"));
assertEquals("Invalid argument: bla", exception.getMessage());
}
}

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

import static org.junit.jupiter.api.Assertions.assertTimeout;
@Test
assertTimeout(Duration.ofMillis(2000), myObject::slow);
}
@Test
String output = assertTimeout(Duration.ofMillis(2000), myObject::slow);
assertEquals("slow...", output);
}
}

import static
org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;
@Test
assertTimeoutPreemptively(Duration.ofMillis(2000),
myObject::slow);
}
}

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

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

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

import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
@ParameterizedTest
@MethodSource("parameterFactory")
}
static Collection<String> parameterFactory() {
return Arrays.asList("Hello", "World");
}
}

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

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

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

Parameterized Tests
custom argument
provider

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

import org.junit.jupiter.api.extension.ExtensionContext;
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));
}
}

@ParameterizedTest
@ExcelSource(file = "test.xls")
}
}

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

import org.junit.jupiter.api.extension.ExtensionContext;
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();
}
}

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

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

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

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

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

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

import org.junit.jupiter.api.Tag;
@Test
@Tag("slow")
@Tag("whatever")
assertNotNull("...");
}
}

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/

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

Junit 5 - Maior e melhor

More Related Content

What's hot

Similar to Junit 5 - Maior e melhor

Recently uploaded

Junit 5 - Maior e melhor

Editor's Notes