Mockito-rammeverket gir en rekke metoder som mock(), verify(), when() osv., som brukes til å teste Java-applikasjoner. Å bruke disse forhåndsdefinerte metodene gjør testingen veldig enkel.

Den korte beskrivelsen av Mockito-metodene er gitt nedenfor:

konvertere boolesk til streng

Mockito mock() metode

Den brukes til å lage falske objekter av en gitt klasse eller grensesnitt. Mockito inneholder fem håne() metoder med ulike argumenter. Når vi ikke tilordnet noe til håner, vil de returnere standardverdier. Alle fem metodene utfører samme funksjon som å håne objektene.

Følgende er mock()-metodene med forskjellige parametere:

mock() metode med klasse:Den brukes til å lage falske objekter av en konkret klasse eller et grensesnitt. Det tar en klasse eller et grensesnittnavn som en parameter.
Syntaks: mock(KlasseklasseToMock)mock() metode med svar:Den brukes til å lage falske objekter av en klasse eller grensesnitt med en bestemt prosedyre. Det er en avansert mock-metode, som kan brukes når du arbeider med eldre systemer. Den tar Answer som en parameter sammen med klasse- eller grensesnittnavnet. Svaret er en oppregning av forhåndskonfigurerte falske svar.
Syntaks: mock(Class classToMock, Answer defaultAnswer)mock() metode med MockSettings:Den brukes til å lage falske objekter med noen ikke-standardinnstillinger. Det tar MockSettings som en ekstra innstillingsparameter sammen med klassen eller grensesnittnavnet. MockSettings gjør det mulig å lage falske objekter med tilleggsinnstillinger.
Syntaks: mock(Class classToMock, MockSettings mockSettings)mock() metode med ReturnValues:Det tillater opprettelse av falske objekter av en gitt klasse eller grensesnitt. Nå er den avviklet, ettersom ReturnValues ​​erstattes med Answer.
Syntaks: mock(KlasseklasseToMock, ReturnValues ​​returnValues)mock() metode med streng:Den brukes til å lage falske objekter ved å spesifisere falske navn. Ved feilsøking kan det være nyttig å navngi falske objekter, mens det er et dårlig valg med stor og kompleks kode.
Syntaks: mock(KlasseklasseToMock, strengnavn)

Følgende kodebit viser hvordan du bruker håne() metode:

 ToDoService doService = mock(ToDoService.class); 

Mockito when()-metoden

Det muliggjør stubbemetoder. Den bør brukes når vi ønsker å håne for å returnere spesifikke verdier når bestemte metoder kalles. For å si det enkelt, ' Når XYZ()-metoden kalles, deretter returner ABC.' Det brukes mest når det er en betingelse å utføre.

Syntaks: when(T methodCall)

Følgende kodebit viser hvordan du bruker when()-metoden:

 when(mock.someCode ()).thenReturn(5); 

I koden ovenfor, thenReturn() brukes mest med når() metode.

Mockito verify() metode

De bekrefte() metode brukes til å sjekke om noen spesifiserte metoder kalles eller ikke. Enkelt sagt validerer den den bestemte oppførselen som skjedde en gang i en test. Den brukes nederst i testkoden for å sikre at de definerte metodene kalles.

Mockito-rammeverket holder styr på alle metodekallene med deres parametere for å håne objekter. Etter hån kan vi verifisere at de definerte betingelsene er oppfylt eller ikke ved å bruke verify()-metoden. Denne typen testing er noen ganger kjent som atferdstesting. Den sjekker at en metode kalles med de riktige parameterne i stedet for å sjekke resultatet av et metodekall.

Verify()-metoden brukes også til å teste antall påkallinger. Så vi kan teste det nøyaktige antallet påkallelser ved å bruke ganger metode, minst én gang metode, og på det meste metoden for en hånet metode.

Det er to typer verify()-metoder tilgjengelig i Mockito-klassen, som er gitt nedenfor:

verify() metode:Det bekrefter at bestemt atferd har skjedd en gang.
Syntaks: verifisere (T spott)verify() metode med VerificationMode:Den bekrefter at noen atferd har skjedd minst én gang, nøyaktig antall ganger eller aldri.
Syntaks: verifisere (T mock, VerificationMode-modus)

Mockito spy() metode

Mockito gir en metode for å delvis håne et objekt, som er kjent som spion metode. Når du bruker spionmetoden, eksisterer det et ekte objekt, og spioner eller stubber blir laget av det virkelige objektet. Hvis vi ikke stopper en metode som bruker spion, vil den kalle den virkelige metoden atferd. Hovedfunksjonen til spy()-metoden er at den overstyrer de spesifikke metodene til det virkelige objektet. En av funksjonene til spy()-metoden er at den verifiserer påkallelsen av en bestemt metode.

Det er to typer spy()-metoder tilgjengelig i Mockito-klassen:

