Java einfach erklärt

Plain Java

AssertJ – bessere Assertions in Java-Unit-Tests

AssertJ ist eine leistungsfähige und leicht zu verwendende Java-Assertion-Bibliothek, die für ihre klaren und intuitiven API bekannt ist. Sie erleichtert das Schreiben und Verstehen von Testcode und bietet eine breite Palette an Assertionen, die weit über die Möglichkeiten von JUnit und Hamcrest hinausgehen. In diesem Artikel werden wir die Hauptmerkmale und die Anwendung von AssertJ detailliert beleuchten.

Einführung in AssertJ

AssertJ ist eine Open-Source-Bibliothek, die ursprünglich als Erweiterung von Fest-Assertions entstand. Sie wurde entwickelt, um die Einschränkungen und Unzulänglichkeiten anderer Assertion-Bibliotheken zu überwinden. Mit ihrer flüssigen und lesbaren Syntax bietet AssertJ Entwicklern eine Vielzahl von Vorteilen, darunter:

  • Klarheit und Lesbarkeit: Die API von AssertJ ist so gestaltet, dass die Tests leicht zu lesen und zu verstehen sind. Das trägt zur besseren Wartbarkeit des Codes bei.
  • Erweiterbarkeit: AssertJ ermöglicht die Erstellung benutzerdefinierter Assertionen, die spezifisch auf die Anforderungen eines Projekts zugeschnitten sind.
  • Leistungsstärke: Mit einer breiten Palette von vordefinierten Assertionen können Entwickler nahezu alle Aspekte ihres Codes überprüfen.

Grundlegende Verwendung

Installation

Um AssertJ in einem Maven-Projekt zu verwenden, muss die folgende Abhängigkeit in der pom.xml hinzugefügt werden:

<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <version>3.20.2</version>
    <scope>test</scope>
</dependency>Code-Sprache: HTML, XML (xml)

Für Gradle-Projekte sieht die Konfiguration wie folgt aus:

testImplementation 'org.assertj:assertj-core:3.20.2'Code-Sprache: JavaScript (javascript)

Erste Schritte mit AssertJ

Ein einfaches Beispiel für die Verwendung von AssertJ könnte wie folgt aussehen:

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

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

public class AssertJExampleTest {

    @Test
    public void testAssertions() {
        String str = "Hello, AssertJ!";
        List<String> list = Arrays.asList("one", "two", "three");

        Assertions.assertThat(str).isNotNull()
                .startsWith("Hello")
                .contains("AssertJ")
                .endsWith("!");

        Assertions.assertThat(list).isNotEmpty()
                .hasSize(3)
                .contains("two")
                .doesNotContain("four");
    }
}Code-Sprache: JavaScript (javascript)

In diesem Beispiel überprüfen wir verschiedene Eigenschaften eines Strings und einer Liste. Die Methode assertThat dient als Einstiegspunkt für alle Assertionen in AssertJ.

Wichtige Funktionen und Assertionen

AssertJ bietet eine Vielzahl von Assertionen, die in verschiedene Kategorien unterteilt werden können. Im Folgenden werden einige der wichtigsten Funktionen und ihre Anwendung beschrieben.

String-Assertionen

Mit String-Assertionen können Entwickler verschiedene Eigenschaften und Zustände von Strings überprüfen. Hier einige häufig verwendete Methoden:

String str = "AssertJ is great!";

Assertions.assertThat(str).isNotNull()
        .isNotEmpty()
        .startsWith("AssertJ")
        .endsWith("great!")
        .contains("is")
        .doesNotContain("bad")
        .isEqualToIgnoringCase("assertj is great!");Code-Sprache: JavaScript (javascript)

Collection-Assertionen

Für Collections bietet AssertJ umfassende Möglichkeiten zur Überprüfung von Größe, Inhalt und Reihenfolge:

List<String> list = Arrays.asList("one", "two", "three");

Assertions.assertThat(list).isNotEmpty()
        .hasSize(3)
        .contains("one", "two")
        .containsExactly("one", "two", "three")
        .doesNotContain("four");Code-Sprache: PHP (php)

Array-Assertionen

Array-Assertionen sind ähnlich zu Collection-Assertionen, jedoch spezifisch für Arrays:

int[] numbers = {1, 2, 3, 4, 5};

