Komponententest

Werfen wir einen genaueren Blick auf das Konzept des Unit-Tests und warum es notwendig ist.

JUnit-Grundlagen

JUnit ist ein Framework für Komponententests, das Annotationen zur Definition von Testmethoden und Assertions zur Überprüfung erwarteter Ergebnisse bereitstellt.

Sie haben bereits Annotationen kennengelernt, als Sie verschiedene Methoden überschrieben. Einfach ausgedrückt, sagen Annotationen dem Compiler oder Framework was mit einem bestimmten Modul zu tun ist. Sie liefern auch Informationen für den Programmierer über die Bedeutung einer bestimmten Zeile oder eines Moduls im Programm. Annotationen vereinfachen das Leben erheblich und werden in fast jedem Framework verwendet. Schauen wir uns ein einfaches Beispiel für einen Komponententest an, und Sie werden verstehen, wie Annotationen verwendet werden:

In diesem Beispiel:

Die @Test Annotation zeigt an, dass die Methode testAddition() eine Testmethode ist;
Calculator ist die Klasse, die wir testen;
Assertions.assertEquals(8, result) überprüft, dass das Additionsergebnis gleich 8 ist.

Daher haben wir überprüft, dass die add() Methode ihre Funktion korrekt ausführt. Ein einzelner Unit-Test ist jedoch nicht ausreichend, da es viele andere Probleme geben könnte. Zum Beispiel könnte ein Benutzer null anstatt einer Zahl übergeben, oder die Zahlen könnten außerhalb des akzeptablen Bereichs liegen. Solche Fälle sollten ebenfalls durch Unit-Tests abgedeckt werden.

Hinweis

Wir werden im nächsten Abschnitt auf das Schreiben und Lernen von Unit-Tests eingehen. Dieses Kapitel ist zu Informationszwecken gedacht und soll Ihnen helfen zu verstehen, warum das Schreiben von Unit-Tests notwendig ist.

Was sollten Unit-Tests überprüfen?

Stellen wir uns vor, dass wir eine einfache Methode testen müssen. Zu diesem Zweck werden wir eine Methode schreiben, die einen String in der Form von
"Name||Address||email||phoneNumber||" nimmt und in eine Map mit entsprechenden Schlüsseln und Werten aufteilt.

Der Code dieser Methode sieht ungefähr so aus:

Main


              12345678910111213141516171819202122232425
            
package com.example;

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

public class Main {

    public static Map<String, String> convertToMap(String input) {
        Map<String, String> resultMap = new HashMap<>();
        String[] parts = input.split("\\|\\|");
        
        resultMap.put("Name", parts[0]);
        resultMap.put("Address", parts[1]);
        resultMap.put("Email", parts[2]);
        resultMap.put("PhoneNumber", parts[3]);

        return resultMap;
    }

    public static void main(String[] args) {
        String input = "John Doe||123 Maple Street||johndoe@example.com||555-1234";
        Map<String, String> result = convertToMap(input);
        System.out.println(result);
    }
}

Hinweis

Um dieses Format zu teilen, müssen wir nach dem ||-Symbol teilen, aber wir müssen dem Compiler anzeigen, dass es sich tatsächlich um ein Symbol und keinen Befehl handelt. Daher verwenden wir \\ vor dem Symbol. Unser Regex sieht also so aus: \\|\\|.

Die Methode ist ziemlich einfach zu schreiben. Aber lassen Sie uns nun darauf zurückkommen, welche Testfälle genau für diese Methode existieren:

Test von korrekten Daten Testen mit korrekt formatiertem Eingabestring. Es wird erwartet, dass die Methode eine Map mit den korrekten Werten für jeden Schlüssel zurückgibt;
Test von falschem Format Testen mit einem String, der nicht dem erwarteten Format entspricht (z.B. fehlen einige der erforderlichen ||-Trennzeichen oder sind im Übermaß vorhanden);
Test von leerem String Überprüfung des Verhaltens der Methode, wenn der Eingabestring leer ist. Die Methode sollte entweder eine leere Map zurückgeben oder eine Ausnahme auslösen;
Test von Null-String Testen des Verhaltens der Methode, wenn null als Eingabestring übergeben wird.

