JUnit 5-Tutorial:Schreiben von Assertionen mit der JUnit 5-Assertion-API

Dieser Blogbeitrag beschreibt, wie wir Assertionen schreiben können, indem wir die JUnit 5-Assertion-API verwenden. Nachdem wir diesen Blogbeitrag fertiggestellt haben, werden wir:

• Kann grundlegende Behauptungen mit JUnit 5 schreiben.
• Wissen, wie wir die Fehlermeldung anpassen können, die angezeigt wird, wenn eine Assertion fehlschlägt.
• Verstehen, wie wir mehrere Behauptungen als Behauptungsgruppe ausführen können.

Fangen wir an.

Schreiben von Behauptungen mit JUnit 5

Wenn wir Behauptungen schreiben wollen, indem wir die „Standard“-API von JUnit 5 verwenden, müssen wir den org.junit.jupiter.api.Assertions verwenden Klasse. Es bietet static Factory-Methoden, mit denen wir sicherstellen können, dass die angegebene Bedingung erfüllt ist, nachdem das zu testende System ausgeführt wurde.

Bevor wir uns diese Methoden genauer ansehen, müssen wir einige Grundregeln kennen:

• Wenn wir eine benutzerdefinierte Fehlermeldung angeben möchten, die angezeigt wird, wenn unsere Behauptung fehlschlägt, müssen wir diese Nachricht als letzten Methodenparameter der aufgerufenen Behauptungsmethode übergeben.
• Wenn wir zwei Werte (oder Objekte) vergleichen wollen, müssen wir diese Werte (oder Objekte) in dieser Reihenfolge an die aufgerufene Assertion-Methode übergeben:den erwarteten Wert (oder Objekt) und den tatsächlichen Wert (oder Objekt).

Als nächstes werden wir herausfinden, wie wir Assertionen mit der Assertions schreiben können Klasse. Beginnen wir damit herauszufinden, wie wir Zusicherungen für boolean schreiben können Werte.

Boolesche Werte bestätigen

Wenn wir überprüfen möchten, ob ein boolean Wert ist true , müssen wir den assertTrue() verwenden Methode des Assertions Klasse. Mit anderen Worten, wir müssen diese Behauptung verwenden:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

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

@DisplayName("Write assertions for booleans")
class BooleanAssertionTest {

    @Nested
    @DisplayName("When boolean is true")
    class WhenBooleanIsTrue {

        @Test
        @DisplayName("Should be true")
        void shouldBeTrue() {
            assertTrue(true);
        }
    }
}

Wenn wir überprüfen wollen, ob ein boolean Wert ist false , müssen wir den assertFalse() verwenden Methode des Assertions Klasse. Mit anderen Worten, wir müssen diese Behauptung verwenden:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

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

@DisplayName("Write assertions for booleans")
class BooleanAssertionTest {

    @Nested
    @DisplayName("When boolean is false")
    class WhenBooleanIsFalse {

        @Test
        @DisplayName("Should be false")
        void shouldBeFalse() {
            assertFalse(false);
        }
    }
}

Als nächstes werden wir herausfinden, wie wir überprüfen können, ob ein Objekt null ist oder ist nicht null .

Behaupten, dass ein Objekt Null ist oder nicht Null ist

Wenn wir überprüfen möchten, ob ein Objekt null ist , müssen wir den assertNull() verwenden Methode des Assertions Klasse. Mit anderen Worten, wir müssen diese Behauptung verwenden:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

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

@DisplayName("Writing assertions for objects")
class ObjectAssertionTest {

    @Nested
    @DisplayName("When object is null")
    class WhenObjectIsNull {

        @Test
        @DisplayName("Should be null")
        void shouldBeNull() {
            assertNull(null);
        }
    }
}

Wenn wir überprüfen möchten, ob ein Objekt nicht null ist , müssen wir den assertNotNull() verwenden Methode des Assertions Klasse. Mit anderen Worten, wir müssen diese Behauptung verwenden:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

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

@DisplayName("Writing assertions for objects")
class ObjectAssertionTest {

