Tesztelés Hamcrest-szel

1. Áttekintés

Hamcrest a jól ismert keretrendszer, amelyet az egység tesztelésére használnak a Java ökoszisztémában. A JUnit csomagban van, és egyszerűen fogalmazva, meglévő predikátumokat - úgynevezett matcher osztályokat - használ állításokhoz.

Ebben az oktatóanyagban megtesszük fedezze fel a Hamcrest API-t és megtanulják, hogyan kell kihasználni, hogy szoftverünkhöz könnyebb és intuitívabb egységteszteket írjunk.

2. Hamcrest Setup

Tudjuk használni Hamcrest maven-el a következő függőség hozzáadásával pom.xml fájl:

 org.hamcrest hamcrest-all 1.3 

A könyvtár legújabb verziója mindig itt található.

3. Példa teszt

Hamcrest általánosan használják junit és más tesztelési keretrendszerek állításokhoz. Pontosabban, a használat helyett junit’S sok állítják módszerek, csak az API-t használjuk állítsa azt nyilatkozat megfelelő mérkőzésekkel.

Nézzünk meg egy példát, amely kettőt tesztel Húrs az egyenlőség érdekében, esetektől függetlenül. Ennek világos képet kell adnunk arról, hogyan Hamcrest illeszkedik egy tesztelési módszerhez:

public class StringMatcherTest {@Test public void given2Strings_whenEqual_thenCorrect () {String a = "foo"; B karakterlánc = "FOO"; assertThat (a, egyenlőToIgnoringCase (b)); }}

A következő szakaszokban megnézünk több más közös mérkőzést Hamcrest ajánlatok.

4. A Tárgy Matcher

Hamcrest párosítókat állít tetszőleges Java objektumokon.

Azt állítani, hogy a Sztring módszer egy Tárgy megadott értéket ad vissza Húr:

@Test public void givenBean_whenToStringReturnsRequiredString_thenCorrect () {Person person = new Person ("Barrack", "Washington"); Karakterlánc str = person.toString (); assertThat (személy, hasToString (str)); }

Azt is ellenőrizhetjük, hogy az egyik osztály a másik alkategóriája:

@Test public void given2Classes_whenOneInheritsFromOther_thenCorrect () {assertThat (Cat.class, typeCompatibleWith (Animal.class)); }}

5. A babillesztõ

Tudjuk használni HamcrestBean matcher a Java bab tulajdonságainak ellenőrzésére.

Tegyük fel a következőket Személy bab:

public class Személy {String név; Karakterlánc cím; public Person (karakterlánc személynév, karakterlánc személycím) {név = személyNév; cím = személycím; }}

Ellenőrizhetjük, hogy a babnak van-e tulajdona, név így:

@Test public void givenBean_whenHasValue_thenCorrect () {Személy személy = új Személy ("Baeldung", 25); assertThat (személy, hasProperty ("név")); }

Azt is ellenőrizhetjük, hogy Személy rendelkezik a cím New Yorkba inicializált ingatlan:

@Test public void givenBean_whenHasCorrectValue_thenCorrect () {Személy = új Személy ("Baeldung", "New York"); assertThat (személy, hasProperty ("cím", equalTo ("New York"))); }

Azt is ellenőrizhetjük, hogy kettő van-e Személy az objektumok ugyanazokkal az értékekkel készülnek:

@Test public void given2Beans_whenHavingSameValues_thenCorrect () {Személy személy1 = új Személy ("Baeldung", "New York"); Személy személy2 = új Személy ("Baeldung", "New York"); assertThat (személy1, ugyanazTulajdonságértékekAs (személy2)); } 

6. A Gyűjtemény Matcher

Hamcrest biztosítja a párosokat az ellenőrzéshez Gyűjteménys.

Egyszerű ellenőrzéssel megtudhatja, hogy a Gyűjtemény üres:

@Test public void givenCollection_whenEmpty_thenCorrect () {List emptyList = new ArrayList (); assertThat (emptyList, empty ()); }

A méretének ellenőrzéséhez Gyűjtemény:

@Test public void givenAList_whenChecksSize_thenCorrect () {List hamcrestMatchers = Arrays.asList ("gyűjtemények", "bab", "szöveg", "szám"); assertThat (hamcrestMatchers, hasSize (4)); }

