1. A legfontosabb rész:
<code:java>
@Test
</code>
Ez mondja meg a JUnitnak, hogy ez egy tesztmetódus.
Az assertion:
assertEquals(5, result);

azt jelenti:
elvárt érték = 5
tényleges érték = result

2. A legfontosabb assertionök
Ezeket fogod a legtöbbször használni:
<code:java>
assertEquals(expected, actual);
assertNotEquals(expected, actual);

assertTrue(condition);
assertFalse(condition);

assertNull(value);
assertNotNull(value);
</code>
Például:
<code:java>
@Test
void simpleAssertions() {

    assertEquals(4, 2 + 2);

    assertTrue(10 > 5);

    assertFalse(3 > 10);

    String name = "Oliver";
    assertNotNull(name);
}
</code>
Nagyon fontos szokás:
<code:java>
assertEquals(expected, actual);
</code>
tehát először az elvárt, utána a kapott érték.

3. Több teszt ugyanarra az osztályra
Például bővítsük a Calculator osztályt:
<code:java>
public class Calculator {

    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }
}
</code>
A teszt:
<code:java>
class CalculatorTest {

    @Test
    void additionWorks() {
        Calculator calculator = new Calculator();

        assertEquals(5, calculator.add(2, 3));
    }

    @Test
    void subtractionWorks() {
        Calculator calculator = new Calculator();

        assertEquals(7, calculator.subtract(10, 3));
    }

    @Test
    void multiplicationWorks() {
        Calculator calculator = new Calculator();

        assertEquals(20, calculator.multiply(4, 5));
    }
}
</code>
Mavenből:
mvn test

VS Code-ban pedig az egyes @Test metódusok mellett is megjelenhet a Run Test gomb; a Java Test Runner JUnit 5-öt is támogatja. Visual Studio Code

4. @BeforeEach
Gyakran ugyanazt az objektumot kell minden teszthez létrehoznunk.
Ez:
<code:java>
@Test
void additionWorks() {
    Calculator calculator = new Calculator();

    assertEquals(5, calculator.add(2, 3));
}

@Test
void subtractionWorks() {
    Calculator calculator = new Calculator();

    assertEquals(7, calculator.subtract(10, 3));
}
</code>
ismétli ezt:
<code:java>
Calculator calculator = new Calculator();
</code>
Erre való a:
@BeforeEach

Például:
<code:java>
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

class CalculatorTest {

    private Calculator calculator;

    @BeforeEach
    void setUp() {
        calculator = new Calculator();
    }

    @Test
    void additionWorks() {
        assertEquals(5, calculator.add(2, 3));
    }

    @Test
    void subtractionWorks() {
        assertEquals(7, calculator.subtract(10, 3));
    }
}
</code>
A setUp() minden egyes teszt előtt lefut.
Tehát:
@BeforeEach -> @Test #1
@BeforeEach -> @Test #2
@BeforeEach -> @Test #3

Ez nagyon fontos unit testing minta.

5. @BeforeAll és @AfterAll
Van olyan inicializáció, amit csak egyszer akarunk lefuttatni.
<code:java>
@BeforeAll
static void beforeAllTests() {
    System.out.println("Tests starting...");
}
</code>
és a végén:
<code:java>
@AfterAll
static void afterAllTests() {
    System.out.println("Tests finished.");
}
</code>
Teljes példa:
<code:java>
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;

class ExampleTest {

    @BeforeAll
    static void beforeAll() {
        System.out.println("START");
    }

    @Test
    void testOne() {
        System.out.println("testOne");
    }

    @Test
    void testTwo() {
        System.out.println("testTwo");
    }

    @AfterAll
    static void afterAll() {
        System.out.println("END");
    }
}
</code>