    @Nested
    @DisplayName("When object is not null")
    class WhenObjectIsNotNotNull {

        @Test
        @DisplayName("Should not be null")
        void shouldNotBeNull() {
            assertNotNull(new Object());
        }
    }
}

Lassen Sie uns weitermachen und herausfinden, wie wir überprüfen können, ob zwei Objekte (oder Werte) gleich oder ungleich sind.

Behaupten, dass zwei Objekte oder Werte gleich sind

Wenn wir überprüfen wollen, ob der erwartete Wert (oder Objekt) gleich dem tatsächlichen Wert (oder Objekt) ist, müssen wir den assertEquals() verwenden Methode des Assertions Klasse. Zum Beispiel, wenn wir zwei Integer vergleichen möchten Objekten müssen wir diese Behauptung verwenden:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

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

@DisplayName("Writing assertions for objects")
class ObjectAssertionTest {

    @Nested
    @DisplayName("When two objects are equal")
    class WhenTwoObjectsAreEqual {

        @Nested
        @DisplayName("When objects are integers")
        class WhenObjectsAreIntegers {

            private final Integer ACTUAL = 9;
            private final Integer EXPECTED = 9;

            @Test
            @DisplayName("Should be equal")
            void shouldBeEqual() {
                assertEquals(EXPECTED, ACTUAL);
            }
        }
    }
}

Wenn wir überprüfen wollen, ob der erwartete Wert (oder Objekt) nicht gleich dem tatsächlichen Wert (oder Objekt) ist, müssen wir den assertNotEquals() verwenden Methode des Assertions Klasse. Zum Beispiel, wenn wir zwei Integer vergleichen möchten Objekten müssen wir diese Behauptung verwenden:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

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

@DisplayName("Writing assertions for objects")
class ObjectAssertionTest {

    @Nested
    @DisplayName("When two objects aren't equal")
    class WhenTwoObjectsAreNotEqual {

        @Nested
        @DisplayName("When objects are integers")
        class WhenObjectsAreIntegers {

            private final Integer ACTUAL = 9;
            private final Integer EXPECTED = 4;

            @Test
            @DisplayName("Should not be equal")
            void shouldNotBeEqual() {
                assertNotEquals(EXPECTED, ACTUAL);
            }
        }
    }
}

Als nächstes werden wir herausfinden, wie wir Zusicherungen für Objektreferenzen schreiben können.

Bestätigen von Objektreferenzen

Wenn wir sicherstellen wollen, dass zwei Objekte auf dasselbe Objekt verweisen, müssen wir den assertSame() verwenden Methode des Assertions Klasse. Mit anderen Worten, wir müssen diese Behauptung verwenden:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

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

@DisplayName("Writing assertions for objects")
class ObjectAssertionTest {

    @Nested
    @DisplayName("When two objects refer to the same object")
    class WhenTwoObjectsReferToSameObject {

        private final Object ACTUAL = new Object();
        private final Object EXPECTED = ACTUAL;

        @Test
        @DisplayName("Should refer to the same object")
        void shouldReferToSameObject() {
            assertSame(EXPECTED, ACTUAL);
        }
    }
}

Wenn wir sicherstellen wollen, dass zwei Objekte nicht auf dasselbe Objekt verweisen, müssen wir den assertNotSame() verwenden Methode des Assertions Klasse. Mit anderen Worten, wir müssen diese Behauptung verwenden:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

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

@DisplayName("Writing assertions for objects")
class ObjectAssertionTest {

    @Nested
    @DisplayName("When two objects don't refer to the same object")
    class WhenTwoObjectsDoNotReferToSameObject {

        private final Object ACTUAL = new Object();
        private final Object EXPECTED = new Object();

        @Test
        @DisplayName("Should not refer to the same object")
        void shouldNotReferToSameObject() {
            assertNotSame(EXPECTED, ACTUAL);
        }
    }
}

Lassen Sie uns weitermachen und herausfinden, wie wir überprüfen können, ob zwei Arrays gleich sind.

Behauptung, dass zwei Arrays gleich sind

