Java >> Java Tutorial >  >> Tag >> JUnit

JUnit 5 Tutorial:Verschachtelte Tests schreiben

Dieser Blogbeitrag beschreibt, wie wir verschachtelte Tests mit JUnit 5 schreiben können. Nachdem wir diesen Blogbeitrag beendet haben, werden wir:

  • Kann verschachtelte Testklassen erstellen.
  • Wissen, wie wir Setup-, Teardown- und Testmethoden zu verschachtelten Testklassen hinzufügen können.
  • Verstehen Sie die Aufrufreihenfolge von Setup-, Deaktivierungs- und Testmethoden.

Beginnen wir mit einem Blick auf unsere Testklasse.

Einführung in unsere Testklasse

Im vorherigen Teil dieses Tutorials wurde beschrieben, wie wir Setup- und Teardown-Methoden verwenden und Testmethoden zu unseren Testklassen hinzufügen können. Außerdem haben wir eine einfache Testklasse geschrieben und der erstellten Klasse alle Setup- und Teardown-Methoden hinzugefügt.

Der Quellcode unserer Testklasse sieht wie folgt aus:

import org.junit.jupiter.api.*;

@DisplayName("JUnit 5 Nested Example")
class JUnit5NestedExampleTest {

    @BeforeAll
    static void beforeAll() {
        System.out.println("Before all test methods");
    }

    @BeforeEach
    void beforeEach() {
        System.out.println("Before each test method");
    }

    @AfterEach
    void afterEach() {
        System.out.println("After each test method");
    }

    @AfterAll
    static void afterAll() {
        System.out.println("After all test methods");
    }
}

Als Nächstes fügen wir unserer Testklasse verschachtelte Setup-, Teardown- und Testmethoden hinzu.

Verschachtelte Tests schreiben

Wenn wir verschachtelte Tests mit JUnit 5 schreiben, müssen wir eine verschachtelte Testklassenhierarchie erstellen, die unsere Setup-, Teardown- und Testmethoden enthält. Wenn wir unserer Testklasse verschachtelte Testklassen hinzufügen, müssen wir diese Regeln befolgen:

  • Alle verschachtelten Testklassen müssen nichtstatische innere Klassen sein.
  • Wir müssen unsere verschachtelten Testklassen mit dem @Nested annotieren Anmerkung. Diese Annotation stellt sicher, dass JUnit 5 unsere verschachtelten Testklassen erkennt.
  • Es gibt keine Begrenzung für die Tiefe der Klassenhierarchie.
  • Standardmäßig kann eine verschachtelte Testklasse Testmethoden enthalten, eine @BeforeEach -Methode und ein @AfterEach Methode.
  • Weil Java static nicht zulässt Mitglieder in inneren Klassen, die @BeforeAll und @AfterAll Methoden funktionieren standardmäßig nicht.

Fügen wir unserer Testklasse ein paar innere Klassen hinzu. Die Idee dieser Übung besteht darin, die Aufrufreihenfolge von Setup-, Teardown- und Testmethoden zu demonstrieren. Wir können die erforderlichen inneren Klassen zu unserer Testklasse hinzufügen, indem wir diesen Schritten folgen:

Zuerst , müssen wir eine neue innere Klasse namens A hinzufügen zu unserer Testklasse und kommentieren Sie die innere Klasse mit dem @Nested Anmerkung. Nachdem wir die A erstellt haben Klasse müssen wir der erstellten inneren Klasse eine Setup-, Teardown- und Testmethode hinzufügen.

Nachdem wir diese innere Klasse zu JUnit5NestedExampleTest hinzugefügt haben Klasse sieht der Quellcode unserer Testklasse wie folgt aus:

import org.junit.jupiter.api.*;

@DisplayName("JUnit 5 Nested Example")
class JUnit5NestedExampleTest {

    @BeforeAll
    static void beforeAll() {
        System.out.println("Before all test methods");
    }

    @BeforeEach
    void beforeEach() {
        System.out.println("Before each test method");
    }

    @AfterEach
    void afterEach() {
        System.out.println("After each test method");
    }

    @AfterAll
    static void afterAll() {
        System.out.println("After all test methods");
    }

