Bevezetés a PowerMock-ba
1. Áttekintés
A gúnyos keretrendszer segítségével végzett egységtesztelést már régóta hasznos gyakorlatnak ismerik el, és különösen a Mockito keretrendszer uralta ezt a piacot az elmúlt években.
A tisztességes kódtervezés megkönnyítése és a nyilvános API egyszerűsítése érdekében szándékosan kihagytak néhány kívánt funkciót. Bizonyos esetekben ezek a hiányosságok arra kényszerítik a tesztelőket, hogy nehézkes kódot írjanak csak azért, hogy a gúnyok létrehozása megvalósítható legyen.
Itt jelenik meg a PowerMock keretrendszer.
PowerMockito egy PowerMock kiterjesztésű API a Mockito támogatásához. Képességeket biztosít a Java Reflection API-val való együttműködéshez, egyszerű módon leküzdve a Mockito problémáit, például a végső, statikus vagy privát módszerek kigúnyolásának hiányát.
Ez az oktatóanyag bemutatja a PowerMockito API-t és annak alkalmazását a tesztekben.
2. Felkészülés a tesztelésre a PowerMockito segítségével
A PowerMock Mockito támogatásának integrálásának első lépése a következő két függőség beépítése a Maven POM fájlba:
org.powermock powermock-module-junit4 1.6.4 teszt org.powermock powermock-api-mockito 1.6.4 teszt
Ezután fel kell készítenünk teszteseteinket a munkára PowerMockito a következő két kommentár alkalmazásával:
@RunWith (PowerMockRunner.class) @PrepareForTest (fullQualifiedNames = "com.baeldung.powermockito.introduction. *")
A fullQualifiedNames elem a @PrepareForTest az annotáció teljesen minősített nevek tömbjét képviseli, amelyeket meg akarunk csúfolni. Ebben az esetben helyettesítővel ellátott csomagnevet használunk PowerMockito hogy minden típust előkészítsen a com.baeldung.powermockito. bevezetés gúnyos csomag.
Most készek vagyunk kihasználni a hatalmat PowerMockito.
3. Gúnyolódó kivitelezők és végső módszerek
Ebben a szakaszban bemutatjuk azokat a módszereket, amelyekkel egy valós példány helyett egy próbapéldányt kaphatunk, amikor egy osztályt példányosítunk a új operátor, majd az objektum segítségével csúfolhatja meg a végső módszert. Az együttműködő osztályt, amelynek konstruktőreit és végső módszereit kigúnyolják, a következőképpen határozzák meg:
public class CollaboratorWithFinalMethods {public final String helloMethod () {return "Hello World!"; }}
Először létrehozunk egy álobjektumot a PowerMockito API:
CollaboratorWithFinalMethods gúny = gúny (CollaboratorWithFinalMethods.class);
Ezután állítson be egy várakozást, amely elmondja, hogy amikor az adott osztály nem arg konstruktorát hívják meg, akkor egy mintapéldányt kell visszaadni, nem pedig valódit:
whenNew (CollaboratorWithFinalMethods.class) .withNoArguments (). thenReturn (gúny);
Lássuk, hogyan működik ez a gúnyolódás működésében a CollaboratorWithFinalMethods osztály az alapértelmezett konstruktora segítségével, majd ellenőrizze a PowerMock viselkedését:
CollaboratorWithFinalMethods munkatárs = new CollaboratorWithFinalMethods (); VerifyNew (CollaboratorWithFinalMethods.class) .withNoArguments ();
A következő lépésben egy elvárás lesz beállítva a végső módszerre:
mikor (munkatárs.helloMethod ()). thenReturn ("Hello Baeldung!");
Ezt a módszert ezután végrehajtják:
String welcome = munkatárs.helloMethod ();
A következő állítások megerősítik, hogy a helloMethod metódust hívták meg a együttműködő objektumot, és visszaadja a gúnyos várakozás által beállított értéket:
Mockito.ellenőrzés (munkatárs) .helloMethod (); assertEquals ("Hello Baeldung!", üdvözlöm);
Ha egy konkrét végső módszert akarunk megcsúfolni, nem pedig az objektumon belüli összes végső módszert, akkor a Mockito.spy (T objektum) módszer jól jöhet. Ezt az 5. szakasz szemlélteti.
4. Statikus módszerek gúnyolása
Tegyük fel, hogy meg akarjuk csúfolni a nevű osztály statikus módszereit CollaboratorWithStaticMethods. Ezt az osztályt a következőképpen deklarálják:
public class CollaboratorWithStaticMethods {public static String firstMethod (String name) {return "Hello" + név + "!"; } public static String secondMethod () {return "Hello senki!"; } public static String thirdMethod () {return "Hello többé senki!"; }}
Ezeknek a statikus módszereknek a kigúnyolása érdekében regisztrálnunk kell a becsatoló osztályt a PowerMockito API:
mockStatic (CollaboratorWithStaticMethods.class);
Alternatív megoldásként használhatjuk a Mockito.spy (Osztályosztály) módszer egy adott gúnyolására, amint azt a következő szakasz bemutatja.
Ezután megadhatók elvárások annak meghatározása érdekében, hogy a módszerek mikor térjenek vissza, amikor meghívják őket:
mikor (CollaboratorWithStaticMethods.firstMethod (Mockito.anyString ())) .thenReturn ("Hello Baeldung!"); mikor (CollaboratorWithStaticMethods.secondMethod ()). thenReturn ("Semmi különös");
Vagy kivételt lehet beállítani, hogy dobja a harmadikMódszer módszer:
doThrow (új RuntimeException ()). mikor (CollaboratorWithStaticMethods.class); CollaboratorWithStaticMethods.thirdMethod ();
Itt az ideje az első két módszer végrehajtásának:
String firstWelcome = CollaboratorWithStaticMethods.firstMethod ("Bárki"); String secondWelcome = CollaboratorWithStaticMethods.firstMethod ("Bármi");
Ahelyett, hogy a valódi osztály tagjait hívnák, a fenti meghívásokat delegálják a gúny módszereire. A következő állítások bizonyítják, hogy a gúny életbe lépett:
assertEquals ("Helló Baeldung!", firstWelcome); assertEquals ("Hello Baeldung!", második üdvözlet);
Ezenkívül képesek vagyunk ellenőrizni az álmódszer viselkedését, beleértve azt is, hogy hányszor hívják meg a módszert. Ebben az esetben a firstMethod kétszer hívták, míg a másodikMódszer soha:
VerifyStatic (Mockito.times (2)); CollaboratorWithStaticMethods.firstMethod (Mockito.anyString ()); VerifyStatic (Mockito.never ()); CollaboratorWithStaticMethods.secondMethod ();
Jegyzet: A ellenőrizzeStatikus metódust közvetlenül a rendszer statikus ellenőrzése előtt kell meghívni PowerMockito tudni, hogy az egymást követő módszer meghívást kell ellenőrizni.
Végül a statikus harmadikMódszer módszernek dobnia kell a RuntimeException ahogyan azt a gúnyon korábban deklarálták. Ezt a várt eleme a @Teszt kommentár:
@Test (várható = RuntimeException.class) public void givenStaticMethods_whenUsingPowerMockito_thenCorrect () {// egyéb módszerek CollaboratorWithStaticMethods.thirdMethod (); }
5. Részleges gúnyolódás
Ahelyett, hogy egy egész osztályt csúfolna, a PowerMockito Az API lehetővé teszi annak egy részének csúfolását a kém módszer. A következő osztály lesz együttműködő a PowerMock támogatásának bemutatására a részleges gúnyolódáshoz:
public class CollaboratorForPartialMocking {public static String staticMethod () {return "Hello Baeldung!"; } public final String finalMethod () {return "Hello Baeldung!"; } private String privateMethod () {return "Hello Baeldung!"; } public String privateMethodCaller () {return privateMethod () + "Üdvözöljük a Java világában."; }}
Kezdjük egy statikus módszer kigúnyolásával, amelynek neve van staticMethod a fenti osztálydefinícióban. Először használja a PowerMockito API, hogy részben gúnyolódjon a CollaboratorForPartialMocking osztály és várakozást állítson be a statikus módszerével kapcsolatban:
kém (CollaboratorForPartialMocking.class); mikor (CollaboratorForPartialMocking.staticMethod ()). thenReturn ("Én egy statikus próbamódszer vagyok.");
Ezután a statikus módszer végrehajtásra kerül:
returnValue = CollaboratorForPartialMocking.staticMethod ();
A gúnyos viselkedést az alábbiak szerint ellenőrizzük:
VerifyStatic (); CollaboratorForPartialMocking.staticMethod ();
A következő állítás megerősíti, hogy a megtérítési módszert valóban meghívták a megtérülési érték és a várakozás összehasonlításával:
assertEquals ("Statikus álmodell vagyok.", returnValue);
Itt az ideje áttérni a végső és a privát módszerekre. E módszerek részleges gúnyolódásának szemléltetése érdekében példát kell adnunk az osztálynak és meg kell mondanunk a PowerMockito API a kém azt:
CollaboratorForPartialMocking munkatárs = new CollaboratorForPartialMocking (); CollaboratorForPartialMocking gock = kém (munkatárs);
A fent létrehozott objektumok mind a végső, mind a privát módszer gúnyolódásának bemutatására szolgálnak. Most a végső módszerrel fogunk foglalkozni egy elvárás megadásával és a módszer meghívásával:
mikor (mock.finalMethod ()). thenReturn ("Végső próbamódszer vagyok."); returnValue = mock.finalMethod ();
Bizonyított a módszer részleges gúnyolódása:
Mockito.ellenőrzés (gúny) .finalMethod ();
Egy teszt igazolja, hogy a finalMethod A metódus a várakozásnak megfelelő értéket ad vissza:
assertEquals ("Végső próbamódszer vagyok.", returnValue);
Hasonló eljárást alkalmaznak a privát módszerre is. A fő különbség az, hogy nem hivatkozhatunk közvetlenül erre a módszerre a tesztesetből. Alapvetően egy privát módszert más, ugyanabból az osztályból származóaknak kell meghívniuk. Ban,-ben CollaboratorForPartialMocking osztály, az privateMethod metódust kell a privateMethodCaller módszert, és az utóbbit fogjuk használni küldöttként. Kezdjük az elvárással és a hívással:
mikor (gúny, "privateMethod"). thenReturn ("privát gúnymódszer vagyok."); returnValue = mock.privateMethodCaller ();
A privát módszer gúnyolódása megerősítést nyer:
VerifyPrivate (mock) .invoke ("privateMethod");
A következő teszt megbizonyosodik arról, hogy a privát módszer meghívásából származó visszatérési érték megegyezik-e a várakozással:
assertEquals ("Én egy privát próbamódszer vagyok. Üdvözöllek a Java világában.", returnValue);
6. Következtetés
Ez az oktatóanyag bemutatta a PowerMockito API, bemutatva annak használatát a Mockito keretrendszer használatakor a fejlesztőkkel szembesülő problémák megoldásában.
Ezeknek a példáknak és kódrészleteknek a megvalósítása megtalálható a kapcsolt GitHub projektben.