Het Mockito-framework biedt een verscheidenheid aan methoden, zoals mock(), verificatie(), wanneer(), enz., die worden gebruikt om Java-applicaties te testen. Door deze vooraf gedefinieerde methoden te gebruiken, wordt het testen heel eenvoudig.

Hieronder vindt u een korte beschrijving van de Mockito-methoden:

strep

Mockito mock()-methode

Het wordt gebruikt om nepobjecten van een bepaalde klasse of interface te maken. Mockito bevat er vijf bespotten() methoden met verschillende argumenten. Als we niets aan mocks hebben toegewezen, retourneren ze standaardwaarden. Alle vijf de methoden vervullen dezelfde functie: het bespotten van de objecten.

Hieronder volgen de mock()-methoden met verschillende parameters:

mock() methode met klasse:Het wordt gebruikt om nepobjecten van een concrete klasse of een interface te maken. Er is een klasse- of interfacenaam nodig als parameter.
Syntaxis: mock(Klasse klasseToMock)mock() methode met antwoord:Het wordt gebruikt om nepobjecten van een klasse of interface met een specifieke procedure te maken. Het is een geavanceerde nepmethode, die kan worden gebruikt bij het werken met oudere systemen. Het heeft Answer als parameter nodig, samen met de klasse- of interfacenaam. Het Antwoord is een opsomming van vooraf geconfigureerde nepantwoorden.
Syntaxis: mock(Klasse classToMock, Answer defaultAnswer)mock() methode met MockSettings:Het wordt gebruikt om nepobjecten te maken met enkele niet-standaard instellingen. MockSettings is als extra instellingsparameter nodig, samen met de klasse- of interfacenaam. Met MockSettings kunt u nepobjecten maken met aanvullende instellingen.
Syntaxis: mock(Klasse classToMock, MockSettings mockSettings)mock() methode met ReturnValues:Hiermee kunnen nepobjecten van een bepaalde klasse of interface worden gemaakt. Het is nu verouderd, omdat ReturnValues ​​zijn vervangen door Answer.
Syntaxis: mock(Klasse classToMock, ReturnValues ​​returnValues)mock() methode met String:Het wordt gebruikt om nepobjecten te maken door de nepnamen op te geven. Bij het debuggen kan het benoemen van nepobjecten nuttig zijn, terwijl het een slechte keuze is om met grote en complexe code te werken.
Syntaxis: mock(Klasse classToMock, Stringnaam)

Het volgende codefragment laat zien hoe u dit kunt gebruiken bespotten() methode:

 ToDoService doService = mock(ToDoService.class); 

Mockito wanneer() methode

Het maakt stubbingmethoden mogelijk. Het moet worden gebruikt als we willen spotten met het retourneren van specifieke waarden wanneer bepaalde methoden worden aangeroepen. In simpele termen, ' Wanneer de XYZ()-methode wordt aangeroepen, Dan geef ABC terug.' Het wordt meestal gebruikt als er een voorwaarde is om uit te voeren.

Syntaxis: wanneer(T-methodeOproep)

Het volgende codefragment laat zien hoe u de methode When() gebruikt:

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

In de bovenstaande code, danReturn() wordt meestal gebruikt met de wanneer() methode.

Mockito verificatie() methode

De verifiëren() methode wordt gebruikt om te controleren of sommige gespecificeerde methoden worden aangeroepen of niet. In eenvoudige bewoordingen valideert het bepaald gedrag dat één keer in een test is opgetreden. Het wordt onderaan de testcode gebruikt om ervoor te zorgen dat de gedefinieerde methoden worden aangeroepen.

Het Mockito-framework houdt alle methodeaanroepen bij met hun parameters voor het bespotten van objecten. Na het spotten kunnen we verifiëren of aan de gedefinieerde voorwaarden is voldaan of niet door de verificatie() methode te gebruiken. Dit type testen wordt ook wel gedragstesten. Het controleert of een methode wordt aangeroepen met de juiste parameters in plaats van het resultaat van een methodeaanroep te controleren.

De methode verificatie() wordt ook gebruikt om het aantal aanroepen te testen. We kunnen dus het exacte aantal aanroepingen testen met behulp van de keer methode, minstens één keer methode, En hoogstens methode voor een bespotte methode.

Er zijn twee soorten verificatie()-methoden beschikbaar in de Mockito-klasse, die hieronder worden gegeven:

verificatie() methode:Het verifieert dat bepaald gedrag ooit heeft plaatsgevonden.
Syntaxis: verifiëren(T nep)verificatie() methode met VerificationMode:Het verifieert dat bepaald gedrag minstens één keer, een exact aantal keren of nooit heeft plaatsgevonden.
Syntaxis: verifiëren(T mock, VerificationMode-modus)

Mockito spy()-methode