Wenn wir überprüfen wollen, ob zwei Arrays gleich sind, müssen wir den assertArrayEquals() verwenden Methode des Assertions Klasse. Zum Beispiel, wenn wir überprüfen wollen, ob zwei int Arrays gleich sind, müssen wir diese Behauptung verwenden:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

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

@DisplayName("Write assertions for arrays")
class ArrayAssertionTest {

    @Nested
    @DisplayName("When arrays contain integers")
    class WhenArraysContainIntegers {

        final int[] ACTUAL = new int[]{2, 5, 7};
        final int[] EXPECTED = new int[]{2, 5, 7};

        @Test
        @DisplayName("Should contain the same integers")
        void shouldContainSameIntegers() {
            assertArrayEquals(EXPECTED, ACTUAL);
        }
    }
}

Als nächstes werden wir herausfinden, wie wen überprüfen kann, ob zwei Iterables gleich sind.

Behauptung, dass zwei Iterables gleich sind

Wenn wir überprüfen wollen, ob zwei Iterables absolut gleich sind, müssen wir den assertIterableEquals() verwenden Methode des Assertions Klasse. Zum Beispiel, wenn wir überprüfen wollen, ob zwei Integer Listen zutiefst gleich sind, müssen wir diese Behauptung verwenden:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.List;

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

@DisplayName("Writing assertions for lists")
class ListAssertionTest {

    @Nested
    @DisplayName("When we compare two lists")
    class WhenWeCompareTwoLists {

        private final List<Integer> FIRST = Arrays.asList(1, 2, 3);
        private final List<Integer> SECOND = Arrays.asList(1, 2, 3);

        @Test
        @DisplayName("Should contain the same elements")
        void shouldContainSameElements() {
            assertIterableEquals(FIRST, SECOND);
        }
    }
}

Lassen Sie uns weitermachen und herausfinden, wie wir Zusicherungen für die vom zu testenden System ausgelöste Ausnahme schreiben können.

Zusicherungen für Ausnahmen schreiben

Wenn wir Zusicherungen für die vom zu testenden System ausgelösten Ausnahmen schreiben wollen, müssen wir den assertThrows() verwenden Methode des Assertions Klasse. Diese Methode akzeptiert die folgenden Methodenparameter:

• A Class Objekt, das den Typ der erwarteten Ausnahme angibt.
• Ein Executable Objekt, das das zu testende System aufruft.
• Eine optionale Fehlermeldung.

Wenn wir beispielsweise überprüfen möchten, ob das zu testende System einen NullPointerException auslöst , sieht unsere Assertion wie folgt aus:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

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

@DisplayName("Writing assertions for exceptions")
class ExceptionAssertionTest {

    @Test
    @DisplayName("Should throw the correct exception")
    void shouldThrowCorrectException() {
        assertThrows(
                NullPointerException.class,
                () -> { throw new NullPointerException(); }
        );
    }
}

Denn der assertThrows() -Methode das ausgelöste Ausnahmeobjekt zurückgibt, können wir auch zusätzliche Assertionen für die ausgelöste Ausnahme schreiben. Wenn wir beispielsweise überprüfen möchten, ob die ausgelöste Ausnahme die richtige Nachricht enthält, können wir die folgenden Zusicherungen verwenden:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

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

@DisplayName("Writing assertions for exceptions")
class ExceptionAssertionTest {

    @Test
    @DisplayName("Should throw an exception that has the correct message")
    void shouldThrowAnExceptionWithCorrectMessage() {
        final NullPointerException thrown = assertThrows(
                NullPointerException.class,
                () -> { throw new NullPointerException("Hello World!"); }
        );
        assertEquals("Hello World!", thrown.getMessage());
    }
}

Auf der anderen Seite möchten wir, obwohl eine Testmethode fehlschlägt, wenn das zu testende System eine Ausnahme auslöst, manchmal ausdrücklich behaupten, dass der getestete Code keine Ausnahme auslöst. In diesem Fall müssen wir den assertDoesNotThrow() verwenden Methode des Assertions Klasse. Wenn wir überprüfen möchten, dass das zu testende System keine Ausnahme auslöst, können wir eine dieser beiden Optionen verwenden:

