Mockito-rammen giver en række forskellige metoder såsom mock(), verify(), when() osv., der bruges til at teste Java-applikationer. Brug af disse foruddefinerede metoder gør test meget let.

Den korte beskrivelse af Mockito-metoderne er givet nedenfor:

lære selen

Mockito mock() metode

Det bruges til at skabe falske objekter af en given klasse eller grænseflade. Mockito indeholder fem håne() metoder med forskellige argumenter. Når vi ikke har tildelt noget til håner, vil de returnere standardværdier. Alle fem metoder udfører den samme funktion at håne objekterne.

Følgende er mock()-metoderne med forskellige parametre:

mock() metode med klasse:Det bruges til at skabe falske objekter af en konkret klasse eller en grænseflade. Det tager en klasse eller et grænsefladenavn som en parameter.
Syntaks: mock(Class classToMock)mock() metode med svar:Det bruges til at skabe falske objekter af en klasse eller grænseflade med en specifik procedure. Det er en avanceret mock-metode, som kan bruges, når man arbejder med ældre systemer. Det tager Answer som en parameter sammen med klassens eller grænsefladenavnet. Svaret er en opremsning af præ-konfigurerede falske svar.
Syntaks: mock(Class classToMock, Answer defaultAnswer)mock() metode med MockSettings:Det bruges til at skabe falske objekter med nogle ikke-standardindstillinger. Det tager MockSettings som en ekstra indstillingsparameter sammen med klassen eller grænsefladenavnet. MockSettings tillader oprettelse af falske objekter med yderligere indstillinger.
Syntaks: mock(Class classToMock, MockSettings mockSettings)mock() metode med ReturnValues:Det tillader oprettelsen af ​​falske objekter af en given klasse eller grænseflade. Nu er det forældet, da ReturnValues ​​er erstattet med Answer.
Syntaks: mock(Class classToMock, ReturnValues ​​returnValues)mock() metode med streng:Det bruges til at skabe falske objekter ved at angive de falske navne. Ved debugging kan navngivning af falske objekter være nyttigt, mens det er et dårligt valg med stor og kompleks kode.
Syntaks: mock(Class classToMock, String name)

Følgende kodestykke viser, hvordan du bruger håne() metode:

 ToDoService doService = mock(ToDoService.class); 

Mockito when() metode

Det muliggør stubningsmetoder. Det skal bruges, når vi ønsker at håne for at returnere specifikke værdier, når bestemte metoder kaldes. Enkelt sagt, ' Hvornår XYZ() metoden kaldes, derefter retur ABC.' Det bruges mest, når der er en betingelse, der skal udføres.

Syntaks: when(T methodCall)

Følgende kodestykke viser, hvordan man bruger when()-metoden:

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

I ovenstående kode, derefter Return() bruges mest sammen med hvornår() metode.

Mockito verify() metode

Det verificere() metode bruges til at kontrollere, om nogle specificerede metoder kaldes eller ej. Enkelt sagt validerer det den bestemte adfærd, der skete én gang i en test. Den bruges i bunden af ​​testkoden for at sikre, at de definerede metoder kaldes.

Mockito framework holder styr på alle metodekald med deres parametre til at håne objekter. Efter hån kan vi verificere, at de definerede betingelser er opfyldt eller ej ved at bruge verify()-metoden. Denne type test er nogle gange kendt som adfærdstest. Den kontrollerer, at en metode kaldes med de rigtige parametre i stedet for at kontrollere resultatet af et metodekald.

Verify()-metoden bruges også til at teste antallet af påkaldelser. Så vi kan teste det nøjagtige antal påkaldelser ved at bruge gange metode, mindst én gang metode, og højst metode for en hånet metode.

Der er to typer verify() metoder tilgængelige i Mockito-klassen, som er angivet nedenfor:

verify() metode:Det bekræfter, at bestemt adfærd skete én gang.
Syntaks: verificere (T håne)verify() metode med VerificationMode:Det bekræfter, at en eller anden adfærd er sket mindst én gang, nøjagtigt antal gange eller aldrig.
Syntaks: verify (T mock, VerificationMode-tilstand)

Mockito spy() metode

