Mockito szigorú szúrás és a felesleges szúrás kivétel
1. Áttekintés
Ebben a gyors bemutatóban megismerhetjük a Mockitót FeleslegesStubbingException. Ez a kivétel az egyik leggyakoribb kivétel, amellyel valószínűleg találkozunk, ha a csonkokat helytelenül használjuk.
Kezdjük azzal, hogy elmagyarázzuk a szigorú csökönyösség filozófiáját és azt, hogy miért ösztönzi a Mockito alapértelmezés szerint a használatát. Ezután megvizsgáljuk, hogy pontosan mit jelent ez a kivétel, és milyen körülmények között fordulhat elő. Befejezésül látni fogunk egy példát arra, hogyan lehet ezt a kivételt elnyomni tesztjeink során.
Ha többet szeretne megtudni a Mockito teszteléséről, tekintse meg átfogó Mockito sorozatunkat.
2. Szigorú szúrás
A Mockito 1.x verziójával bármilyen korlátozás nélkül lehetett konfigurálni és interakcióba lépni azokkal. Ez azt jelentette, hogy az idő múlásával a tesztek gyakran túlbonyolultak és időnként nehezebben debugálhatók.
A 2. + verzió óta A Mockito olyan új funkciókat vezetett be, amelyek a „szigorúság” felé mozdítják el a keretet. A fő célok a következők:
- A fel nem használt csonkok észlelése a tesztkódban
- Csökkentse a tesztkód duplikációját és a szükséges tesztkódot
- Támogassa a tisztább teszteket a „halott” kód eltávolításával
- Javíthatja a hibakereshetőséget és a termelékenységet
Ezen elvek betartása segít tisztább tesztek létrehozásában a felesleges tesztkódok kiküszöbölésével. Ezenkívül segítenek elkerülni a másolás-beillesztés hibákat, valamint a fejlesztők egyéb hibáit.
Összefoglalva, a szigorúan elgondolkodtató felesleges jelentésekről számol be, észleli a pergő érvek eltérését, és tesztjeinket SZÁRAZABBAN (Ne ismételje meg). Ez megkönnyíti a tiszta és karbantartható kódbázist.
2.1. Szigorú csonkok konfigurálása
A Mockito 2. + óta alapértelmezés szerint szigorú csípést alkalmaznak, amikor inicializálják a gúnyainkat az alábbiak egyikével:
- MockitoJUnitRunner
- MockitoJUnit.rule ()
Mockito határozottan javasolja a fentiek bármelyikének alkalmazását. Van azonban egy másik módszer is a szigorú csökönyösítés engedélyezésére tesztjeink során, amikor nem a Mockito-szabályt vagy a futót használjuk:
Mockito.mockitoSession () .initMocks (this) .strictness (Strictness.STRICT_STUBS) .startMocking ();
Utolsó fontos megemlítendő, hogy a Mockito 3.0-ban az összes csonk "szigorú" lesz és alapértelmezés szerint érvényes lesz.
3. FeleslegesStubbingException Példa
Egyszerűen fogalmazva: a felesleges csonk egy elcsépelt metódushívás, amely soha nem valósult meg a teszt végrehajtása során.
Vessünk egy pillantást egy egyszerű példára:
@Test public void givenUnusedStub_whenInvokingGetThenThrowUnnecessaryStubbingException () {when (mockList.add ("one")). ThenReturn (true); // ezt nem hívják meg, amikor (mockList.get (anyInt ())). thenReturn ("hello"); assertEquals ("A listának tartalmaznia kell hello", "hello", mockList.get (1)); }
Amikor lefuttatjuk ezt az egységtesztet, a Mockito észleli a fel nem használt csonkot, és dob egy FeleslegesStubbingException:
org.mockito.exceptions.misusing.UnnecessaryStubbingException: Felesleges csonkokat észleltünk. A tiszta és karbantartható tesztkódnak nulla szükségtelen kódra van szüksége. A következő csonkolások feleslegesek (kattintson a megfelelő kódsorra történő navigáláshoz): 1. -> a com.baeldung.mockito.misusing.MockitoUnecessaryStubUnitTest.givenUnusedStub_whenInvokingGetThenThrowUnnecessaryStubbingException (MockitoUnecessaryStubUbientient Please use use 'remove' remove 'eltávolítás kérjük, távolítsa el. További információ: javadoc for UnnecessaryStubbingException osztály.
Szerencsére a hibaüzenetből egyértelműen kiderül, mi a probléma itt. Láthatjuk azt is, hogy a kivétel üzenet még a hibát okozó pontos vonalra is mutat.
Miért történik ez? Nos, az első mikor Az invokáció visszaállítja az álunkat igaz amikor felhívjuk a hozzá módszer az érveléssel "egy". Ezután azonban nem használjuk ezt a módszert az egységteszt többi végrehajtása során.
Mockito azt mondja nekünk, hogy az első mikor vonal felesleges, és talán hibát vétettünk a csonkjaink konfigurálásakor.
Bár ez a példa triviális, az objektumok összetett hierarchiáját csúfolva könnyen elképzelhető, hogy ez a fajta üzenet hogyan segítheti a hibakeresést és különben nagyon hasznos lehet.
4. A szigorú szúrás megkerülése
Végül nézzük meg, hogyan lehet megkerülni a szigorú csonkokat. Ezt más néven engedékeny csöppségnek is nevezik.
Néha úgy kell beállítanunk a konkrét csonkokat, hogy engedékenyek legyenek, miközben az összes többi csonkot és gúnyt fenntartjuk a szigorú csöppség alkalmazásához:
@Test public void givenLenientdStub_whenInvokingGetThenThrowUnnecessaryStubbingException () {engedékeny (). Mikor (mockList.add ("egy")). ThenReturn (true); mikor (mockList.get (anyInt ())). thenReturn ("hello"); assertEquals ("A listának tartalmaznia kell hello", "hello", mockList.get (1)); }
A fenti példában a statikus módszert alkalmazzuk Mockito.lenient () hogy lehetővé tegye a hozzá próbalistánk módszere.
Az engedékeny csonkok megkerülik a „szigorú csökönyös” érvényesítési szabályokat. Például, ha a csonkolást engedékenynek nyilvánítják, akkor azt nem ellenőrzik potenciális csonkolási problémákra, mint például a korábban leírt felesleges csípésre.
5. Következtetés
Ebben a rövid cikkben azzal kezdtük, hogy bevezettük a szigorú csökönyösség fogalmát Mockitóban, és megértettük azt a filozófiát, amely mögött miért vezették be és miért fontos.
Ezután megnéztük a FeleslegesStubbingException mielőtt befejeznék egy példát arra, hogyan lehet engedélyezni az engedékeny elcsépelést tesztjeink során.
Mint mindig, a cikk teljes forráskódja elérhető a GitHubon.