streamalism.org

1. Oversigt

Enhedstest ved hjælp af en spottende ramme har i lang tid været anerkendt som en nyttig praksis, og især Mockito-rammen har domineret dette marked i de senere år.

Og for at lette anstændigt kodedesign og gøre den offentlige API enkel er nogle ønskede funktioner med vilje blevet udeladt. I nogle tilfælde tvinger disse mangler imidlertid testere til at skrive besværlig kode bare for at gøre oprettelsen af ​​mocks mulig.

Det er her, PowerMock-rammen kommer i spil.

PowerMockito er en PowerMocks udvidelses-API til understøttelse af Mockito. Det giver muligheder for at arbejde med Java Reflection API på en enkel måde for at overvinde Mockitos problemer, såsom manglen på evne til at spotte endelige, statiske eller private metoder.

Denne vejledning giver en introduktion til PowerMockito API, og hvordan den anvendes i test.

2. Forberedelse til test med PowerMockito

Det første trin til at integrere PowerMock-understøttelse af Mockito er at inkludere følgende to afhængigheder i Maven POM-filen:

 org.powermock powermock-module-junit4 1.6.4 test org.powermock powermock-api-mockito 1.6.4 test 

Dernæst er vi nødt til at forberede vores testsager til at arbejde med PowerMockito ved at anvende følgende to kommentarer:

@RunWith (PowerMockRunner.class) @PrepareForTest (fullyQualifiedNames = "com.baeldung.powermockito.introduction. *")

Det fullyQualifiedNames element i @PrepareForTest annotation repræsenterer en matrix af fuldt kvalificerede navne på de typer, vi vil håne om. I dette tilfælde bruger vi et pakkenavn med et jokertegn til at fortælle PowerMockito at forberede alle typer inden for com.baeldung.powermockito.introduction pakke til hån.

Nu er vi klar til at udnytte kraften i PowerMockito.

3. Spottende konstruktører og endelige metoder

I dette afsnit vil vi demonstrere måderne til at få en mock-forekomst i stedet for en reel, når vi starter en klasse med ny operatør, og brug derefter objektet til at spotte en endelig metode. Den samarbejdende klasse, hvis konstruktører og endelige metoder vil blive hånet, er defineret som følger:

public class CollaboratorWithFinalMethods {public final String helloMethod () {return "Hello World!"; }}

Først opretter vi et mock-objekt ved hjælp af PowerMockito API:

CollaboratorWithFinalMethods mock = mock (CollaboratorWithFinalMethods.class);

Indstil derefter en forventning, der fortæller, at hver gang no-arg-konstruktøren af ​​denne klasse påberåbes, skal en mock-forekomst returneres i stedet for en reel:

whenNew (CollaboratorWithFinalMethods.class) .withNoArguments (). derefterReturn (mock);

Lad os se, hvordan denne konstruktionshån fungerer i aktion ved at instantiere CollaboratorWithFinalMethods klasse ved hjælp af sin standardkonstruktør, og kontroller derefter PowerMocks opførsel:

CollaboratorWithFinalMethods kollaboratør = ny CollaboratorWithFinalMethods (); verifyNew (CollaboratorWithFinalMethods.class) .withNoArguments ();

I det næste trin indstilles en forventning til den endelige metode:

når (samarbejdspartner.helloMethod ()). derefterReturn ("Hej Baeldung!");

Denne metode udføres derefter:

Streng velkommen = samarbejdspartner.helloMethod ();

Følgende påstande bekræfter, at hejMetode metoden er blevet kaldt på samarbejdspartner objekt og returnerer den værdi, der er indstillet af den håne forventning:

Mockito.verify (samarbejdspartner) .helloMethod (); assertEquals ("Hej Baeldung!", velkommen);

Hvis vi ønsker at spotte en bestemt endelig metode i stedet for alle de endelige inde i et objekt, er Mockito.spy (T-objekt) metode kan komme til nytte. Dette er illustreret i afsnit 5.

4. Hånende statiske metoder

Antag, at vi vil spotte statiske metoder for en klasse, der hedder CollaboratorWithStaticMethods. Denne klasse erklæres som følger:

public class CollaboratorWithStaticMethods {public static String firstMethod (String name) {return "Hello" + name + "!"; } offentlig statisk streng secondMethod () {return "Hej ingen!"; } offentlig statisk String thirdMethod () {return "Hej ingen igen!"; }}

For at spotte disse statiske metoder er vi nødt til at registrere den indesluttende klasse med PowerMockito API:

mockStatic (CollaboratorWithStaticMethods.class);

Alternativt kan vi bruge Mockito.spy (klasse klasse) metode til at spotte en bestemt som vist i det følgende afsnit.

Dernæst kan forventninger indstilles til at definere, hvilke værdier metoder skal vende tilbage, når de påberåbes:

når (CollaboratorWithStaticMethods.firstMethod (Mockito.anyString ())) .thenReturn ("Hej Baeldung!"); når (CollaboratorWithStaticMethods.secondMethod ()). derefterReturn ("Intet specielt");

Eller der kan indstilles en undtagelse, der skal kastes, når du ringer til tredje metode metode:

doThrow (ny RuntimeException ()). når (CollaboratorWithStaticMethods.class); CollaboratorWithStaticMethods.thirdMethod ();

Nu er det tid til at udføre de to første metoder:

String firstWelcome = CollaboratorWithStaticMethods.firstMethod ("Hvem som helst"); String secondWelcome = CollaboratorWithStaticMethods.firstMethod ("Whatever");

I stedet for at kalde medlemmer af den virkelige klasse delegeres ovenstående kald til mockens metoder. Følgende påstande viser, at mocken er trådt i kraft:

assertEquals ("Hello Baeldung!", firstWelcome); assertEquals ("Hello Baeldung!", secondWelcome);

Vi er også i stand til at kontrollere adfærd fra mock-metoderne, herunder hvor mange gange en metode påberåbes. I dette tilfælde er første metode er blevet kaldt to gange, mens anden metode har aldrig:

verificere Statisk (Mockito.times (2)); CollaboratorWithStaticMethods.firstMethod (Mockito.anyString ()); verificere Statisk (Mockito.never ()); CollaboratorWithStaticMethods.secondMethod ();

Bemærk: Det verificere statisk metoden skal kaldes lige før enhver statisk metodeverifikation for PowerMockito at vide, at den successive metodeopkald er det, der skal verificeres.

Endelig det statiske tredje metode metoden skal kaste en RuntimeException som deklareret på mocken før. Det valideres af forventet element i @Prøve kommentar:

@Test (forventet = RuntimeException.class) offentlig ugyldighed givenStaticMethods_whenUsingPowerMockito_thenCorrect () {// andre metoder CollaboratorWithStaticMethods.thirdMethod (); }

5. Delvis hån

I stedet for at spotte en hel klasse, PowerMockito API giver mulighed for at spotte en del af det ved hjælp af spion metode. Følgende klasse vil blive brugt som samarbejdspartner til at illustrere PowerMock-understøttelsen til delvis hån:

public class CollaboratorForPartialMocking {public static String staticMethod () {return "Hej Baeldung!"; } offentlig finale String finalMethod () {return "Hej Baeldung!"; } private String privateMethod () {return "Hej Baeldung!"; } public String privateMethodCaller () {return privateMethod () + "Velkommen til Java-verdenen."; }}

Lad os begynde med at spotte en statisk metode, der er navngivet statisk metode i ovennævnte klassedefinition. Brug først PowerMockito API til delvis at spotte CollaboratorForPartialMocking klasse og sæt en forventning til dens statiske metode:

spion (CollaboratorForPartialMocking.class); når (CollaboratorForPartialMocking.staticMethod ()). derefterReturn ("Jeg er en statisk mock-metode.");

Den statiske metode udføres derefter:

returnValue = CollaboratorForPartialMocking.staticMethod ();

Den spottende adfærd bekræftes som følger:

verificere Statisk (); CollaboratorForPartialMocking.staticMethod ();

Følgende påstand bekræfter, at mock-metoden faktisk er blevet kaldt ved at sammenligne returværdien med forventningen:

assertEquals ("Jeg er en statisk mock-metode.", returnValue);

Nu er det tid til at gå videre til de endelige og private metoder. For at illustrere den delvise hån af disse metoder er vi nødt til at instantiere klassen og fortælle den PowerMockito API til spion det:

CollaboratorForPartialMocking-samarbejdspartner = ny CollaboratorForPartialMocking (); CollaboratorForPartialMocking mock = spion (samarbejdspartner);

Objekterne oprettet ovenfor bruges til at demonstrere spottet af både den endelige og private metode. Vi vil beskæftige os med den endelige metode nu ved at indstille en forventning og påkalde metoden:

når (mock.finalMethod ()). derefterReturn ("Jeg er en sidste mock-metode."); returnValue = mock.finalMethod ();

Adfærden ved delvis at spotte den metode er bevist:

Mockito.verify (mock) .finalMethod ();

En test bekræfter, at opkald til endelig metode metoden returnerer en værdi, der svarer til forventningen:

assertEquals ("Jeg er en sidste mock-metode.", returnValue);

En lignende proces anvendes på den private metode. Hovedforskellen er, at vi ikke direkte kan påberåbe sig denne metode fra testsagen. Dybest set skal en privat metode kaldes af andre fra samme klasse. I CollaboratorForPartialMocking klasse, den privat metode metoden skal påberåbes af privateMethodCaller metode, og vi vil bruge sidstnævnte som en delegeret. Lad os starte med forventningen og påkaldelsen:

når (mock, "privateMethod"). thenReturn ("Jeg er en privat mock-metode."); returnValue = mock.privateMethodCaller ();

Spottet af den private metode er bekræftet:

verificerePrivat (mock) .invoke ("privateMethod");

Følgende test sørger for, at returværdien fra påkaldelse af den private metode er den samme som forventningen:

assertEquals ("Jeg er en privat mock-metode. Velkommen til Java-verdenen.", returnValue);

6. Konklusion

Denne vejledning har givet en introduktion til PowerMockito API, der viser dets anvendelse til at løse nogle af de problemer, som udviklere støder på, når de bruger Mockito-rammen.

Implementeringen af ​​disse eksempler og kodestykker findes i det sammenkædede GitHub-projekt.