Gehen wir Schritt für Schritt vor. Im ersten Testfall werden wir die Funktion dieser Methode mit korrekten Daten testen. In der main-Methode haben wir dies bereits getan, als wir einen Wert übergeben und die korrekten Daten erhalten haben.

Im zweiten Testfall müssen wir ein falsches Format übergeben, um zu sehen, wie sich die Methode verhält. Zum Beispiel lassen Sie uns Daten getrennt durch ein einzelnes |-Zeichen übergeben:

main


              12345678910111213141516171819202122232425
            
package com.example;

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

public class Main {

    public static Map<String, String> convertToMap(String input) {
        Map<String, String> resultMap = new HashMap<>();
        String[] parts = input.split("\\|\\|");

        resultMap.put("Name", parts[0]);
        resultMap.put("Address", parts[1]);
        resultMap.put("Email", parts[2]);
        resultMap.put("PhoneNumber", parts[3]);

        return resultMap;
    }

    public static void main(String[] args) {
        String input = "John Doe|123 Maple Street|johndoe@example.com|555-1234";
        Map<String, String> result = convertToMap(input);
        System.out.println(result);
    }
}

Wie Sie sehen können, werfen wir eine IndexOutOfBoundsException. Das bedeutet, dass das Array, das wir aus dem ursprünglichen String erstellen, nicht 4 Elemente hat, wie es sollte. Der Test hat uns gezeigt, dass unsere Methode nicht perfekt ist, also fügen wir eine Ausnahmebehandlung mit einer einfachen if-Anweisung hinzu:

Hier haben wir eine grundlegende Überprüfung hinzugefügt, die im Falle falscher Daten eine leere Map zurückgibt und eine Nachricht über den fehlerhaften Betrieb der Methode ausgibt.

Schauen wir uns ein ausführbares Beispiel an:

main


              123456789101112131415161718192021222324252627282930
            
package com.example;

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

public class Main {

    public static Map<String, String> convertToMap(String input) {
        Map<String, String> resultMap = new HashMap<>();
        String[] parts = input.split("\\|\\|");

        if (parts.length != 4) {
            System.out.println("Input string format is not correct");
            return new HashMap<>();
        }

        resultMap.put("Name", parts[0]);
        resultMap.put("Address", parts[1]);
        resultMap.put("Email", parts[2]);
        resultMap.put("PhoneNumber", parts[3]);

        return resultMap;
    }

    public static void main(String[] args) {
        String input = "John Doe|123 Maple Street|johndoe@example.com|555-1234";
        Map<String, String> result = convertToMap(input);
        System.out.println(result);
    }
}

Wie Sie sehen können, wird der dritte Testfall ebenfalls durch diese Überprüfung abgedeckt; Wenn ein leerer String übergeben wird, wird er die von uns geschriebene Validierung nicht bestehen.

Kommen wir nun zu dem Fall, in dem ein null-Wert übergeben wird. Derzeit überprüfen wir den String nicht auf null, daher müssen wir diese Überprüfung in der Methode hinzufügen:

Wir haben eine null-Überprüfung hinzugefügt, und jetzt wird die Methode eine leere Map zurückgeben, wenn null an sie übergeben wird.

Lassen Sie uns diesen Code ausführen und das Ergebnis sehen:

main


              1234567891011121314151617181920212223242526272829303132333435
            
package com.example;

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

public class Main {

    public static Map<String, String> convertToMap(String input) {
        if (input == null) {
            System.out.println("Input string can't be null!");
            return new HashMap<>();
        }

        Map<String, String> resultMap = new HashMap<>();
        String[] parts = input.split("\\|\\|");

        if (parts.length != 4) {
            System.out.println("Input string format is not correct");
            return new HashMap<>();
        }

        resultMap.put("Name", parts[0]);
        resultMap.put("Address", parts[1]);
        resultMap.put("Email", parts[2]);
        resultMap.put("PhoneNumber", parts[3]);

        return resultMap;
    }

    public static void main(String[] args) {
        String input = null;
        Map<String, String> result = convertToMap(input);
        System.out.println(result);
    }
}

Also haben wir eine verfeinerte Methode, die verschiedene Fehler und unterschiedliche Parameterübergabefälle behandelt. Wir haben diese Methode manuell getestet, ohne die JUnit-Bibliothek zu verwenden. Im nächsten Abschnitt werden wir dies jedoch viel schneller mit dieser Bibliothek und Unit-Tests tun.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 4