Azt is használhatjuk, hogy állítsuk, hogy egy tömbnek van egy előírt mérete:

@Test public void givenArray_whenChecksSize_thenCorrect () {String [] hamcrestMatchers = {"gyűjtemények", "bab", "szöveg", "szám"}; assertThat (hamcrestMatchers, arrayWithSize (4)); }

Annak ellenőrzésére, hogy a Gyűjtemény adott tagokat tartalmaz, sorrendtől függetlenül:

@Test public void givenAListAndValues_whenChecksListForGivenValues_thenCorrect () {List hamcrestMatchers = Arrays.asList ("gyűjtemények", "bab", "szöveg", "szám"); assertThat (hamcrestMatchers, tartalmazzaInAnyOrder ("bab", "szöveg", "gyűjtemények", "szám"); }

Tovább állítva, hogy a Gyűjtemény tagok sorrendben:

@Test public void givenAListAndValues_whenChecksListForGivenValuesWithOrder_thenCorrect () {List hamcrestMatchers = Arrays.asList ("gyűjtemények", "bab", "szöveg", "szám"); assertThat (hamcrestMatchers, tartalmazza ("gyűjtemények", "bab", "szöveg", "szám")); }

Annak ellenőrzése, hogy egy tömbnek van-e egyetlen adott eleme:

@Test public void givenArrayAndValue_whenValueFoundInArray_thenCorrect () {String [] hamcrestMatchers = {"gyűjtemények", "bab", "szöveg", "szám"}; assertThat (hamcrestMatchers, hasItemInArray ("szöveg")); }

Alternatív illesztőt is használhatunk ugyanahhoz a teszthez:

@Test public void givenValueAndArray_whenValueIsOneOfArrayElements_thenCorrect () {String [] hamcrestMatchers = {"gyűjtemények", "bab", "szöveg", "szám"}; assertThat ("szöveg", isOneOf (hamcrestMatchers)); }

Vagy mégis megtehetjük ugyanezt egy másik mérkőzéssel, így:

@Test public void givenValueAndArray_whenValueFoundInArray_thenCorrect () {String [] array = new String [] {"gyűjtemények", "bab", "szöveg", "szám"}; assertThat ("bab", isIn (tömb)); }

Azt is ellenőrizhetjük, hogy a tömb sorrendtől függetlenül tartalmaz-e adott elemeket:

@Test public void givenArrayAndValues_whenValuesFoundInArray_thenCorrect () {String [] hamcrestMatchers = {"gyűjtemények", "bab", "szöveg", "szám"}; assertThat (hamcrestMatchers, arrayContainingInAnyOrder ("bab", "gyűjtemények", "szám", "szöveg")); }

Annak ellenőrzéséhez, hogy a tömb tartalmaz-e megadott elemeket, de a megadott sorrendben:

@Test public void givenArrayAndValues_whenValuesFoundInArrayInOrder_thenCorrect () {String [] hamcrestMatchers = {"gyűjtemények", "bab", "szöveg", "szám"}; assertThat (hamcrestMatchers, arrayContaining ("gyűjtemények", "bab", "szöveg", "szám"); }

Amikor a mi Gyűjtemény egy Térkép, a következő illesztőket használhatjuk ezekben a funkciókban:

Annak ellenőrzése, hogy tartalmaz-e egy adott kulcsot:

@Test public void givenMapAndKey_whenKeyFoundInMap_thenCorrect () {Map map = new HashMap (); map.put ("blognév", "baeldung"); assertThat (térkép, hasKey ("blognév")); }

és egy adott érték:

@Test public void givenMapAndValue_whenValueFoundInMap_thenCorrect () {Map map = new HashMap (); map.put ("blognév", "baeldung"); assertThat (térkép, hasValue ("baeldung")); }

végül egy adott bejegyzés (kulcs, érték):

@Test public void givenMapAndEntry_whenEntryFoundInMap_thenCorrect () {Map map = new HashMap (); map.put ("blognév", "baeldung"); assertThat (térkép, hasEntry ("blognév", "baeldung")); }

7. Az Szám Matcher

A Szám illesztőket használnak állítások elvégzésére a Szám osztály.

Ellenőrizni nagyobb, mint feltétel:

@Test public void givenAnInteger_whenGreaterThan0_thenCorrect () {assertThat (1, nagyobbThan (0)); }

Ellenőrizni nagyobb, mint vagy egyenlő feltétel:

@Test public void givenAnInteger_whenGreaterThanOrEqTo5_thenCorrect () {assertThat (5, nagyobbThanOrEqualTo (5)); }

Ellenőrizni kevesebb, mint feltétel:

@Test public void givenAnInteger_whenLessThan0_thenCorrect () {assertThat (-1, lessThan (0)); }

Ellenőrizni kevesebb, mint vagy egyenlő feltétel:

@Test public void givenAnInteger_whenLessThanOrEqTo5_thenCorrect () {assertThat (-1, lessThanOrEqualTo (5)); }

Ellenőrizni közel feltétel:

@Test public void givenADouble_whenCloseTo_thenCorrect () {assertThat (1.2, closeTo (1, 0.5)); }

Figyeljünk nagyon az utolsó párosra, közel. Az első argumentum, az operandus az, amelyhez a célt hasonlítják, a második argumentum pedig az operandtól való megengedett eltérés . Ez azt jelenti, hogy ha a cél operandus + eltérés vagy operandus-eltérés, akkor a teszt sikeres lesz.

8. A szövegillesztõ

Állítás tovább Húrs könnyebbé, könnyebbé és intuitívabbá válik Hamcrest’S szövegillesztők. Ebben a részben meg fogjuk nézni őket.

Annak ellenőrzésére, hogy a Húr üres:

@Test public void givenString_whenEmpty_thenCorrect () {String str = ""; assertThat (str, isEmptyString ()); }

Annak ellenőrzésére, hogy a Húr üres vagy nulla:

@Test public void givenString_whenEmptyOrNull_thenCorrect () {String str = null; assertThat (str, isEmptyOrNullString ()); }

Kettő egyenlőségének ellenőrzése Húrs a szóköz figyelmen kívül hagyásával:

@Test public void given2Strings_whenEqualRegardlessWhiteSpace_thenCorrect () {String str1 = "text"; String str2 = "szöveg"; assertThat (str1, egyenlőToIgnoringWhiteSpace (str2)); }

Ellenőrizhetjük egy vagy több részhúr jelenlétét is egy adott esetben Húr adott sorrendben:

@Test public void givenString_whenContainsGivenSubstring_thenCorrect () {String str = "kalligráfia"; assertThat (str, stringContainsInOrder (Arrays.asList ("call", "graph"))); }

Végül ellenőrizhetjük a kettő egyenlőségét Húrs esettől függetlenül:

@Test public void given2Strings_whenEqual_thenCorrect () {String a = "foo"; B karakterlánc = "FOO"; assertThat (a, egyenlőToIgnoringCase (b)); }

9. A Core API

A Hamcrest core API-t harmadik fél keretrendszer-szolgáltatóinak kell használniuk. Mindazonáltal remek konstrukciókat kínál számunkra, hogy egységeink tesztjeit olvashatóbbá tegyük, és néhány alapvető illesztőt is, amelyek ugyanolyan egyszerűen használhatók.

Olvashatóság a van konstrukció egy párosra:

@Test public void given2Strings_whenIsEqualRegardlessWhiteSpace_thenCorrect () {String str1 = "text"; String str2 = "szöveg"; assertThat (str1, is (egyenlőToIgnoringWhiteSpace (str2))); }

A van egyszerű adattípusra épít:

@Test public void given2Strings_whenIsEqual_thenCorrect () {String str1 = "text"; String str2 = "szöveg"; assertThat (str1, is (str2)); }

Negáció a nem konstrukció egy párosra:

@Test public void given2Strings_whenIsNotEqualRegardlessWhiteSpace_thenCorrect () {String str1 = "text"; String str2 = "szövegek"; assertThat (str1, nem (equalToIgnoringWhiteSpace (str2))); }

A nem szerkeszteni egy egyszerű adattípuson:

@Test public void given2Strings_whenNotEqual_thenCorrect () {String str1 = "text"; String str2 = "szövegek"; assertThat (str1, nem (str2)); }

Ellenőrizze, hogy a Húr egy adott részláncot tartalmaz:

@Test public void givenAStrings_whenContainsAnotherGivenString_thenCorrect () {String str1 = "kalligráfia"; String str2 = "hívás"; assertThat (str1, tartalmazzaString (str2)); }

Ellenőrizze, hogy a Húr adott al-karakterlánccal kezdődik:

@Test public void givenAString_whenStartsWithAnotherGivenString_thenCorrect () {String str1 = "kalligráfia"; String str2 = "hívás"; assertThat (str1, startWith (str2)); }

Ellenőrizze, hogy a Húr adott al-karakterlánccal végződik:

@Test public void givenAString_whenEndsWithAnotherGivenString_thenCorrect () {String str1 = "kalligráfia"; Karakterlánc str2 = "phy"; assertThat (str1, endWith (str2)); }

Ellenőrizze, hogy kettő van-e Tárgys ugyanabban a példányban vannak:

@Test public void given2Objects_whenSameInstance_thenCorrect () {Cat cat = new Cat (); assertThat (macska, ugyanaz az ügy (macska)); }

Ellenőrizze, hogy van-e Tárgy egy adott osztály példánya:

@Test public void givenAnObject_whenInstanceOfGivenClass_thenCorrect () {Cat cat = new Cat (); assertThat (macska, instanceOf (Kat.osztály)); }

Ellenőrizze, hogy a Gyűjtemény teljesít egy feltételt:

@Test public void givenList_whenEachElementGreaterThan0_thenCorrect () {List list = Arrays.asList (1, 2, 3); int baseCase = 0; assertThat (list, everyItem (nagyobbThan (baseCase))); }

Ellenőrizze, hogy a Húr nem nulla:

@Test public void givenString_whenNotNull_thenCorrect () {String str = "notnull"; assertThat (str, notNullValue ()); }

Láncfeltételek együtt, teszt sikeres, ha a cél megfelel a logikai VAGY-hoz hasonló feltételek bármelyikének:

@Test public void givenString_whenMeetsAnyOfGivenConditions_thenCorrect () {String str = "kalligráfia"; Karakterlánc kezdete = "hívás"; Karakterlánc vége = "foo"; assertThat (str, anyOf (startsWith (start), tartalmazzaString (end))); }

Láncfeltételek együtt, a teszt csak akkor felel meg, ha a cél megfelel minden feltételnek, hasonlóan a logikai AND-hoz:

@Test public void givenString_whenMeetsAllOfGivenConditions_thenCorrect () {String str = "kalligráfia"; Karakterlánc kezdete = "hívás"; Karakterlánc vége = "phy"; assertThat (str, allOf (startWith (start), endWith (end))); }

10. Egyéni mérkőzés

Kiterjesztéssel meghatározhatjuk saját párosunkat TypeSafeMatcher. Ebben a szakaszban létrehozunk egy egyedi illesztőt, amely csak akkor engedi át a tesztet, ha a cél pozitív egész szám.

public class IsPositiveInteger kiterjeszti a TypeSafeMatcher {public void descriptionTo (Leírás leírása) {description.appendText ("pozitív egész szám"); } @Factory public static Matcher isAPositiveInteger () {return new IsPositiveInteger (); } @Orride védett logikai egyezésekSafely (Egész egész szám) {return egész szám> 0; }}

Csak a matchSafely módszer, amely ellenőrzi, hogy a cél valóban pozitív egész szám, és a írja le módszer, amely hibaüzenetet állít elő abban az esetben, ha a teszt nem felel meg.

Itt van egy teszt, amely az új egyedi egyeztetőnket használja:

@Test public void givenInteger_whenAPositiveValue_thenCorrect () {int num = 1; assertThat (szám, isAPositiveInteger ()); }

és itt van egy hibaüzenet, amelyet kaptunk, mivel nem pozitív egész számot adtunk át:

java.lang.AssertionError: Várható: pozitív egész szám, de: volt 

11. Következtetés

Ebben az oktatóanyagban van felfedezte a Hamcrest API-t és megtanulta, hogyan írhatunk vele jobb és karbantarthatóbb egységteszteket.

Ezen példák és kódrészletek teljes megvalósítása megtalálható a hamcresti github projektemben.


$config[zx-auto] not found$config[zx-overlay] not found