Mockito giver en metode til delvist at håne et objekt, som er kendt som spion metode. Når du bruger spionmetoden, eksisterer der et rigtigt objekt, og spioner eller stubbe skabes af det rigtige objekt. Hvis vi ikke stopper en metode ved hjælp af spion, vil den kalde den rigtige metode adfærd. Hovedfunktionen af ​​spy() metoden er, at den tilsidesætter de specifikke metoder for det rigtige objekt. En af funktionerne i spy()-metoden er, at den verificerer påkaldelsen af ​​en bestemt metode.

Der er to typer spy() metoder tilgængelige i Mockito-klassen:

spy() metode:Det skaber en spion af det virkelige objekt. Spionmetoden kalder de rigtige metoder, medmindre de er stive. Vi bør bruge de rigtige spioner omhyggeligt og lejlighedsvis, for eksempel når vi beskæftiger os med arveloven.
Syntaks: spion (T objekt)spy() metode med klasse:Det opretter et spionobjekt baseret på klasse i stedet for et objekt. Spy(T-objekt)-metoden er især nyttig til at spionere abstrakte klasser, fordi de ikke kan instansieres.
Syntaks: spion(KlasseklasseToSpy)

Følgende kodestykke viser, hvordan man bruger spy() metoden:

 List spyArrayList = spy(ArrayList.class); 

Mockito reset() metode

Mockito reset() metoden bruges til at nulstille mocks. Det bruges hovedsageligt til at arbejde med de beholderinjicerede spots. Normalt resulterer reset() metoden i en lang kode og dårlige tests. Det er bedre at oprette nye håner i stedet for at bruge metoden reset(). Det er grunden til, at reset()-metoden sjældent bruges i test.

Signaturen for metoden reset() er:

partielle derivater i latex

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

Mockito verifyNoMoreInteractions() metode

Det bruges til at kontrollere, at nogen af ​​de givne håner har nogen ubekræftede interaktioner. Vi kan bruge denne metode efter at have verificeret alle mock, for at sikre, at intet andet blev påberåbt på mocks. Det registrerer også de ubekræftede påkald, der forekommer før testmetoden, for eksempel i setup(), @Before-metoden eller konstruktøren. Det er en valgfri metode, og vi behøver ikke bruge den i hver test.

Signaturen for metoden verifyNoMoreInteractions() er:

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

Mockito verifyZeroInteractions() metode

Det verificerer, at der ikke er sket nogen interaktion på de givne håner. Den registrerer også de påkald, der er opstået før testmetoden, for eksempel i setup(), @Before-metoden eller konstruktøren.

Signaturen for metoden verifyZeroInteractions() er:

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

Mockito doThrow() metode

Det bruges, når man skal stoppe en void-metode for at kaste en undtagelse. Det opretter en ny undtagelsesforekomst for hver metodekald. Der er to typer doThrow()-metoder tilgængelige i Mockito-klassen med forskellige parametre, som vist nedenfor:

doThrow() metode med Throwable:Denne metode bruges, når vi ønsker at stoppe en void-metode med en undtagelse. Syntaks: doThrow(Smides toBeThrown)
Signaturen for doThrow() metoden er:

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

doThrow() metode med klasse:Denne metode bruges, når vi ønsker at stoppe en void-metode for at kaste en undtagelse af en specificeret klasse.
Syntaks: doThrow(Class toBeThrown)
Signaturen for doThrow() metoden er:

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

Mockito doCallRealMethod() metode

Det bruges, når vi vil kalde den virkelige implementering af en metode. Med andre ord bruges det til at skabe delvise håner af et objekt. Det bruges i sjældne situationer, såsom at kalde de rigtige metoder. Det ligner spy() metoden, og den eneste forskel er, at det resulterer i kompleks kode.

Signaturen for doCallRealMethod() metoden er:

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

Mockito doAnswer() metode

Det bruges, når vi ønsker at stoppe en void-metode med en generisk svartype. Signaturen for doAnswer()-metoden er:

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

Mockito doNothing() metode

Det bruges til at indstille ugyldige metoder til at gøre ingenting. Metoden doNothing() bruges i sjældne situationer. Som standard gør void-metoderne på falske forekomster intet, dvs. ingen opgave udføres.

Signaturen for doNothing() metoden er:

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

Mockito doReturn() metode

Det bruges i de sjældne tilfælde, hvor vi ikke kan bruge Mockito.when(object). Mockito.when(object)-metoden er altid foreslået til stubbing, fordi den er argumenttypesikker og mere læsbar sammenlignet med doReturn()-metoden.