6. Kivételek tesztelése: assertThrows
Ez különösen fontos.
Tegyük fel, hogy van osztás:
<code:java>
public int divide(int a, int b) {

    if (b == 0) {
        throw new IllegalArgumentException("Division by zero");
    }

    return a / b;
}
</code>
Azt szeretnénk tesztelni, hogy nullával osztás esetén valóban kivételt kapunk:
<code:java>
@Test
void divisionByZeroThrowsException() {

    Calculator calculator = new Calculator();

    assertThrows(
        IllegalArgumentException.class,
        () -> calculator.divide(10, 0)
    );
}
</code>
Ez nagyon tipikus JUnit 5 kód.
Még jobb:
<code:java>
@Test
void divisionByZeroThrowsException() {

    IllegalArgumentException exception =
        assertThrows(
            IllegalArgumentException.class,
            () -> calculator.divide(10, 0)
        );

    assertEquals(
        "Division by zero",
        exception.getMessage()
    );
}
</code>
Itt már nemcsak azt ellenőrizzük, hogy volt exception, hanem az üzenetét is.

7. assertAll
Több dolgot egyszerre is ellenőrizhetsz:
<code:java>
@Test
void severalAssertions() {

    int result = 10;

    assertAll(
        () -> assertTrue(result > 0),
        () -> assertTrue(result < 100),
        () -> assertEquals(10, result)
    );
}
</code>
Előnye, hogy a JUnit megpróbálja az összes assertiont kiértékelni.

8. @DisplayName
Olvasható nevet adhatsz a tesztnek:
<code:java>
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

class CalculatorTest {

    @Test
    @DisplayName("2 + 3 eredménye 5")
    void additionWorks() {

        Calculator calculator = new Calculator();

        assertEquals(5, calculator.add(2, 3));
    }
}
</code>
A VS Code Testing nézetében így sokkal érthetőbb lehet a teszt.

9. @Disabled
Ideiglenesen kikapcsolhatsz egy tesztet:
<code:java>
import org.junit.jupiter.api.Disabled;

@Test
@Disabled
void unfinishedTest() {
    // még nincs kész
}
</code>
Vagy indoklással:
@Disabled("A funkció még nincs implementálva")

10. Paraméterezett tesztek
Ez a JUnit 5 egyik nagyon hasznos funkciója.
Tegyük fel, hogy ezt akarjuk tesztelni:
calculator.add(...)

Nem akarunk öt külön tesztet írni:
<code:java>
assertEquals(3, calculator.add(1, 2));
assertEquals(7, calculator.add(3, 4));
assertEquals(0, calculator.add(-1, 1));
</code>
Használhatunk @ParameterizedTest-et:
<code:java>
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

import static org.junit.jupiter.api.Assertions.assertEquals;

class CalculatorTest {

    private final Calculator calculator = new Calculator();

    @ParameterizedTest
    @CsvSource({
        "1, 2, 3",
        "3, 4, 7",
        "-1, 1, 0",
        "10, 20, 30"
    })
    void additionWorks(
            int a,
            int b,
            int expected) {

        assertEquals(
            expected,
            calculator.add(a, b)
        );
    }
}
</code>
Ez gyakorlatilag négyszer futtatja ugyanazt a tesztet különböző adatokkal.

11. @ValueSource
Egyszerű paraméterlistához:
<code:java>
@ParameterizedTest
@ValueSource(ints = {1, 2, 3, 10, 100})
void positiveNumbersArePositive(int number) {

    assertTrue(number > 0);
}
</code>
12. Jó teszt felépítése: Arrange – Act – Assert
Ezt érdemes megszokni.
<code:java>
@Test
void additionWorks() {

    // Arrange
    Calculator calculator = new Calculator();

    // Act
    int result = calculator.add(2, 3);

    // Assert
    assertEquals(5, result);
}
</code>
A három rész:
Arrange
↓
előkészítjük a tesztet

Act
↓
meghívjuk a tesztelendő kódot

Assert
↓
ellenőrizzük az eredményt

Ez az egyik legfontosabb unit testing gondolkodásmód.