Mockito biedt een methode om een ​​object gedeeltelijk te bespotten, dat bekend staat als de spion methode. Bij gebruik van de spionagemethode bestaat er een echt object en worden er spionnen of stubs gemaakt van dat echte object. Als we een methode niet met behulp van spionage stoppen, zal deze het gedrag van de echte methode aanroepen. De belangrijkste functie van de methode spy() is dat deze de specifieke methoden van het echte object overschrijft. Eén van de functies van de methode spy() is dat het de aanroep van een bepaalde methode verifieert.

Er zijn twee typen spy()-methoden beschikbaar in de Mockito-klasse:

spion() methode:Het creëert een spion van het echte object. De spionagemethode roept de echte methoden aan, tenzij ze worden verwijderd. We moeten de echte spionnen zorgvuldig en af ​​en toe inzetten, bijvoorbeeld bij het omgaan met de oude code.
Syntaxis: spion(T-object)spy() methode met klasse:Het creëert een spionageobject op basis van klasse in plaats van een object. De methode spy(T object) is vooral handig voor het bespioneren van abstracte klassen, omdat deze niet kunnen worden geïnstantieerd.
Syntaxis: spy(Klasse klasseToSpy)

Het volgende codefragment laat zien hoe u de methode spy() gebruikt:

 List spyArrayList = spy(ArrayList.class); 

Mockito reset()-methode

De Mockito reset()-methode wordt gebruikt om de mocks te resetten. Het wordt voornamelijk gebruikt voor het werken met de container-geïnjecteerde mocks. Meestal resulteert de reset()-methode in lange code en slechte tests. Het is beter om nieuwe mocks te maken in plaats van de reset()-methode te gebruiken. Dat is de reden waarom de reset()-methode zelden wordt gebruikt bij het testen.

De handtekening van de reset() methode is:

Scherpe hoek

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

Mockito verificatieNoMoreInteractions()-methode

Het wordt gebruikt om te controleren of een van de gegeven mocks niet-geverifieerde interacties heeft. We kunnen deze methode gebruiken nadat we alle schijnvertoningen hebben geverifieerd, om er zeker van te zijn dat er niets anders op de schijnvertoningen is aangeroepen. Het detecteert ook de niet-geverifieerde aanroepen die vóór de testmethode plaatsvinden, bijvoorbeeld in de setup(), @Before-methode of de constructor. Het is een optionele methode en we hoeven deze niet bij elke test te gebruiken.

De handtekening van de methode verificatieNoMoreInteractions() is:

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

Mockito verificatieZeroInteractions()-methode

Het verifieert dat er geen interactie heeft plaatsgevonden op de gegeven mocks. Het detecteert ook de aanroepen die vóór de testmethode hebben plaatsgevonden, bijvoorbeeld in de setup(), @Before-methode of de constructor.

De handtekening van de methode verificatieZeroInteractions() is:

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

Mockito doThrow()-methode

Het wordt gebruikt bij het stubben van een void-methode om een ​​uitzondering te genereren. Er wordt een nieuwe uitzonderingsinstantie gemaakt voor elke methodeaanroep. Er zijn twee soorten doThrow()-methoden beschikbaar in de Mockito-klasse met verschillende parameters, zoals hieronder weergegeven:

doThrow() methode met Throwable:Deze methode wordt gebruikt als we een void-methode met een uitzondering willen stoppen. Syntaxis: doThrow (werpbaar om te gooien)
De handtekening van de doThrow()-methode is:

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

doThrow() methode met klasse:Deze methode wordt gebruikt wanneer we een void-methode willen stubben om een ​​uitzondering van een opgegeven klasse te genereren.
Syntaxis: doThrow(Klasse om te gooien)
De handtekening van de doThrow()-methode is:

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

Mockito doCallRealMethod()-methode

Het wordt gebruikt wanneer we de echte implementatie van een methode willen aanroepen. Met andere woorden, het wordt gebruikt om gedeeltelijke nabootsingen van een object te maken. Het wordt gebruikt in zeldzame situaties, bijvoorbeeld om de echte methoden aan te roepen. Het is vergelijkbaar met de methode spy() en het enige verschil is dat het resulteert in complexe code.

De handtekening van de methode doCallRealMethod() is:

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

Mockito doAnswer()-methode

Het wordt gebruikt wanneer we een void-methode willen stubben met een algemeen antwoordtype. De handtekening van de methode doAnswer() is:

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

Mockito doNothing()-methode

Het wordt gebruikt voor het instellen van ongeldige methoden om niets te doen. De methode doNothing() wordt in zeldzame situaties gebruikt. Standaard doen de void-methoden op nepinstanties niets, dat wil zeggen dat er geen taak wordt uitgevoerd.

De handtekening van de methode doNothing() is:

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

Mockito doReturn()-methode