Zuerst , wenn wir keine Zusicherungen für den vom zu testenden System zurückgegebenen Wert schreiben wollen, müssen wir die folgenden Methodenparameter an assertDoesNotThrow() übergeben Methode:

• Ein Executable Objekt, das das zu testende System aufruft.
• Eine optionale Fehlermeldung.

Wenn wir beispielsweise überprüfen möchten, ob das zu testende System keine Ausnahme auslöst, sieht unsere Assertion wie folgt aus:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

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

@DisplayName("Writing assertions for exceptions")
class ExceptionAssertionTest {

    @Test
    @DisplayName("Should not throw an exception")
    void shouldNotThrowException() {
        assertDoesNotThrow(() -> {});
    }
}

Zweiter , wenn wir Zusicherungen für den vom zu testenden System zurückgegebenen Wert schreiben wollen, müssen wir die folgenden Methodenparameter an assertDoesNotThrow() übergeben Methode:

• A ThrowingSupplier Objekt, das das zu testende System aufruft (und den Rückgabewert zurückgibt).
• Eine optionale Fehlermeldung.

Wenn wir beispielsweise überprüfen möchten, ob das zu testende System keine Ausnahme auslöst UND wir überprüfen möchten, ob das zu testende System die richtige Nachricht zurückgibt, sieht unsere Assertion wie folgt aus:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

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

@DisplayName("Writing assertions for exceptions")
class ExceptionAssertionTest {

    @Test
    @DisplayName("Should not throw an exception")
    void shouldNotThrowException() {
        String message = assertDoesNotThrow(() -> { return "Hello World!"; } );
        assertEquals("Hello World!", message);
    }
}

Als nächstes werden wir herausfinden, wie wir Zusicherungen für die Ausführungszeit des zu testenden Systems schreiben können.

Schreiben von Zusicherungen für die Ausführungszeit des zu testenden Systems

Wenn wir sicherstellen möchten, dass die Ausführung des zu testenden Systems abgeschlossen ist, bevor das angegebene Timeout überschritten wird, können wir den assertTimeout() verwenden und assertTimeoutPreemptively() Methoden des Assertions Klasse. Beide Methoden nehmen die folgenden Methodenparameter:

• A Duration Objekt, das die Zeitüberschreitung angibt.
• Ein Executable oder ein ThrowingSupplier Objekt, das das zu testende System aufruft.
• Eine optionale Fehlermeldung, die angezeigt wird, wenn das angegebene Timeout überschritten wird.

Obwohl diese beiden Methoden ziemlich ähnlich sind, haben sie einen entscheidenden Unterschied. Dieser Unterschied wird im Folgenden erläutert:

• Wenn wir den assertTimeout() verwenden Methode, der bereitgestellte Executable oder ThrowingSupplier wird im selben Thread ausgeführt wie der Code, der sie aufruft. Außerdem bricht diese Methode die Ausführung nicht ab, wenn das Timeout überschritten wird.
• Wenn wir den assertTimeoutPreemptively() verwenden Methode, der bereitgestellte Executable oder ThrowingSupplier wird in einem anderen Thread ausgeführt als der Code, der sie aufruft. Außerdem bricht diese Methode die Ausführung ab, wenn das Timeout überschritten wird.

Wie wir sehen, können wir überprüfen, ob die Ausführung des zu testenden Systems abgeschlossen ist, bevor das angegebene Timeout überschritten wird, indem wir eine dieser beiden Optionen verwenden:

Zuerst , wenn wir wollen, dass die Ausführung nicht abgebrochen wird, wenn das Timeout überschritten wird, müssen wir den assertTimeout() verwenden Methode des Assertions Klasse. Wenn wir beispielsweise überprüfen möchten, ob das zu testende System die Nachricht zurückgibt:„Hallo Welt!“ bevor das angegebene Timeout (50ms) überschritten wird, müssen wir Zusicherungen schreiben, die wie folgt aussehen:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.time.Duration;

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