spy() metode:Det skaper en spion av det virkelige objektet. Spionmetoden kaller de virkelige metodene med mindre de er stubbet. Vi bør bruke de virkelige spionene forsiktig og av og til, for eksempel når vi arbeider med arvekoden.
Syntaks: spion(T-objekt)spy() metode med klasse:Den lager et spionobjekt basert på klasse i stedet for et objekt. Spy(T-objekt)-metoden er spesielt nyttig for å spionere abstrakte klasser fordi de ikke kan instansieres.
Syntaks: spion(KlasseklasseToSpy)

Følgende kodebit viser hvordan du bruker spy()-metoden:

 List spyArrayList = spy(ArrayList.class); 

Mockito reset() metode

Mockito reset()-metoden brukes til å tilbakestille mockene. Den brukes hovedsakelig til å jobbe med beholderen som er injisert. Vanligvis resulterer reset()-metoden i en lang kode og dårlige tester. Det er bedre å lage nye mocks i stedet for å bruke reset()-metoden. Det er grunnen til at reset()-metoden sjelden brukes i testing.

Signaturen til reset()-metoden er:

okser vs okse

 public static void reset(T ... mocks) { MOCKITO_CORE.reset(mocks); } 

Mockito verifyNoMoreInteractions() metode

Den brukes til å sjekke at noen av de gitte hånene har ubekreftede interaksjoner. Vi kan bruke denne metoden etter å ha verifisert all mock, for å forsikre oss om at ingenting annet ble påkalt på mockene. Den oppdager også de ubekreftede påkallelsene som oppstår før testmetoden, for eksempel i setup(), @Before-metoden eller konstruktøren. Det er en valgfri metode, og vi trenger ikke bruke den i hver test.

Signaturen til verifyNoMoreInteractions()-metoden er:

 public static void verifyNoMoreInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

Mockito verifyZeroInteractions() metode

Den bekrefter at ingen interaksjon har skjedd på de gitte hånene. Den oppdager også påkallelsene som har skjedd før testmetoden, for eksempel i setup(), @Before-metoden eller konstruktøren.

Signaturen til verifyZeroInteractions()-metoden er:

 public static void verifyZeroInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

Mockito doThrow()-metoden

Den brukes når du skal stoppe en void-metode for å kaste et unntak. Det oppretter en ny unntaksforekomst for hver metodeanrop. Det er to typer doThrow()-metoder tilgjengelig i Mockito-klassen med forskjellige parametere, som vist nedenfor:

doThrow()-metoden med Throwable:Denne metoden brukes når vi ønsker å stoppe en void-metode med et unntak. Syntaks: doThrow(Kastbar for å BeThrown)
Signaturen til doThrow()-metoden er:

 public static Stubber doThrow(Throwable toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsException(toBeThrown)); } 

doThrow()-metoden med klasse:Denne metoden brukes når vi vil stubbe en void-metode for å kaste et unntak fra en spesifisert klasse.
Syntaks: doThrow(Class toBeThrown)
Signaturen til doThrow()-metoden er:

 public static Stubber doThrow(Class toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsExceptionClass(toBeThrown)); } 

Mockito doCallRealMethod()-metoden

Det brukes når vi vil kalle den virkelige implementeringen av en metode. Med andre ord, det brukes til å lage delvise hån av et objekt. Det brukes i sjeldne situasjoner, for eksempel å kalle de virkelige metodene. Den ligner på spy()-metoden, og den eneste forskjellen er at den resulterer i kompleks kode.

Signaturen til doCallRealMethod()-metoden er:

 public static Stubber doCallRealMethod() { return MOCKITO_CORE.doAnswer(new CallsRealMethods()); } 

Mockito doAnswer()-metoden

Den brukes når vi ønsker å kutte en void-metode med en generisk svartype. Signaturen til doAnswer()-metoden er:

 public static Stubber doAnswer(Answer answer) { return MOCKITO_CORE.doAnswer(answer); } 

Mockito doNothing()-metoden

Den brukes til å angi ugyldige metoder til å gjøre ingenting. Metoden doNothing() brukes i sjeldne situasjoner. Som standard gjør void-metodene på falske forekomster ingenting, det vil si at ingen oppgave utføres.

Signaturen til doNothing()-metoden er:

 public static Stubber doNothing() { return MOCKITO_CORE.doAnswer(new DoesNothing()); } 

Mockito doReturn() metode

Det brukes i de sjeldne tilfellene når vi ikke kan bruke Mockito.when(object). Mockito.when(object)-metoden er alltid foreslått for stubbing fordi den er argumenttypesikker og mer lesbar sammenlignet med doReturn()-metoden.

tilfeldig verdigenerator i java

Signaturen til doReturn()-metoden er:

 public static Stubber doReturn(Object toBeReturned) { return MOCKITO_CORE.doAnswer(new Returns(toBeReturned)); } 

Mockito inOrder() metode

Den brukes til å lage objekter som tillater verifisering av spotter i en bestemt rekkefølge. Bekreftelse gjort i rekkefølge er mer fleksibel siden vi ikke trenger å bekrefte alle interaksjoner. Vi trenger å verifisere bare de interaksjonene som er interessert i å teste (i rekkefølge). Vi kan også bruke inOrder()-metoden for å lage et inOrder-objekt som passerer håner som er relevante for in-order-verifisering.