Het wordt gebruikt in de zeldzame gevallen waarin we Mockito.when(object) niet kunnen gebruiken. De Mockito.when(object)-methode wordt altijd voorgesteld voor stubbing, omdat deze argumenttypeveilig is en beter leesbaar is in vergelijking met de doReturn()-methode.

De handtekening van de doReturn()-methode is:

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

Mockito inOrder()-methode

Het wordt gebruikt om objecten te maken die de verificatie van mocks in een specifieke volgorde mogelijk maken. Verificatie op volgorde is flexibeler omdat we niet alle interacties hoeven te verifiëren. We hoeven alleen die interacties te verifiëren die geïnteresseerd zijn in testen (in volgorde). We kunnen ook de methode inOrder() gebruiken om een ​​inOrder-object te maken, waarbij voorbeelden worden doorgegeven die relevant zijn voor verificatie in de bestelling.

De handtekening van de Mockito.inOrder()-methode is:

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

Mockito negeerStubs()-methode

Het wordt gebruikt om de stompzinnige methoden van bepaalde schijnvertoningen ter verificatie te negeren. Het is handig met de methoden verificatieNoMoreInteractions() of verificatie inOrder(). Het helpt ook bij het voorkomen van redundante verificatie van afgebroken oproepen.

De handtekening van de methode negeerStubs() is:

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

Mockito times()-methode

Het wordt gebruikt om het exacte aantal methode-aanroepen te verifiëren, wat betekent dat het aangeeft hoe vaak een methode wordt aangeroepen. De handtekening van de times() methode is:

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

Mockito nooit() methode

Het wordt gebruikt om te verifiëren dat de interactie niet heeft plaatsgevonden. De handtekening van de methode never() is:

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

Mockito atLeastOnce()-methode

Het wordt gebruikt om de aanroep minstens één keer te verifiëren, wat betekent dat de methode minstens één keer moet worden aangeroepen.

De handtekening van de methode atLeastOnce() is:

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

Mockito atLeast()-methode

Het wordt gebruikt om de aanroep minimaal een x aantal keren te verifiëren. Het gegeven atLeast(3) betekent bijvoorbeeld dat de methode minimaal drie keer zal worden aangeroepen.

exemplaarvan

De handtekening van de methode atLeast() is:

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

Mockito atMost()-methode

Het wordt gebruikt om de aanroep maximaal x aantal keren te verifiëren. Het gegeven atMost(3) betekent bijvoorbeeld dat de methode maximaal drie keer zal worden aangeroepen.

De handtekening van de atMost() methode is:

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

Mockito roept de methode aan

Het maakt een niet-hebzuchtige verificatie op orde mogelijk. Het kan alleen worden gebruikt met de verificatiemethode inOrder(). Bijvoorbeeld inOrder.verify(mock, calls(3)).xyzMethod('...');

De handtekening van de methode calls() is:

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

Alleen Mockito()-methode

Het controleert of de gegeven methode de enige aangeroepen methode was. De handtekening van de only() methode is:

Java-erfenis

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

Mockito time-out()-methode

Hiermee kan Mockito verificatie uitvoeren met een time-out. Het instrueert een verificatie om een ​​specifieke periode te wachten op een bepaalde interactie in plaats van onmiddellijk te mislukken. Het kan nuttig zijn om te testen in bestaande situaties.

De methode timeout() verschilt van de methode after() omdat de methode after() de volledige periode wacht, tenzij het eindresultaat wordt gedeclareerd, terwijl de methode timeout() stopt zodra de verificatie is geslaagd. Het wordt zelden gebruikt bij het testen.

De handtekening van de timeout()-methode is:

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

Mockito na() methode

Hiermee kan Mockito gedurende een bepaalde periode verifiëren. We hebben al besproken dat de after()-methode verschilt van de timeout()-methode.

De handtekening van de after() methode is:

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

Mockito validateMockitoUsage()-methode

Het wordt gebruikt voor het expliciet valideren van de raamwerkstatus om het ongeldige gebruik van het Mockito-raamwerk te detecteren. Het is een optionele functie van Mockito omdat het het gebruik voortdurend valideert. Zowel de ingebouwde runner (MockitoJUnitRunner) als de regel (MockitoRule) roepen na elke testmethode de methode validateMockitoUsage() aan.

De handtekening van de methode validateMockitoUsage() is:

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

Mockito withSettings()-methode

Het wordt gebruikt om mocks te maken met extra mock-instellingen. Het moet af en toe worden gebruikt bij tests. In plaats van de methode withSettings() te gebruiken, kunt u eenvoudige tests maken met behulp van eenvoudige proefmodellen. De belangrijkste redenen voor het gebruik van MockSettings zijn

• Door MockSetting te gebruiken, kunnen we indien nodig eenvoudig andere nep-instellingen toevoegen.
• Het combineert verschillende nep-instellingen zonder de code te verpesten.

De handtekening van de methode withSettings() is:

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