@DisplayName("Writing assertions for the execution time of the system under test")
class TimeoutAssertionTest {

    @Test
    @DisplayName("Should return the correct message before timeout is exceeded")
    void shouldReturnCorrectMessageBeforeTimeoutIsExceeded() {
        final String message = assertTimeout(Duration.ofMillis(50), () -> {
            Thread.sleep(20);
            return "Hello World!";
        });
        assertEquals("Hello World!", message);
    }
}

Zweiter , wenn wir wollen, dass die Ausführung abgebrochen wird, wenn das Timeout überschritten wird, müssen wir den assertTimeoutPreemptively() verwenden Methode des Assertions Klasse. Wenn wir beispielsweise überprüfen möchten, ob das zu testende System die Nachricht zurückgibt:„Hallo Welt!“ bevor das angegebene Timeout (50ms) überschritten wird, müssen wir Zusicherungen schreiben, die wie folgt aussehen:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.time.Duration;

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

@DisplayName("Writing assertions for the execution time of the system under test")
class TimeoutAssertionTest {

    @Test
    @DisplayName("Should return the correct message before timeout is exceeded")
    void shouldReturnCorrectMessageBeforeTimeoutIsExceeded() {
        final String message = assertTimeoutPreemptively(Duration.ofMillis(50), () -> {
            Thread.sleep(20);
            return "Hello World!";
        });
        assertEquals("Hello World!", message);
    }
}

Wir können jetzt grundlegende Zusicherungen mit JUnit 5 schreiben. Lassen Sie uns weitermachen und herausfinden, wie wir die Fehlermeldungen anpassen können, die von JUnit 5 angezeigt werden, wenn eine Zusicherung fehlschlägt.

Eine benutzerdefinierte Fehlermeldung bereitstellen

Wie wir uns erinnern, müssen wir, wenn wir eine benutzerdefinierte Fehlermeldung angeben möchten, die angezeigt wird, wenn unsere Behauptung fehlschlägt, diese Nachricht als letzten Methodenparameter der aufgerufenen Behauptungsmethode übergeben. Wir können diese Nachricht erstellen, indem wir eine dieser beiden Optionen verwenden:

Zuerst , können wir einen neuen String erstellen Objekt und übergeben Sie dieses Objekt als letzten Methodenparameter der aufgerufenen Assertion-Assertion-Methode. Dies ist eine gute Wahl, wenn unsere Fehlermeldung keine Parameter hat. Wenn wir beispielsweise eine benutzerdefinierte Fehlermeldung für eine Assertion bereitstellen möchten, die bestätigt, dass ein boolean Wert ist false , müssen wir eine Assertion schreiben, die wie folgt aussieht:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

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

@DisplayName("Write assertions for booleans")
class BooleanAssertionTest {

    @Nested
    @DisplayName("When boolean is false")
    class WhenBooleanIsFalse {

        @Test
        @DisplayName("Should be false")
        void shouldBeFalse() {
            assertFalse(false, "The boolean is not false");
        }
    }
}

Zweiter , können wir einen Nachrichtenanbieter erstellen (Supplier ) und übergeben Sie diesen Lieferanten als letzten Methodenparameter der aufgerufenen Zusicherungsmethode. Wenn wir diesen Ansatz verwenden, erstellt JUnit 5 nur die eigentlichen Fehlermeldungen wenn unsere Behauptung fehlschlägt. Deshalb ist dies eine gute Wahl, wenn wir eine "komplexe" Fehlermeldung mit Parametern erstellen möchten.

Wenn wir beispielsweise eine benutzerdefinierte Fehlermeldung für eine Assertion bereitstellen möchten, die bestätigt, dass eine Map den angegebenen Schlüssel enthält, müssen wir eine Assertion schreiben, die wie folgt aussieht:

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.util.HashMap;
import java.util.Map;

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

@DisplayName("Writing assertions for maps")
class MapAssertionTest {

    private static final String KEY = "key";
    private static final String VALUE = "value";

