Brugerdefinerede påstande med AssertJ

Denne artikel er en del af en serie:• Introduktion til AssertJ
• AssertJ for Guava
• AssertJs Java 8-funktioner
• Brugerdefinerede påstande med AssertJ (aktuel artikel)

1. Oversigt

I denne vejledning gennemgår vi oprettelse af brugerdefinerede AssertJ-påstande; AssertJ's grundlæggende kan findes her.

Enkelt sagt giver brugerdefinerede påstande mulighed for at skabe påstande, der er specifikke for vores egne klasser, så vores tests bedre afspejler domænemodellen.

2. Klasse under test

Testcases i denne øvelse vil blive bygget op omkring Personen klasse:

public class Person {
    private String fullName;
    private int age;
    private List<String> nicknames;

    public Person(String fullName, int age) {
        this.fullName = fullName;
        this.age = age;
        this.nicknames = new ArrayList<>();
    }

    public void addNickname(String nickname) {
        nicknames.add(nickname);
    }

    // getters
}

3. Custom Assertion Class

At skrive en brugerdefineret AssertJ-påstandsklasse er ret simpelt. Alt, vi skal gøre, er at erklære en klasse, der udvider AbstractAssert , tilføj en påkrævet konstruktør og angiv tilpassede påstandsmetoder.

Assertion-klassen skal udvide AbstractAssert klasse for at give os adgang til væsentlige påstandsmetoder i API'et, såsom isNotNull og isEqualTo .

Her er skelettet af en tilpasset påstandsklasse for Person :

public class PersonAssert extends AbstractAssert<PersonAssert, Person> {

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

    // assertion methods described later
}

Vi skal angive to typeargumenter, når vi udvider AbstractAssert klasse:den første er selve den tilpassede påstandsklasse, som kræves til metodekæde, og den anden er klassen, der testes.

For at give et indgangspunkt til vores påstandsklasse kan vi definere en statisk metode, der kan bruges til at starte en påstandskæde:

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

Dernæst vil vi gennemgå flere tilpassede påstande inkluderet i PersonAssert klasse.

Den første metode verificerer, at det fulde navn på en Person matcher en streng argument:

public PersonAssert hasFullName(String fullName) {
    isNotNull();
    if (!actual.getFullName().equals(fullName)) {
        failWithMessage("Expected person to have full name %s but was %s", 
          fullName, actual.getFullName());
    }
    return this;
}

Følgende metode tester, om en Person er en voksen baseret på dens alder :

public PersonAssert isAdult() {
    isNotNull();
    if (actual.getAge() < 18) {
        failWithMessage("Expected person to be adult");
    }
    return this;
}

Den sidste kontrollerer, om der findes et kaldenavn :

public PersonAssert hasNickName(String nickName) {
    isNotNull();
    if (!actual.getNickNames().contains(nickName)) {
        failWithMessage("Expected person to have nickname %s", 
          nickName);
    }
    return this;
}

Når vi har mere end én tilpasset påstandsklasse, kan vi ombryde alle assertThat metoder i en klasse, der giver en statisk fabriksmetode for hver af påstandsklasserne:

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

    // static factory methods of other assertion classes
}

påstandene klasse vist ovenfor er et praktisk indgangspunkt til alle brugerdefinerede påstandsklasser.

Statiske metoder af denne klasse har samme navn og er adskilt fra hinanden ved deres parametertype.

4. I aktion

De følgende testcases vil illustrere de brugerdefinerede påstandsmetoder, vi oprettede i det foregående afsnit. Bemærk, at assertThat metode er importeret fra vores tilpassede påstande klasse, ikke kerne AssertJ API.

Sådan er hasFullName metode kan bruges:

@Test
public void whenPersonNameMatches_thenCorrect() {
    Person person = new Person("John Doe", 20);
    assertThat(person)
      .hasFullName("John Doe");
}

Dette er en negativ testcase, der illustrerer isAdult metode:

@Test
public void whenPersonAgeLessThanEighteen_thenNotAdult() {
    Person person = new Person("Jane Roe", 16);

    // assertion fails
    assertThat(person).isAdult();
}

og en anden test, der viser hasNickname metode:

@Test
public void whenPersonDoesNotHaveAMatchingNickname_thenIncorrect() {
    Person person = new Person("John Doe", 20);
    person.addNickname("Nick");

    // assertion will fail
    assertThat(person)
      .hasNickname("John");
}

5. Påstandsgenerator

At skrive tilpassede påstandsklasser svarende til objektmodellen baner vejen for meget læsbare testcases.

Men hvis vi har mange klasser, ville det være smertefuldt manuelt at oprette tilpassede påstandsklasser for dem alle . Det er her, AssertJ-påstandsgeneratoren kommer i spil.

For at bruge påstandsgeneratoren med Maven skal vi tilføje et plugin til pom.xml fil:

<plugin>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-assertions-generator-maven-plugin</artifactId>
    <version>2.1.0</version>
    <configuration>
        <classes>
            <param>com.baeldung.testing.assertj.custom.Person</param>
        </classes>
    </configuration>
</plugin>

Den seneste version af assertj-assertions-generator-maven-plugin kan findes her.

klasserne element i ovenstående plugin markerer klasser, som vi ønsker at generere påstande for. Se venligst dette indlæg for andre konfigurationer af pluginnet.

AssertJ-påstandsgeneratoren opretter påstande for hver offentlig ejendom i målklassen . Det specifikke navn på hver påstandsmetode afhænger af feltets eller egenskabens type. For en komplet beskrivelse af påstandsgeneratoren, se denne reference.

Udfør følgende Maven-kommando i projektets basisbibliotek:

mvn assertj:generate-assertions

Vi skulle se påstandsklasser genereret i mappen mål /generated-test-sources/assertj-assertions . For eksempel ser den genererede indgangspunktklasse for de genererede påstande sådan ud:

// generated comments are stripped off for brevity

package com.baeldung.testing.assertj.custom;

@javax.annotation.Generated(value="assertj-assertions-generator")
public class Assertions {

    @org.assertj.core.util.CheckReturnValue
    public static com.baeldung.testing.assertj.custom.PersonAssert
      assertThat(com.baeldung.testing.assertj.custom.Person actual) {
        return new com.baeldung.testing.assertj.custom.PersonAssert(actual);
    }

    protected Assertions() {
        // empty
    }
}

Nu kan vi kopiere de genererede kildefiler til testbiblioteket og derefter tilføje brugerdefinerede påstandsmetoder for at opfylde vores testkrav.

En vigtig ting at bemærke er, at den genererede kode ikke garanteres at være helt korrekt. På dette tidspunkt er generatoren ikke et færdigt produkt, og fællesskabet arbejder på det.

Derfor bør vi bruge generatoren som et støtteværktøj til at gøre vores liv lettere i stedet for at tage det for givet.

6. Konklusion

I denne øvelse har vi vist, hvordan du opretter brugerdefinerede påstande til at oprette læsbar testkode med AssertJ-biblioteket, både manuelt og automatisk.

Hvis vi kun har et lille antal klasser under test, er den manuelle løsning nok; ellers skal generatoren bruges.

Og som altid kan implementeringen af ​​alle eksemplerne og kodestykkerne findes på GitHub.

« ForrigeAssertJs Java 8-funktioner