Signaturen til Mockito.inOrder()-metoden er:

 public static InOrder inOrder(Object... mocks) { return MOCKITO_CORE.inOrder(mocks); } 

Mockito ignoreStubs()-metoden

Den brukes til å ignorere de stubbede metodene til gitte håner for verifisering. Det er nyttig med verifyNoMoreInteractions()- eller verification inOrder()-metoder. Det hjelper også med å unngå overflødig verifisering av stubbede samtaler.

Signaturen til ignoreStubs()-metoden er:

 public static Object[] ignoreStubs(Object... mocks) { return MOCKITO_CORE.ignoreStubs(mocks); } 

Mockito times() metode

Den brukes til å verifisere det nøyaktige antallet metodepåkallelser, noe som betyr at det erklærer hvor mange ganger en metode påkalles. Signaturen til times()-metoden er:

 public static VerificationMode times(int wantedNumberOfInvocations) { return VerificationModeFactory.times(wantedNumberOfInvocations); } 

Mockito never() metode

Den brukes til å bekrefte at interaksjonen ikke skjedde. Signaturen til never()-metoden er:

 public static VerificationMode never() { return times(0); } 

Mockito atLeastOnce()-metoden

Den brukes til å verifisere påkallingen minst én gang, noe som betyr at metoden bør påberopes minst én gang.

Signaturen til atLeastOnce()-metoden er:

 public static VerificationMode atLeastOnce() { return VerificationModeFactory.atLeastOnce(); } 

Mockito atLeast()-metoden

Den brukes til å bekrefte påkallingen minst x antall ganger. For eksempel, gitt atMinst(3) betyr at metoden vil påkalle minimum tre ganger.

Signaturen til atLeast()-metoden er:

 public static VerificationMode atLeast(int minNumberOfInvocations) { return VerificationModeFactory.atLeast(minNumberOfInvocations); } 

Mockito atMost()-metoden

Den brukes til å bekrefte påkallingen maksimalt x antall ganger. For eksempel, gitt atMost(3) betyr at metoden vil påkalle maksimalt tre ganger.

Signaturen til atMost()-metoden er:

 public static VerificationMode atMost(int maxNumberOfInvocations) { return VerificationModeFactory.atMost(maxNumberOfInvocations); } 

Mockito kaller () metode

Det tillater en ikke-grådig verifisering i rekkefølge. Den kan bare brukes med inOrder()-verifiseringsmetoden. For eksempel, inOrder.verify(mock, calls(3)).xyzMethod('...');

Signaturen til calls()-metoden er:

 public static VerificationMode calls( int wantedNumberOfInvocations ){ return VerificationModeFactory.calls( wantedNumberOfInvocations ); } 

Mockito only() metode

Den sjekker at den gitte metoden var den eneste påberopte metoden. Signaturen til only()-metoden er:

programvaretesting

 public static VerificationMode only() { return VerificationModeFactory.only(); } 

Mockito timeout() metode

Det lar Mockito utføre verifisering med et tidsavbrudd. Den instruerer en verifisering om å vente i en bestemt tidsperiode på en bestemt interaksjon i stedet for å mislykkes umiddelbart. Det kan være nyttig for testing i eksisterende situasjoner.

Timeout()-metoden er forskjellig fra after()-metoden ettersom after()-metoden venter i hele perioden med mindre det endelige resultatet er deklarert, mens timeout()-metoden vil stoppe så snart verifiseringen går. Det brukes sjelden i testing.

Signaturen til timeout()-metoden er:

 public static VerificationWithTimeout timeout(long millis) { return new Timeout(millis, VerificationModeFactory.times(1)); } 

Mockito after() metode

Det lar Mockito verifisere over en gitt tidsperiode. Vi har allerede diskutert at after()-metoden er forskjellig fra timeout()-metoden.

Signaturen til after()-metoden er:

 public static VerificationAfterDelay after(long millis) { return new After(millis, VerificationModeFactory.times(1)); } 

Mockito validateMockitoUsage()-metoden

Den brukes for å eksplisitt validere rammetilstanden for å oppdage ugyldig bruk av Mockito-rammeverket. Det er en valgfri funksjon i Mockito fordi den validerer bruken hele tiden. Både den innebygde løperen (MockitoJUnitRunner) og regelen (MockitoRule) kaller validateMockitoUsage()-metoden etter hver testmetode.

Signaturen til validateMockitoUsage()-metoden er:

 public static void validateMockitoUsage() { MOCKITO_CORE.validateMockitoUsage(); } 

Mockito withSettings()-metoden

Den brukes til å lage mocks med ekstra mock-innstillinger. Den bør brukes av og til i testing. I stedet for å bruke withSettings()-metoden, lag enkle tester ved å bruke enkle mocks. Hovedårsakene til å bruke MockSettings er

• Ved å bruke MockSetting kan vi enkelt legge til andre mock-innstillinger når det er nødvendig.
• Den kombinerer forskjellige mock-innstillinger uten å rote til koden.

Signaturen til withSettings()-metoden er:

 public static MockSettings withSettings() { return new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS); }