Inleiding tot AssertJ

Dit artikel maakt deel uit van een serie: • Inleiding tot AssertJ (huidig ​​artikel) • AssertJ voor Guava

• AssertJ's Java 8-functies

• Aangepaste beweringen met AssertJ

1. Overzicht

In dit artikel zullen we AssertJ verkennen - een opensource community-gedreven bibliotheek die wordt gebruikt voor het schrijven van vloeiende en rijke beweringen in Java-tests.

Dit artikel richt zich op tools die beschikbaar zijn in de basis AssertJ-module genaamd AssertJ-core.

2. Afhankelijkheden van Maven

Om AssertJ te gebruiken, moet u de volgende sectie opnemen in uw pom.xml het dossier:

 org.assertj assertj-core 3.4.1 test 

Deze afhankelijkheid dekt alleen de elementaire Java-beweringen. Als u geavanceerde beweringen wilt gebruiken, moet u extra modules afzonderlijk toevoegen.

Merk op dat u voor Java 7 en eerder AssertJ core-versie 2.x.x moet gebruiken.

De laatste versies zijn hier te vinden.

3. Inleiding

AssertJ biedt een reeks klassen en hulpprogramma's waarmee we gemakkelijk vloeiende en mooie beweringen kunnen schrijven voor:

  • Standaard Java
  • Java 8
  • Guave
  • Joda-tijd
  • Neo4J en
  • Swing componenten

Een gedetailleerde lijst van alle modules is beschikbaar op de website van het project.

Laten we beginnen met een paar voorbeelden, rechtstreeks uit de documentatie van AssertJ:

assertThat (frodo) .isNotEqualTo (sauron) .isIn (fellowshipOfTheRing); assertThat (frodo.getName ()) .startsWith ("Fro") .endsWith ("do") .isEqualToIgnoringCase ("frodo"); assertThat (fellowshipOfTheRing) .hasSize (9) .bevat (frodo, sam) .doesNotContain (sauron);

De bovenstaande voorbeelden zijn slechts het topje van de ijsberg, maar geven ons een overzicht van hoe het schrijven van beweringen met deze bibliotheek eruit zou kunnen zien.

4. AssertJ in actie

In deze sectie zullen we ons concentreren op het opzetten van AssertJ en het verkennen van de mogelijkheden ervan.

4.1. Beginnen

Met de jar van de bibliotheek op een klassenpad, is het inschakelen van beweringen net zo eenvoudig als het toevoegen van een enkele statische import aan uw testklasse:

importeer statische org.assertj.core.api.Assertions. *;

4.2. Beweringen schrijven

Om een ​​bewering te schrijven, moet u altijd beginnen met het doorgeven van uw object aan de Assertions.assertThat () methode en dan volg je met de feitelijke beweringen.

Het is belangrijk om te onthouden dat, in tegenstelling tot sommige andere bibliotheken, de onderstaande code nog niet echt iets beweert en zal doen nooit een test niet doorstaan:

assertThat (anyRefenceOrValue);

Als u gebruikmaakt van de functies voor het aanvullen van code van uw IDE, wordt het schrijven van AssertJ-beweringen ongelooflijk eenvoudig vanwege de zeer beschrijvende methoden. Zo ziet het eruit in IntelliJ IDEA 16:

IDE's functies voor het aanvullen van codes

Zoals je kunt zien, heb je tientallen contextuele methoden om uit te kiezen en die zijn alleen beschikbaar voor Draad type. Laten we enkele van deze API's in detail bekijken en enkele specifieke beweringen bekijken.

4.3. Voorwerp Beweringen

Voorwerpen kunnen op verschillende manieren worden vergeleken om de gelijkheid van twee objecten te bepalen of om de velden van een object te onderzoeken.

Laten we eens kijken naar twee manieren waarop we de gelijkheid van twee objecten kunnen vergelijken. Gegeven de volgende twee Hond voorwerpen fido en fidosClone:

openbare klasse Hond {privé Stringnaam; privé Float-gewicht; // standard getters and setters} Dog fido = new Dog ("Fido", 5.25); Dog fidosClone = nieuwe hond ("Fido", 5.25);

We kunnen gelijkheid vergelijken met de volgende bewering:

assertThat (fido) .isEqualTo (fidosClone);

Dit zal mislukken als is gelijk aan() vergelijkt objectreferenties. Als we in plaats daarvan hun inhoud willen vergelijken, kunnen we gebruiken isEqualToComparingFieldByFieldRecursively () zo:

assertThat (fido) .isEqualToComparingFieldByFieldRecursively (fidosClone);

Fido en fidosClone zijn gelijk bij het uitvoeren van een recursieve veld-op-veldvergelijking, omdat elk veld van het ene object wordt vergeleken met het veld in het andere object.

Er zijn veel andere assertiemethoden die verschillende manieren bieden om objecten te vergelijken en te contracteren en om hun velden te onderzoeken en te bevestigen. Raadpleeg de ambtenaar om ze allemaal te ontdekken AbstractObjectAssert documentatie.

4.4. Boolean Beweringen

Er zijn enkele eenvoudige methoden om de waarheid te testen:

  • is waar()
  • is fout()

Laten we ze in actie zien:

assertThat ("". isEmpty ()). isTrue ();

4.5. Iterable / Array Beweringen

Voor een Herhaalbaar of een Array er zijn meerdere manieren om te beweren dat hun inhoud bestaat. Een van de meest voorkomende beweringen is om te controleren of een Herhaalbaar of Array bevat een bepaald element:

Lijst lijst = Arrays.asList ("1", "2", "3"); assertThat (lijst) .contains ("1");

of als een Lijst is niet leeg:

assertThat (lijst) .isNotEmpty ();

of als een Lijst begint met een bepaald karakter. Bijvoorbeeld "1":

assertThat (lijst) .startsWith ("1");

Houd er rekening mee dat als u meer dan één bewering voor hetzelfde object wilt maken, u ze gemakkelijk kunt samenvoegen.

Hier is een voorbeeld van een bewering die controleert of een opgegeven lijst niet leeg is, het element "1" bevat, geen nullen bevat en een reeks elementen "2", "3" bevat:

assertThat (lijst) .isNotEmpty () .contains ("1") .doesNotContainNull () .containsSequence ("2", "3");

Er zijn natuurlijk veel meer mogelijke beweringen voor die typen. Raadpleeg de ambtenaar om ze allemaal te ontdekken AbstractIterableAssert documentatie.

4.6. Karakter Beweringen

Beweringen voor karaktertypen omvatten meestal vergelijkingen en zelfs het controleren of een bepaald karakter van een Unicode tafel.

Hier is een voorbeeld van een bewering die controleert of een opgegeven teken niet ‘a 'is, in de Unicode-tabel staat, groter is dan‘ b' en in kleine letters is:

assertThat (someCharacter) .isNotEqualTo ('a') .inUnicode () .isGreaterThanOrEqualTo ('b') .isLowerCase ();

Zie voor een gedetailleerde lijst van alle beweringen van karaktertypen AbstractCharacterAssert documentatie.

4.7. Klasse Beweringen

Beweringen voor Klasse type gaat meestal over het controleren van de velden, Klasse typen, aanwezigheid van annotaties en definitiefheid van de klas.

Als je die klasse wilt laten gelden Runnable is een interface, je hoeft alleen maar te schrijven:

assertThat (Runnable.class) .isInterface ();

of als je wilt controleren of de ene klas kan worden toegewezen aan de andere:

assertThat (Exception.class) .isAssignableFrom (NoSuchElementException.class);

Alles mogelijk Klasse beweringen kunnen worden bekeken in het AbstractClassAssert documentatie.

4.8. het dossier Beweringen

het dossier beweringen hebben alles te maken met het controleren of een gegeven is het dossier instantie bestaat, is een directory of een bestand, heeft bepaalde inhoud, is leesbaar of heeft een extensie gegeven.

Hier kun je een voorbeeld zien van een bewering die controleert of een bepaald bestand bestaat, een bestand is en geen directory, leesbaar en beschrijfbaar kan zijn:

 assertThat (someFile) .exists () .isFile () .canRead () .canWrite ();

Alle mogelijke Class-beweringen kunnen worden bekeken in het AbstractFileAssert documentatie.

4.9. Dubbel / zwevend / geheel getal Beweringen

Dubbel / zwevend / geheel getal en andere Aantal Types

Numerieke beweringen hebben alles te maken met het vergelijken van numerieke waarden binnen of zonder een bepaalde offset. Als u bijvoorbeeld wilt controleren of twee waarden gelijk zijn volgens een bepaalde precisie, kunnen we het volgende doen:

assertThat (5.1) .isEqualTo (5, withPrecision (1d));

Merk op dat we al geïmporteerd withPrecision (dubbele offset) helper-methode voor het genereren van Compensatie voorwerpen.

Bezoek de AbstractDoubleAssert-documentatie voor meer beweringen.

4.10. InputStream Beweringen

Er is slechts een InputStream-specifieke bewering beschikbaar:

  • hasSameContentAs (InputStream verwacht)

en in actie:

assertThat (gegeven) .hasSameContentAs (verwacht);

4.11. Kaart Beweringen

Kaart Met beweringen kunt u controleren of een kaart een bepaald item, een reeks items of afzonderlijke sleutels / waarden bevat.

En hier kun je een voorbeeld zien van een bewering die controleert of een bepaalde kaart niet leeg is, numerieke sleutel "2" bevat, geen numerieke sleutel "10" bevat en invoer bevat: key: 2, waarde: "a":

assertThat (map) .isNotEmpty () .containsKey (2) .doesNotContainKeys (10) .contains (entry (2, "a"));

Zie voor meer beweringen AbstractMapAssert documentatie.

4.12. Gooibaar Beweringen

Gooibaar beweringen staan ​​bijvoorbeeld toe: het inspecteren van uitzonderingsberichten, stacktraces, het controleren of verifiëren of er al een uitzondering is gegenereerd.

Laten we eens kijken naar het voorbeeld van een bewering die controleert of een bepaalde uitzondering is gegenereerd en een bericht heeft dat eindigt op "c":

assertThat (ex) .hasNoCause (). hasMessageEndingWith ("c");

Zie de AbstractThrowableAssert-documentatie voor meer beweringen.

5. Beschrijven van beweringen

Om een ​​nog hoger breedsprakigheidsniveau te bereiken, kunt u dynamisch gegenereerde aangepaste beschrijvingen voor uw beweringen maken. De sleutel om dit te doen is de as (String description, Object ... args) methode.

Als je je bewering als volgt definieert:

assertThat (person.getAge ()) .as ("De leeftijd van% s moet gelijk zijn aan 100", person.getName ()) .isEqualTo (100);

dit is wat u krijgt als u tests uitvoert:

[Alex 'leeftijd zou gelijk moeten zijn aan 100] verwacht: maar was:

6. Java 8

AssertJ maakt optimaal gebruik van de functionele programmeerfuncties van Java 8. Laten we in een voorbeeld duiken en het in actie zien. Laten we eerst eens kijken hoe we het doen in Java 7:

assertThat (fellowshipOfTheRing) .filteredOn ("race", HOBBIT) .containsOnly (sam, frodo, pippin, merry);

Hier filteren we een verzameling over de race Hobbit en in Java 8 kunnen we zoiets als dit doen:

assertThat (fellowshipOfTheRing) .filteredOn (character -> character.getRace (). equals (HOBBIT)) .containsOnly (sam, frodo, pippin, merry);

We zullen de Java8-mogelijkheden van AssertJ onderzoeken in een toekomstig artikel uit deze serie. De bovenstaande voorbeelden zijn afkomstig van de website van AssertJ.

7. Conclusie

In dit artikel hebben we kort de mogelijkheden onderzocht die AssertJ ons biedt, samen met de meest populaire beweringen voor kern Java-typen.

De implementatie van alle voorbeelden en codefragmenten is te vinden in een GitHub-project.

De volgende » AssertJ voor Guava