Assertions.assertThat(numbers).isNotEmpty()
        .hasSize(5)
        .contains(1, 2, 3)
        .containsExactly(1, 2, 3, 4, 5)
        .doesNotContain(6);

Map-Assertionen

Mit Map-Assertionen lassen sich Schlüssel, Werte und Einträge einer Map überprüfen:

Map<String, Integer> map = new HashMap<>();
map.put("one", 1);
map.put("two", 2);
map.put("three", 3);

Assertions.assertThat(map).isNotEmpty()
        .hasSize(3)
        .containsKeys("one", "two")
        .containsValues(1, 2)
        .containsEntry("three", 3);Code-Sprache: JavaScript (javascript)

Exception-Assertionen

AssertJ bietet auch Möglichkeiten zur Überprüfung von Exceptions und deren Eigenschaften:

Throwable thrown = Assertions.catchThrowable(() -> {
    throw new IllegalArgumentException("Invalid argument");
});

Assertions.assertThat(thrown).isInstanceOf(IllegalArgumentException.class)
        .hasMessageContaining("Invalid");Code-Sprache: JavaScript (javascript)

Datum- und Zeit-Assertionen

Für die Arbeit mit Datums- und Zeitwerten bietet AssertJ spezielle Assertionen:

LocalDate date = LocalDate.of(2023, 5, 15);

Assertions.assertThat(date).isAfter(LocalDate.of(2023, 1, 1))
        .isBefore(LocalDate.of(2023, 12, 31))
        .isEqualTo("2023-05-15");Code-Sprache: JavaScript (javascript)

Erweiterte Funktionen

Benutzerdefinierte Assertionen

AssertJ ermöglicht die Erstellung benutzerdefinierter Assertionen, um spezifische Anforderungen zu erfüllen. Hier ein Beispiel:

public class Person {
    private String name;
    private int age;

    // Konstruktoren, Getter und Setter
}

public class PersonAssert extends AbstractAssert<PersonAssert, Person> {

    public PersonAssert(Person actual) {
        super(actual, PersonAssert.class);
    }

    public static PersonAssert assertThat(Person actual) {
        return new PersonAssert(actual);
    }

    public PersonAssert hasName(String name) {
        isNotNull();
        if (!actual.getName().equals(name)) {
            failWithMessage("Expected person's name to be <%s> but was <%s>", name, actual.getName());
        }
        return this;
    }

    public PersonAssert hasAge(int age) {
        isNotNull();
        if (actual.getAge() != age) {
            failWithMessage("Expected person's age to be <%s> but was <%s>", age, actual.getAge());
        }
        return this;
    }
}

// Verwendung der benutzerdefinierten Assertion
Person person = new Person("John Doe", 25);

PersonAssert.assertThat(person).hasName("John Doe")
        .hasAge(25);Code-Sprache: JavaScript (javascript)

Soft Assertions

Mit Soft Assertions kann man mehrere Assertionen gleichzeitig ausführen und alle Fehler auf einmal anzeigen, anstatt nach dem ersten Fehler abzubrechen:

SoftAssertions softly = new SoftAssertions();

softly.assertThat("Hello").isEqualTo("Hello");
softly.assertThat(1).isGreaterThan(0);
softly.assertThat(true).isFalse(); // Dieser Fehler wird erst am Ende ausgegeben

softly.assertAll(); // Führt alle Assertionen aus und zeigt alle Fehler anCode-Sprache: JavaScript (javascript)

BDD-Style Assertions

AssertJ unterstützt auch Behavior-Driven Development (BDD)-Style Assertions:

import static org.assertj.core.api.BDDAssertions.*;

String str = "AssertJ BDD";

then(str).isNotNull()
        .startsWith("AssertJ")
        .endsWith("BDD")
        .contains(" ");Code-Sprache: JavaScript (javascript)

Fazit

AssertJ ist eine vielseitige und leistungsfähige Assertion-Bibliothek, die das Schreiben und Verstehen von Tests erheblich erleichtert. Mit ihrer klaren und lesbaren API, den umfangreichen vordefinierten Assertionen und der Möglichkeit, benutzerdefinierte Assertionen zu erstellen, ist AssertJ ein wertvolles Werkzeug für jeden Java-Entwickler. Ob für einfache Unit-Tests oder komplexe Integrations-Tests – AssertJ bietet die Flexibilität und die Funktionen, die Entwickler benötigen, um robuste und wartbare Tests zu schreiben.