[JAVA] Test-API, die häufig in AssertJ verwendet wird

Fraktion

――Die Behauptung von JUnit5 ist ausgezeichnet, aber ich wage es zu behaupten ――Schreiben Sie nur das, was Sie normalerweise verwenden

• Da die Karte nicht verwendet wird, erfolgt keine Überprüfung. --Überprüfen Sie nicht nur String und int

Betriebsumgebung

--Java8 (Verzeih mir, weil es die Umgebung ist, die ich bei der Arbeit benutze ...)

• JUnit5
• Spring Boot:
• AssertJ: 3.14.0

Die Quelle ist hier

Ursprüngliches Klassensystem

Überprüfen Sie rekursiv Felder von Objekten

Durch das Gewähren von "usingRecursiveComparison" werden Instanzvergleiche bei der Validierung verschachtelter Klassen verhindert.

@Test
Felder von leeren Objekten rekursiv validieren() {
    String studentIdentifier = generateUUID();
    String tutorIdentifier = generateUUID();
    Lesson actual = new Lesson(
        new Student(new StudentIdentifier(studentIdentifier), new StudentName("studentName")),
        new Tutor(new TutorIdentifier(tutorIdentifier), new TutorName("tutorName")));
    Lesson expected = new Lesson(
        new Student(new StudentIdentifier(studentIdentifier), new StudentName("studentName")),
        new Tutor(new TutorIdentifier(tutorIdentifier), new TutorName("tutorName")));
    Assertions.assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}

Mehrere gleichzeitig

@Test
void Beenden Sie die Überprüfung nicht in der Mitte() {
    String studentIdentifier = generateUUID();
    String tutorIdentifier = generateUUID();
    Lesson actual = new Lesson(
        new Student(new StudentIdentifier(studentIdentifier), new StudentName("studentName")),
        new Tutor(new TutorIdentifier(tutorIdentifier), new TutorName("tutorName")));
    SoftAssertions softAssertions = new SoftAssertions();
    softAssertions.assertThat(actual.student().identifier().value()).as("OK").isEqualTo(studentIdentifier);
    softAssertions.assertThat(actual.student().name().value()).as("NG").isEqualTo("x");
    softAssertions.assertThat(actual.tutor().identifier().value()).as("OK").isEqualTo(tutorIdentifier);
    softAssertions.assertThat(actual.tutor().name().value()).as("OK").isEqualTo("tutorName");
    softAssertions.assertAll();
}

Sammelsystem

Größe

@Test
Überprüfung der Hohlraumgröße() {
    List<String> actual = Arrays.asList("a", "b", "c");
    Assertions.assertThat(actual).hasSize(3);
}

Alle Elemente

Ein Überprüfungsfehler tritt auf, wenn nicht alle durch Extrahieren generierten Elemente von Tuples Iterable enthalten sind.

@Test
ungültig Überprüfung aller Elemente() {

    //Generieren Sie die erste Lektion
    String student1Identifier = generateUUID();
    String tutor1Identifier = generateUUID();
    Lesson lesson1 = new Lesson(
            new Student(new StudentIdentifier(student1Identifier), new StudentName("student1")),
            new Tutor(new TutorIdentifier(tutor1Identifier), new TutorName("tutor1")));

    //Generieren Sie eine zweite Lektion
    String student2Identifier = generateUUID();
    String tutor2Identifier = generateUUID();
    Lesson lesson2 = new Lesson(
            new Student(new StudentIdentifier(student2Identifier), new StudentName("student2")),
            new Tutor(new TutorIdentifier(tutor2Identifier), new TutorName("tutor2")));

    Lessons actual = new Lessons(Arrays.asList(lesson1, lesson2));
    Assertions.assertThat(actual.list())
            .usingRecursiveFieldByFieldElementComparator()
            //Überprüfung aller Werte, beliebiger Reihenfolge
            .containsOnly(
                    new Lesson(new Student(new StudentIdentifier(student2Identifier), new StudentName("student2")), new Tutor(new TutorIdentifier(tutor2Identifier), new TutorName("tutor2"))),
                    new Lesson(new Student(new StudentIdentifier(student1Identifier), new StudentName("student1")), new Tutor(new TutorIdentifier(tutor1Identifier), new TutorName("tutor1"))));
}

Auftrag

