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.