    private Map<String, String> map;

    @BeforeEach
    void createAndInitializeMap() {
        map = new HashMap<>();
        map.put(KEY, VALUE);
    }

    @Test
    @DisplayName("Should contain the correct key")
    void shouldContainCorrectKey() {
        assertTrue(
                map.containsKey(KEY), 
                () -> String.format("The map doesn't contain the key: %s", KEY)
        );
    }
}

Als nächstes werden wir herausfinden, wie wir Behauptungen mit JUnit 5 gruppieren können.

Assertions gruppieren

Wenn wir eine Zusicherung für einen Zustand schreiben müssen, der mehrere Zusicherungen erfordert, können wir unsere Zusicherungen gruppieren, indem wir den assertAll() verwenden Methode des Assertions Klasse. Diese Methode akzeptiert die folgenden Methodenparameter:

• Eine optionale Überschrift, die den bestätigten Zustand identifiziert.
• Ein Array, ein Collection , oder ein Stream von Executable Objekte, die unsere Behauptungen aufrufen.

Wenn wir den assertAll() aufrufen -Methode, ruft sie alle angegebenen Zusicherungen auf und meldet alle Zusicherungsfehler, nachdem alle Zusicherungen ausgeführt wurden.

Nehmen wir an, wir müssen eine Assertion schreiben, die verifiziert, dass ein Person Objekt hat den richtigen Namen. Der Quellcode von Person Klasse sieht wie folgt aus:

public class Person {

    private String firstName;
    private String lastName;

    public Person() {}

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

Wie wir sehen können, müssen wir, wenn wir überprüfen wollen, ob eine Person den richtigen Namen hat, überprüfen, ob der geltend gemachte Person Objekt hat den richtigen Vor- und Nachnamen. Mit anderen Worten, wir müssen eine Assertion schreiben, die wie folgt aussieht:

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

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

@DisplayName("Group multiple assertions")
class GroupAssertionsTest {

    private static final String FIRST_NAME = "Jane";
    private static final String LAST_NAME = "Doe";

    private Person person;

    @BeforeEach
    void createPerson() {
        person = new Person();
        person.setFirstName(FIRST_NAME);
        person.setLastName(LAST_NAME);
    }

    @Test
    @DisplayName("Should have the correct name")
    void shouldHaveCorrectName() {
        assertAll("name",
                () -> assertEquals(FIRST_NAME, 
                        person.getFirstName(), 
                        "The first name is incorrect"
                ),
                () -> assertEquals(LAST_NAME, 
                        person.getLastName(), 
                        "The last name is incorrect"
                )
        );
    }
}

Wir können jetzt grundlegende Zusicherungen mit JUnit 5 schreiben, eine benutzerdefinierte Fehlermeldung bereitstellen, die angezeigt wird, wenn eine Zusicherung fehlschlägt, und Zusicherungen mit JUnit 5 gruppieren.

Fassen wir zusammen, was wir aus diesem Blogbeitrag gelernt haben.

Zusammenfassung

Dieser Blogbeitrag hat uns vier Dinge gelehrt:

• Wenn wir Zusicherungen schreiben wollen, indem wir die „Standard“-API von JUnit 5 verwenden, müssen wir den org.junit.jupiter.api.Assertions verwenden Klasse.
• Wenn wir eine benutzerdefinierte Fehlermeldung ohne Parameter angeben möchten, müssen wir einen neuen String erstellen Objekt und übergeben Sie dieses Objekt als letzten Methodenparameter der aufgerufenen Assertion-Methode.
• Wenn wir eine "komplexe" Fehlermeldung mit Parametern angeben möchten, müssen wir einen Nachrichtenlieferanten erstellen (Supplier ) und übergeben Sie diesen Lieferanten als letzten Methodenparameter der aufgerufenen Zusicherungsmethode.
• Wenn wir eine Zusicherung für einen Zustand schreiben müssen, der mehrere Zusicherungen erfordert, können wir unsere Zusicherungen gruppieren, indem wir den assertAll() verwenden Methode des Assertions Klasse.