java sortering array

Signaturen for metoden doReturn() er:

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

Mockito inOrder() metode

Det bruges til at skabe objekter, der tillader verifikation af håner i en bestemt rækkefølge. Bekræftelse udført i rækkefølge er mere fleksibel, da vi ikke behøver at verificere alle interaktioner. Vi skal kun verificere de interaktioner, der er interesserede i at teste (i rækkefølge). Vi kan også bruge metoden inOrder() til at skabe et inOrder-objekt, der sender håner, der er relevante for in-order-verifikation.

Signaturen for metoden Mockito.inOrder() er:

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

Mockito ignoreStubs() metode

Det bruges til at ignorere de udslettede metoder til givne håner til verifikation. Det er nyttigt med verifyNoMoreInteractions() eller verification inOrder() metoder. Det hjælper også med at undgå overflødig verifikation af stubbede opkald.

Signaturen for ignoreStubs() metoden er:

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

Mockito times() metode

Det bruges til at verificere det nøjagtige antal metodepåkaldelser, hvilket betyder, at det erklærer, hvor mange gange en metode påkaldes. Signaturen for times() metoden er:

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

Mockito never() metode

Det bruges til at bekræfte, at interaktionen ikke fandt sted. Signaturen for metoden never() er:

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

Mockito atLeastOnce() metode

Det bruges til at bekræfte påkaldelsen mindst én gang, hvilket betyder, at metoden skal påberåbes mindst én gang.

Signaturen for metoden atLeastOnce() er:

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

Mockito atLeast() metode

Det bruges til at bekræfte påkaldelsen mindst x antal gange. For eksempel betyder givet mindst(3) at metoden vil påberåbe sig mindst tre gange.

Signaturen for metoden atLeast() er:

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

Mockito atMost() metode

Det bruges til at bekræfte påkaldelsen højst x antal gange. For eksempel betyder givet atMost(3) at metoden vil påberåbe sig maksimalt tre gange.

Signaturen for metoden atMost() er:

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

Mockito kalder () metode

Det tillader en ikke-grådig verifikation i rækkefølge. Den kan kun bruges med inOrder()-verifikationsmetoden. F.eks. inOrder.verify(mock, calls(3)).xyzMethod('...');

Signaturen for calls()-metoden er:

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

Mockito only() metode

Den kontrollerer, at den givne metode var den eneste påberåbte metode. Signaturen for metoden only() er:

software test

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

Mockito timeout() metode

Det giver Mockito mulighed for at udføre verifikation med en timeout. Den instruerer en verifikation om at vente i en bestemt periode på en bestemt interaktion i stedet for at fejle med det samme. Det kan være nyttigt til test i eksisterende situationer.

Timeout()-metoden adskiller sig fra after()-metoden, da after()-metoden venter i hele perioden, medmindre det endelige resultat er erklæret, hvorimod timeout()-metoden stopper, så snart verifikationen passerer. Det bruges sjældent i test.

Signaturen for timeout() metoden er:

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

Mockito after() metode

Det giver Mockito mulighed for at verificere over en given periode. Vi har allerede diskuteret, at after()-metoden adskiller sig fra timeout()-metoden.

Signaturen for after() metoden er:

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

Mockito validateMockitoUsage() metode

Det bruges til eksplicit at validere rammetilstanden for at opdage den ugyldige brug af Mockito-rammeværket. Det er en valgfri funktion i Mockito, fordi den validerer brugen hele tiden. Både den indbyggede runner (MockitoJUnitRunner) og reglen (MockitoRule) kalder validateMockitoUsage() metoden efter hver testmetode.

Signaturen for metoden validateMockitoUsage() er:

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

Mockito withSettings() metode

Det bruges til at lave mocks med yderligere mock-indstillinger. Det bør bruges lejlighedsvis i test. I stedet for at bruge metoden withSettings() skal du oprette simple tests ved hjælp af simple mocks. De vigtigste grunde til at bruge MockSettings er

• Ved at bruge MockSetting kan vi nemt tilføje andre mock-indstillinger, når det er nødvendigt.
• Den kombinerer forskellige mock-indstillinger uden at ødelægge koden.

Signaturen for metoden withSettings() er:

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