    @Nested
    @DisplayName("Tests for the method A")
    class A {

        @BeforeEach
        void beforeEach() {
            System.out.println("Before each test method of the A class");
        }

        @AfterEach
        void afterEach() {
            System.out.println("After each test method of the A class");
        }

        @Test
        @DisplayName("Example test for method A")
        void sampleTestForMethodA() {
            System.out.println("Example test for method A");
        }
    }
}

Zweiter , müssen wir eine neue innere Klasse namens WhenX hinzufügen zum A Klasse und kommentieren Sie die innere Klasse mit dem @Nested Anmerkung. Nachdem wir den WhenX erstellt haben Klasse müssen wir der erstellten inneren Klasse eine Setup-, Teardown- und Testmethode hinzufügen.

Nachdem wir diese innere Klasse zu A hinzugefügt haben Klasse sieht der Quellcode unserer Testklasse wie folgt aus:

import org.junit.jupiter.api.*;

@DisplayName("JUnit 5 Nested Example")
class JUnit5NestedExampleTest {

    @BeforeAll
    static void beforeAll() {
        System.out.println("Before all test methods");
    }

    @BeforeEach
    void beforeEach() {
        System.out.println("Before each test method");
    }

    @AfterEach
    void afterEach() {
        System.out.println("After each test method");
    }

    @AfterAll
    static void afterAll() {
        System.out.println("After all test methods");
    }

    @Nested
    @DisplayName("Tests for the method A")
    class A {

        @BeforeEach
        void beforeEach() {
            System.out.println("Before each test method of the A class");
        }

        @AfterEach
        void afterEach() {
            System.out.println("After each test method of the A class");
        }

        @Test
        @DisplayName("Example test for method A")
        void sampleTestForMethodA() {
            System.out.println("Example test for method A");
        }

        @Nested
        @DisplayName("When X is true")
        class WhenX {

            @BeforeEach
            void beforeEach() {
                System.out.println("Before each test method of the WhenX class");
            }

            @AfterEach
            void afterEach() {
                System.out.println("After each test method of the WhenX class");
            }

            @Test
            @DisplayName("Example test for method A when X is true")
            void sampleTestForMethodAWhenX() {
                System.out.println("Example test for method A when X is true");
            }
        }
    }
}

Wir haben jetzt eine Testklasse geschrieben, die verschachtelte Tests enthält. Mal sehen, was passiert, wenn wir unsere Tests durchführen.

Durchführung unserer Tests

Wenn wir unsere Tests ausführen, sollten wir die folgende Ausgabe sehen:

Before all test methods
Before each test method
Before each test method of the A class
Example test for method A
After each test method of the A class
After each test method
Before each test method
Before each test method of the A class
Before each test method of the WhenX class
Example test for method A when X is true
After each test method of the WhenX class
After each test method of the A class
After each test method
After all test methods

Mit anderen Worten, JUnit 5 ruft die Setup- und Teardown-Methoden auf, indem es der Kontexthierarchie der aufgerufenen Testmethode folgt. Das bedeutet, dass wir doppelten Code eliminieren können, indem wir unseren Code an der richtigen Stelle platzieren.

Wir haben jetzt eine Testklasse geschrieben, die verschachtelte Setup-, Teardown- und Testmethoden enthält. Außerdem verstehen wir die Aufrufreihenfolge dieser Methoden. Fassen wir zusammen, was wir aus diesem Blogbeitrag gelernt haben.

Zusammenfassung

Dieser Blogbeitrag hat uns fünf Dinge beigebracht:

  • Alle verschachtelten Testklassen müssen nichtstatische innere Klassen sein.
  • Alle verschachtelten Testklassen müssen mit dem @Nested annotiert werden Anmerkung.
  • Die Tiefe der Testklassenhierarchie ist in keiner Weise eingeschränkt.
  • Eine verschachtelte Testklasse kann Testmethoden enthalten, eine @BeforeEach -Methode und ein @AfterEach Methode.
  • Standardmäßig können wir den @BeforeAll nicht hinzufügen und @AfterAll Methoden zu einer verschachtelten Testklasse.

Java-Tag