streamalism.org

1. Oversikt

Enhetstesting ved hjelp av et mocking-rammeverk har vært anerkjent som en nyttig praksis i lang tid, og spesielt Mockito-rammeverket har dominert dette markedet de siste årene.

Og for å tilrettelegge for anstendig kodedesign og gjøre det offentlige API enkelt, har noen ønskede funksjoner med vilje blitt utelatt. I noen tilfeller tvinger disse manglene imidlertid testere til å skrive tungvint kode bare for å gjøre det mulig å lage spotter.

Det er her PowerMock-rammeverket spiller inn.

PowerMockito er et PowerMocks utvidelses-API for å støtte Mockito. Det gir muligheter til å jobbe med Java Reflection API på en enkel måte for å overvinne problemene med Mockito, for eksempel mangel på evne til å spotte endelige, statiske eller private metoder.

Denne opplæringen vil gi en introduksjon til PowerMockito API og hvordan den brukes i tester.

2. Klargjøre for testing med PowerMockito

Det første trinnet for å integrere PowerMock-støtte for Mockito er å inkludere følgende to avhengigheter i Maven POM-filen:

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

Deretter må vi forberede testsakene våre for å jobbe med PowerMockito ved å bruke følgende to merknader:

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

De fullyQualifiedNames element i @PrepareForTest kommentar representerer en rekke fullt kvalifiserte navn på typene vi ønsker å spotte. I dette tilfellet bruker vi et pakkenavn med jokertegn for å fortelle PowerMockito å forberede alle typer innen com.baeldung.powermockito.introduction pakke for hån.

Nå er vi klare til å utnytte kraften til PowerMockito.

3. Spottende konstruktører og endelige metoder

I denne delen vil vi demonstrere måtene å få en mock-forekomst i stedet for en reell når vi starter en klasse med ny operatøren, og bruk deretter objektet til å spotte en endelig metode. Den samarbeidende klassen, hvis konstruktører og endelige metoder vil bli hånet, er definert som følger:

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

Først lager vi et mock-objekt ved hjelp av PowerMockito API:

CollaboratorWithFinalMethods mock = mock (CollaboratorWithFinalMethods.class);

Sett deretter en forventning som forteller at når ikke arg-konstruktøren av den klassen påkalles, skal en hånlig forekomst returneres i stedet for en reell:

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

La oss se hvordan denne konstruksjonshåningen fungerer i aksjon ved å øyeblikkeliggjøre CollaboratorWithFinalMethods klasse ved hjelp av standardkonstruktøren, og verifiser deretter oppførselen til PowerMock:

CollaboratorWithFinalMethods samarbeidspartner = ny CollaboratorWithFinalMethods (); verifyNew (CollaboratorWithFinalMethods.class) .withNoArguments ();

I neste trinn settes en forventning til den endelige metoden:

når (samarbeidspartner.helloMethod ()). deretterReturn ("Hei Baeldung!");

Denne metoden utføres deretter:

String velkommen = samarbeidspartner.helloMethod ();

Følgende påstander bekrefter at heiMetode metoden har blitt kalt på samarbeidspartner objekt, og returnerer verdien satt av den spottende forventningen:

Mockito.verify (samarbeidspartner) .helloMethod (); assertEquals ("Hei Baeldung!", velkommen);

Hvis vi ønsker å spotte en bestemt sluttmetode i stedet for alle de endelige i et objekt, vil Mockito.spy (T-objekt) metoden kan komme til nytte. Dette er illustrert i avsnitt 5.

4. Hånlige statiske metoder

Anta at vi vil spotte statiske metoder for en klasse som heter CollaboratorWithStaticMethods. Denne klassen er erklært som følger:

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

For å spotte disse statiske metodene, må vi registrere den vedlagte klassen med PowerMockito API:

mockStatic (CollaboratorWithStaticMethods.class);

Alternativt kan vi bruke Mockito.spy (klasse klasse) metode for å spotte en bestemt som vist i det følgende avsnittet.

Deretter kan forventninger settes for å definere verdiene metodene skal returnere når de påkalles:

når (CollaboratorWithStaticMethods.firstMethod (Mockito.anyString ())) .thenReturn ("Hei Baeldung!"); når (CollaboratorWithStaticMethods.secondMethod ()). deretterReturn ("Ikke noe spesielt");

Eller et unntak kan være satt til å bli kastet når du ringer til tredje metode metode:

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

Nå er det på tide å utføre de to første metodene:

String firstWelcome = CollaboratorWithStaticMethods.firstMethod ("Whoever"); String secondWelcome = CollaboratorWithStaticMethods.firstMethod ("Whatever");

I stedet for å ringe medlemmer av den virkelige klassen, blir ovennevnte påkallelser delegert til narrens metoder. Følgende påstander viser at spotten har trådt i kraft:

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

Vi er også i stand til å verifisere oppførselen til mock-metodene, inkludert hvor mange ganger en metode blir påkalt. I dette tilfellet førstMetode har blitt kalt to ganger, mens andre Metode har aldri:

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

Merk: De verifisereStatic metoden må kalles rett før en statisk metodeverifisering for PowerMockito å vite at den påfølgende metoden påkalling er det som må verifiseres.

Til slutt, det statiske tredje metode metoden skal kaste en RuntimeException som erklært på spotten før. Det valideres av forventet element av @Test kommentar:

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

5. Delvis hån

I stedet for å spotte en hel klasse, har PowerMockito API tillater spott av deler av det ved hjelp av spion metode. Følgende klasse vil bli brukt som samarbeidspartner for å illustrere PowerMock-støtten for delvis hån:

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

La oss begynne med å spotte en statisk metode, som heter statisk metode i klassedefinisjonen ovenfor. Bruk først PowerMockito API for delvis å spotte CollaboratorForPartialMocking klasse og sett en forventning for den statiske metoden:

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

Den statiske metoden utføres deretter:

returnValue = CollaboratorForPartialMocking.staticMethod ();

Spottadferd blir bekreftet som følger:

verifisereStatic (); CollaboratorForPartialMocking.staticMethod ();

Følgende påstand bekrefter at mock-metoden faktisk er blitt kalt ved å sammenligne returverdien mot forventningen:

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

Nå er det på tide å gå videre til de endelige og private metodene. For å illustrere den delvise spottingen av disse metodene, må vi instintere klassen og fortelle den PowerMockito API til spion den:

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

Objektene opprettet ovenfor brukes til å demonstrere spott av både de endelige og private metodene. Vi vil håndtere den endelige metoden nå ved å sette en forventning og påkalle metoden:

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

Oppførselen til å delvis spotte den metoden er bevist:

Mockito.verify (mock) .finalMethod ();

En test bekrefter at det å ringe til endelig metode metoden returnerer en verdi som samsvarer med forventningen:

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

En lignende prosess brukes på den private metoden. Hovedforskjellen er at vi ikke direkte kan påberope denne metoden fra testsaken. I utgangspunktet skal en privat metode kalles av andre fra samme klasse. I CollaboratorForPartialMocking klasse, den privat metode metoden skal påberopes av privateMethodCaller metode og vi vil bruke sistnevnte som en delegat. La oss starte med forventning og påkallelse:

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

Håningen om den private metoden er bekreftet:

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

Følgende test sørger for at returverdien fra påkalling av den private metoden er den samme som forventningen:

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

6. Konklusjon

Denne opplæringen har gitt en introduksjon til PowerMockito API, som viser bruken av den til å løse noen av problemene utviklere støter på når de bruker Mockito-rammeverket.

Implementeringen av disse eksemplene og kodebiter finner du i det tilknyttede GitHub-prosjektet.