@Test
Stornierungsbestätigung ungültig() {
    //Generieren Sie die erste Lektion
    String student1Identifier = generateUUID();
    String tutor1Identifier = generateUUID();
    Lesson lesson1 = new Lesson(
            new Student(new StudentIdentifier(student1Identifier), new StudentName("student1")),
            new Tutor(new TutorIdentifier(tutor1Identifier), new TutorName("tutor1")));

    //Generieren Sie eine zweite Lektion
    String student2Identifier = generateUUID();
    String tutor2Identifier = generateUUID();
    Lesson lesson2 = new Lesson(
            new Student(new StudentIdentifier(student2Identifier), new StudentName("student2")),
            new Tutor(new TutorIdentifier(tutor2Identifier), new TutorName("tutor2")));

    //Generieren Sie eine dritte Lektion
    String student3Identifier = generateUUID();
    String tutor3Identifier = generateUUID();
    Lesson lesson3 = new Lesson(
            new Student(new StudentIdentifier(student3Identifier), new StudentName("student3")),
            new Tutor(new TutorIdentifier(tutor3Identifier), new TutorName("tutor3")));

    Lessons actual = new Lessons(Arrays.asList(lesson1, lesson2, lesson3));

    Assertions.assertThat(actual.list())
            .usingRecursiveFieldByFieldElementComparator()
            //Überprüfung aller Werte
            .containsExactly(
                    new Lesson(new Student(new StudentIdentifier(student1Identifier), new StudentName("student1")), new Tutor(new TutorIdentifier(tutor1Identifier), new TutorName("tutor1"))),
                    new Lesson(new Student(new StudentIdentifier(student2Identifier), new StudentName("student2")), new Tutor(new TutorIdentifier(tutor2Identifier), new TutorName("tutor2"))),
                    new Lesson(new Student(new StudentIdentifier(student3Identifier), new StudentName("student3")), new Tutor(new TutorIdentifier(tutor3Identifier), new TutorName("tutor3"))));
}

Einige Werte

@Test
Extrahieren Sie einige Werte des ungültigen Objekts und überprüfen Sie es() {
    //Generieren Sie die erste Lektion
    Lesson lesson1 = new Lesson(
            new Student(new StudentIdentifier(generateUUID()), new StudentName("student1")),
            new Tutor(new TutorIdentifier(generateUUID()), new TutorName("tutor1")));

    //Generieren Sie eine zweite Lektion
    Lesson lesson2 = new Lesson(
            new Student(new StudentIdentifier(generateUUID()), new StudentName("student2")),
            new Tutor(new TutorIdentifier(generateUUID()), new TutorName("tutor2")));

    Lessons actual = new Lessons(Arrays.asList(lesson1, lesson2));
    Assertions.assertThat(actual.list())
            //Zerlegen Sie die Elemente von Iterable, um ein neues Tupel-Iterable zu erstellen
            .extracting(
                    lesson -> lesson.student().name().value(),
                    lesson -> lesson.tutor().name().value())
            //Überprüfung aller Werte, beliebiger Reihenfolge
            .containsOnly(
                    //Mit Tupel validiert
                    Tuple.tuple("student2", "tutor2"),
                    Tuple.tuple("student1", "tutor1"));
}

Ausnahme

Ist es die richtige Ausnahme?

Ich wage es, assertThatExceptionOfType zu verwenden,

• assertThatNullPointerException
• assertThatIllegalArgumentException
• assertThatIllegalStateException
• assertThatIOException Sind individuell vorbereitet

@Test
eine nichtige Ausnahme erhalten() {
    Assertions.assertThatExceptionOfType(IOException.class)
            .isThrownBy(() -> {
                throw new IOException("IOException Message");
            })
            .withMessage("%s Message", "IOException")
            .withMessageContaining("IOException")
            .withNoCause();
}

Ich habe nur lauwarm geschrieben

@Test
nur Nurupo ungültig machen() {
    Assertions.assertThatNullPointerException().isThrownBy(() -> { throw new NullPointerException("Schleimig"); })
            .withMessage("Schleimig%s", "Gat")
            .withMessageContaining("Gat")
            .withNoCause();
}

Nachwort

Fügen wir hinzu, wenn etwas häufig verwendet wird Bitte kommentieren Sie, wenn Sie Empfehlungen haben