Tesztelés a Google Truth segítségével
1. Áttekintés
Igazság egy gördülékeny és rugalmas nyílt forráskódú tesztelési keretrendszer, amelynek célja a teszt állítások és a hibaüzenetek olvashatóbbá tétele.
Ebben a cikkben megvizsgáljuk a Igazság keretet és megvalósítson példákat képességeinek bemutatására.
2. Maven-függőségek
Először hozzá kell adnunk a igazság és igazság-java8-kiterjesztés a miénknek pom.xml:
com.google.truth truth 0.32 com.google.truth.extensions truth-java8-extension 0.32 test Az igazság és az igazság-java8-kiterjesztés legújabb verzióit megtalálhatja a Maven Central oldalon.
3. Bevezetés
Igazság lehetővé teszi számunkra, hogy olvasható állításokat és hibaüzeneteket írjunk különféle osztályokhoz:
- Normál Java - primitívek, tömbök, húrok, tárgyak, gyűjtemények, dobható tárgyak, osztályok stb.
- Java 8 – Választható és Folyam példányok
- Gujávafa – Választható, Multimap, Multiset, és asztal tárgyakat
- Egyéni típusok - a Tantárgy osztály, mint később meglátjuk
Keresztül Igazság és Igazság8 osztályokban a könyvtár hasznos módszereket biztosít az állítások megírásához, amelyek a tantárgy, ez a tesztelt érték vagy objektum.
Amint a téma ismert, Igazság összeállítási időpontban meg tudja indokolni, hogy milyen javaslatok ismertek az adott témáról. Ez lehetővé teszi számunkra az értékünk körüli burkolatok visszavezetését, amelyek az adott témára jellemző javaslattételi módszereket deklarálják.
Például, ha egy listán állít, Igazság visszatér egy IterableSubject Például meghatározó módszerek, mint például tartalmaz () és tartalmazzaAnyOf ()többek között. Amikor azt állítja a Térkép, akkor a MapSubject hogy olyan módszereket deklarál, mint tartalmazzaEntry () és tartalmazzaKey ().
4. Az első lépések
Az állítások megkezdéséhez először importáljuk IgazságBelépési pontjai:
importálja a statikus com.google.common.truth.Truth. *; importálja a statikus com.google.common.truth.Truth8. *;Most írjunk egy egyszerű osztályt, amelyet a következő néhány példában felhasználunk:
public class Felhasználó {private String name = "John Doe"; privát lista e-mailek = Arrays.asList ("[email protected]", "[email protected]"); public boolean egyenlő (Object obj) {if (obj == null || getClass ()! = obj.getClass ()) {return false; } Felhasználó egyéb = (Felhasználó) obj; return Objects.equals (ez.név, egyéb.név); } // szabványos kivitelezők, mérőeszközök és beállítók}Figyelje meg a szokást egyenlő () módszer, amelyben kijelentjük, hogy kettő Felhasználó az objektumok egyenlőek, ha a nevük azonos.
5. Standard Java állítások
Ebben a szakaszban részletes példákat láthatunk arról, hogyan írhatunk teszt állításokat a standard Java típusokhoz.
5.1. Tárgy Állítások
Igazság biztosítja a Tantárgy burkoló állításokkal kapcsolatos állítások végrehajtására. Tantárgy a könyvtár összes többi burkolójának a szülője, és deklarálja a annak meghatározására szolgáló módszereket Tárgy, esetünkben a Felhasználó, egyenlő egy másik objektummal:
@Test public void whenComparingUsers_thenEqual () {User aUser = new User ("John Doe"); Felhasználó anotherUser = új felhasználó ("John Doe"); assertThat (aUser) .isEqualTo (anotherUser); }vagy ha megegyezik egy adott lista objektumával:
@Test public void whenComparingUser_thenInList () {User aUser = new User (); assertThat (aUser) .isIn (Arrays.asList (1, 3, aUser, null)); }vagy ha nem:
@Test public void whenComparingUser_thenNotInList () {// ... assertThat (aUser) .isNotIn (Arrays.asList (1, 3, "Három")); }ha ez null vagy sem:
@Test public void whenComparingUser_thenIsNull () {User aUser = null; assertThat (aUser) .isNull (); } @Test public void whenComparingUser_thenNotNull () {User aUser = new User (); assertThat (aUser) .isNotNull (); }vagy ha egy adott osztály példánya:
@Test public void whenComparingUser_thenInstanceOf () {// ... assertThat (aUser) .isInstanceOf (User.class); }Vannak más állítási módszerek a Tantárgy osztály. Mindegyikük felfedezéséhez olvassa el a Tantárgy dokumentáció.
A következő szakaszokban: az egyes típusok legrelevánsabb módszereire fogunk összpontosítaniIgazság támogatja. Ne feledje azonban, hogy a Tantárgy osztály is alkalmazható.
5.2. Egész szám, Úszó, és Kettős Állítások
Egész szám, Úszó, és Kettős példányok összehasonlíthatók az egyenlőség szempontjából:
@Test public void whenComparingInteger_thenEqual () {int anInt = 10; assertThat (anInt) .isEqualTo (10); }ha nagyobbak:
@Test public void whenComparingFloat_thenIsBigger () {float aFloat = 10.0f; assertThat (aFloat) .isGreaterThan (1.0f); }vagy kisebb:
@Test public void whenComparingDouble_thenIsSmaller () {double aDouble = 10.0f; assertThat (aDouble) .isLessThan (20.0); }Továbbá, Úszó és Kettős a példányokat is ellenőrizni lehet, hogy a várt pontosságon belül vannak-e vagy sem:
@Test public void whenComparingDouble_thenWithinPrecision () {double aDouble = 22.18; assertThat (aDouble) .isWithin (2) .of (23d); } @Test public void whenComparingFloat_thenNotWithinPrecision () {float aFloat = 23.04f; assertThat (aFloat) .isNotWithin (1,3f) .of (100f); }5.3. BigDecimal Állítások
A gyakori állítások mellett ez a típus összehasonlítható a skála figyelmen kívül hagyásával:
@Test public void whenComparingBigDecimal_thenEqualIgnoringScale () {BigDecimal aBigDecimal = BigDecimal.valueOf (1000, 3); assertThat (aBigDecimal) .isEqualToIgnoringScale (új BigDecimal (1.0)); }5.4. Logikai Állítások
Csak két releváns módszer szerepel, igaz() és isFalse ():
@Test public void whenCheckingBoolean_thenTrue () {logikai aBoolean = true; assertThat (aBoolean) .isTrue (); }5.5. Húr Állítások
Kipróbálhatjuk, hogy a Húr egy adott szöveggel kezdődik:
@Test public void whenCheckingString_thenStartsWith () {String aString = "Ez egy karakterlánc"; assertThat (aString) .startsWith ("Ez"); }Ezen felül ellenőrizhetjük, hogy a karakterlánc tartalmaz-e egy adott karakterláncot, várt értékkel végződik-e, vagy üres-e. Ezek és más módszerek tesztesetei elérhetők a forráskódban.
5.6. Tömb állítások
Ellenőrizhetjük Sors hogy megegyezzenek-e más tömbökkel:
@Test public void whenComparingArrays_thenEqual () {String [] firstArrayOfStrings = {"egy", "kettő", "három"}; String [] secondArrayOfStrings = {"egy", "kettő", "három"}; assertThat (firstArrayOfStrings) .isEqualTo (secondArrayOfStrings); }vagy ha üresek:
@Test public void whenCheckingArray_thenEmpty () {Object [] anArray = {}; assertThat (anArray) .isEmpty (); }5.7. Hasonló Állítások
A tesztelés mellett, hogy a Hasonló nagyobb vagy kevesebb, mint egy másik példány, ellenőrizhetjük, hogy ezek legalább egy adott értéket tartalmaznak-e:
@Test public void whenCheckingComparable_thenAtLeast () {Összehasonlítható aComparable = 5; assertThat (összehasonlítható) .isAtLeast (1); }Azt is tesztelhetjük, hogy egy adott tartományba esnek-e:
@Test public void whenCheckingComparable_thenInRange () {// ... assertThat (aComparable) .isIn (Range.closed (1, 10)); }vagy egy adott listában:
@Test public void whenCheckingComparable_thenInList () {// ... assertThat (aComparable) .isIn (Arrays.asList (4, 5, 6)); }Azt is tesztelhetjük, hogy kettő Hasonló példányok egyenértékűek az osztályok szerint összehasonlítani() módszer.
Először módosítsuk Felhasználó osztály a Hasonló felület:
public class Felhasználó megvalósítja a Comparable {// ... public int CompareTo (User o) {return this.getName (). CompareToIgnoreCase (o.getName ()); }}Tegyük fel, hogy két azonos nevű felhasználó egyenértékű:
@Test public void whenComparingUsers_thenEquivalent () {User aUser = new User (); aUser.setName ("John Doe"); Felhasználó anotherUser = új felhasználó (); anotherUser.setName ("john doe"); assertThat (aUser) .isEquivalentAccordingToCompareTo (anotherUser); }5.8. Iterálható Állítások
Az an méretének állításán túl Iterálható Például, függetlenül attól, hogy üres-e, vagy nincsenek-e másolatai, a legjellemzőbb állítások az Iterálható vannak-e olyan elemei:
@Test public void whenCheckingIterable_thenContains () {List aList = Arrays.asList (4, 5, 6); assertThat (aList). tartalmaz (5); }hogy a másik bármely elemét tartalmazza Iterálható:
@Test public void whenCheckingIterable_thenContainsAnyInList () {List aList = Arrays.asList (1, 2, 3); assertThat (aList) .containsAnyIn (Arrays.asList (1, 5, 10)); }és hogy az alany ugyanazokkal az elemekkel rendelkezik, ugyanabban a sorrendben, mint egy másik:
@Test public void whenCheckingIterable_thenContainsExactElements () {List aList = Arrays.asList ("10", "20", "30"); Soroljon fel egy másik listát = tömbök. AsList ("10", "20", "30"); assertThat (aList) .containExactlyElementsIn (anotherList) .inOrder (); }és ha egyedi összehasonlítóval rendelték meg:
@Test public void givenComparator_whenCheckingIterable_thenOrdered () {Comparator aComparator = (a, b) -> new Float (a) .compareTo (new Float (b)); List aList = Arrays.asList ("1", "012", "0020", "100"); assertThat (aList) .isRendelt (aComparator); }5.9. Térkép Állítások
Amellett, hogy állítja, hogy a Térkép a példány üres vagy nem, vagy meghatározott méretű; ellenőrizhetjük, hogy van-e konkrét bejegyzése:
@Test public void whenCheckingMap_thenContainsEntry () {Map aMap = new HashMap (); aMap.put ("egy", 1 L); assertThat (aMap) .containsEntry ("egy", 1L); }ha van egy speciális kulcsa:
@Test public void whenCheckingMap_thenContainsKey () {// ... assertThat (térkép) .containsKey ("one"); }vagy ha ugyanazok vannak a bejegyzések, mint egy másik Térkép:
@Test public void whenCheckingMap_thenContainsEntries () {Map aMap = new HashMap (); aMap.put ("első", 1L); aMap.put ("második", 2.0); aMap.put ("harmadik", 3f); Map anotherMap = új HashMap (aMap); assertThat (aMap) .containsExactlyEntriesIn (anotherMap); }5.10. Kivétel Állítások
Csak két fontos módszerről van szó Kivétel tárgyakat.
Írhatunk állításokat a kivétel okához:
@Test public void whenCheckingException_thenInstanceOf () {Exception anException = new IllegalArgumentException (new NumberFormatException ()); assertThat (anException) .hasCauseThat () .isInstanceOf (NumberFormatException.class); }vagy annak üzenetére:
@Test public void whenCheckingException_thenCauseMessageIsKnown () {Exception anException = new IllegalArgumentException ("Bad value"); assertThat (anException) .hasMessageThat () .startsWith ("Rossz"); }5.11. Osztály Állítások
Csak egy fontos módszer létezik Osztály állítások, amelyekkel tesztelhetjük, hogy egy osztály hozzárendelhető-e egy másikhoz:
@Test public void whenCheckingClass_thenIsAssignable () {Class aClass = Double.class; assertThat (aClass) .isAssignableTo (Szám.osztály); }6. Java 8 állítások
Választható és Folyam az egyetlen két Java 8 típus, amelyek Igazság támogatja.
6.1. Választható Állítások
Három fontos módszer létezik az Választható.
Megvizsgálhatjuk, hogy van-e egy adott értéke:
@Test public void whenCheckingJavaOptional_thenHasValue () {Opcionális anOptional = Opcionális.of (1); assertThat (anOptional) .hasValue (1); }ha az érték jelen van:
@Test public void whenCheckingJavaOptional_thenPresent () {Opcionális anOptional = Opcionális.of ("Baeldung"); assertThat (anOptional) .isPresent (); }vagy ha az érték nincs megadva:
@Test public void whenCheckingJavaOptional_thenEmpty () {Opcionális anOptional = Opcionális.empty (); assertThat (anOptional) .isEmpty (); }6.2. Folyam Állítások
Állítások a Folyam nagyon hasonlítanak az an Iterálható.
Például tesztelhetjük, hogy egy adott Folyam az összes objektumát tartalmazza Iterálható ugyanabban a sorrendben:
@Test public void whenCheckingStream_thenContainsInOrder () {Stream anStream = Stream.of (1, 2, 3); assertThat (anStream) .containAllOf (1, 2, 3) .inOrder (); }További példákat a Iterálható Állítások szakasz.
7. Guava állítások
Ebben a szakaszban a támogatott guava-típusokra vonatkozó állításokat fogunk látni Igazság.
7.1. Választható Állítások
Három fontos állítási módszer is létezik egy guava esetében Választható. A hasValue () és jelen van() A módszerek pontosan úgy viselkednek, mint egy Java 8 esetén Választható.
De ahelyett üres() állítani, hogy egy Választható nincs jelen, használjuk isAbsent ():
@Test public void whenCheckingGuavaOptional_thenIsAbsent () {Opcionális anOptional = Opcionális.absent (); assertThat (opcionális) .isAbsent (); }7.2. Multimap Állítások
Multimap és szabványos Térkép állítások nagyon hasonlóak.
Az egyik figyelemre méltó különbség az, hogy a kulcson belül több kulcsot is meg tudunk szerezni Multimap és tegyen állításokat azokról az értékekről.
Íme egy példa, amely teszteli, hogy az „egy” kulcs értéke kettő-e:
@Test public void whenCheckingGuavaMultimap_thenExpectedSize () {Multimap aMultimap = ArrayListMultimap.create (); aMultimap.put ("egy", 1 L); aMultimap.put ("egy", 2.0); assertThat (aMultimap) .valuesForKey ("egy") .hasSize (2); }További példákat a Térkép Állítások szakasz.
7.3. Multiset Állítások
Állítások a Multiset az objektumok közé tartoznak az Iterálható és egy extra módszer annak ellenőrzésére, hogy egy kulcsnak van-e meghatározott számú előfordulása:
@Test public void whenCheckingGuavaMultiset_thenExpectedCount () {TreeMultiset aMultiset = TreeMultiset.create (); aMultiset.add ("baeldung", 10); assertThat (aMultiset) .hasCount ("baeldung", 10); }7.4. asztal Állítások
Amellett, hogy ellenőrizzük a méretét vagy azt, hogy hol üres, ellenőrizhetjük a asztal annak ellenőrzése, hogy tartalmaz-e egy adott leképezést egy adott sorhoz és oszlophoz:
@Test public void whenCheckingGuavaTable_thenContains () {Table aTable = TreeBasedTable.create (); aTable.put ("firstRow", "firstColumn", "baeldung"); assertThat (aTable) .contains ("firstRow", "firstColumn"); }vagy ha egy adott cellát tartalmaz:
@Test public void whenCheckingGuavaTable_thenContainsCell () {Table aTable = getDummyGuavaTable (); assertThat (aTable) .containsCell ("firstRow", "firstColumn", "baeldung"); }Továbbá ellenőrizhetjük, hogy tartalmaz-e egy adott sort, oszlopot vagy értéket. A vonatkozó tesztesetekhez lásd a forráskódot.
8. Egyedi hibaüzenetek és címkék
Ha egy állítás sikertelen, Igazság nagyon olvasható üzeneteket jelenít meg, amelyek pontosan azt jelzik, ami elromlott. Néha azonban további információkra van szükség ezekhez az üzenetekhez, hogy további részleteket nyújtsanak a történtekről.
Igazság lehetővé teszi számunkra a hibaüzenetek testreszabását:
@Test public void whenFailingAssertion_thenCustomMessage () {assertWithMessage ("TEST-985: A titkos felhasználói alany NEM volt null!") .That (új Felhasználó ()) .isNull (); }A teszt futtatása után a következő kimenetet kapjuk:
TESZT-985: A titkos felhasználói alany NEM volt null !: Nem igaz, hogy az [[email protected]> értéke nullHozzáadhatunk egy egyedi címkét is, amely hibaüzenetekben jelenik meg a témánk előtt. Ez hasznos lehet, ha egy objektumnak nincs hasznos karakterlánc-reprezentációja:
@Test public void whenFailingAssertion_thenMessagePrefix () {User aUser = new User (); assertThat (aUser) .named ("Felhasználó [% s]", aUser.getName ()) .isNull (); }Ha lefuttatjuk a tesztet, a következő kimenetet láthatjuk:
Nem igaz, hogy a [John Doe] (<[email protected]>) felhasználó null9. Bővítések
Kiterjedő Igazság azt jelenti, hogy hozzáadhatunk támogatást az egyedi típusokhoz. Ehhez létre kell hoznunk egy osztályt, amely:
- kiterjeszti a Tantárgy osztály vagy annak egyik alosztálya
- definiál egy konstruktort, amely elfogad két érvet - a FailureStrategy és az egyedi típusú példányunk
- deklarál egy mezőt SubjectFactory típus, amely Igazság felhasználja egyedi témánk példányainak létrehozására
- statikát valósít meg assertThat () módszer, amely elfogadja az egyedi típusunkat
- bemutatja a teszt állítás API-t
Most, hogy tudjuk, hogyan kell meghosszabbítani Igazság, hozzunk létre egy osztályt, amely támogatja a típusú objektumok támogatását Felhasználó:
public class UserSubject kiterjeszti a ComparableSubject {private UserSubject (FailureStrategy FailStrategy, User target) {super (FailStrategy, target); } private static final SubjectFactory USER_SUBJECT_FACTORY = new SubjectFactory () {public UserSubject getSubject (FailureStrategy FailStrategy, Felhasználói cél) {return new UserSubject (FailStrategy, target); }}; public static UserSubject assertThat (User user) {return Truth.assertAbout (USER_SUBJECT_FACTORY). that (felhasználó); } public void hasName (Karakterlánc neve) {if (! tényleges (). getName (). egyenlő (név)) {fail ("van neve", neve); }} public void hasNameIgnoringCase (Karakterlánc neve) {if (! actual (). getName (). equalsIgnoreCase (név)) {fail ("van neve figyelmen kívül hagyva esetet", név); }} public IterableSubject e-mailek () {return Truth.assertThat (tényleges (). getEmails ()); }}Most statikusan importálhatjuk a assertThat () módszerünk, és írjon néhány tesztet:
@Test public void whenCheckingUser_thenHasName () {User aUser = new User (); assertThat (aUser) .hasName ("John Doe"); } @Test public void whenCheckingUser_thenHasNameIgnoringCase () {// ... assertThat (aUser) .hasNameIgnoringCase ("john doe"); } @Test public void givenUser_whenCheckingEmails_thenExpectedSize () {// ... assertThat (aUser) .emails () .hasSize (2); }10. Következtetés
Ebben az oktatóanyagban feltártuk a lehetőségeket Igazság így olvashatóbb teszteket és hibaüzeneteket írhatunk.
Bemutattuk a legnépszerűbb állítási módszereket a támogatott Java és Guava típusokhoz, testreszabott hibaüzeneteket és kiterjesztést Igazság egyéni tantárgyakkal.
Mint mindig, a cikk teljes forráskódja megtalálható a Github oldalon.
