Mockito - Spionnen gebruiken

1. Overzicht

In deze zelfstudie laten we zien hoe u er het meeste uit kunt halen spionnen in Mockito.

We zullen praten over de @Spion annotatie, hoe je een spion kunt stoten en, tot slot - we zullen het verschil tussen Bespotten en Spion.

En natuurlijk, voor meer Mockito-goedheid, bekijk de serie hier.

2. Simpel Spion Voorbeeld

Laten we beginnen met een eenvoudig voorbeeld van hoe je een spion.

Simpel gezegd, de API is Mockito.spy () - naar een echt object bespioneren.

Hierdoor kunnen we alle normale methoden van het object oproepen terwijl we nog steeds elke interactie volgen, net zoals we zouden doen met een mock.

OK, laten we een snel voorbeeld geven waarin we een bestaand voorbeeld zullen bespioneren ArrayList voorwerp:

@Test openbare leegte whenSpyingOnList_thenCorrect () {Lijstlijst = nieuwe ArrayList (); List spyList = Mockito.spy (lijst); spyList.add ("een"); spyList.add ("twee"); Mockito.verify (spyList) .add ("één"); Mockito.verify (spyList) .add ("twee"); assertEquals (2, spyList.size ()); }

Merk op hoe de echte methode toevoegen() heet eigenlijk en hoe de grootte van spyList wordt 2.

3. Het @Spion Annotatie

Vervolgens - laten we eens kijken hoe we het @Spion annotatie. We kunnen gebruiken @Spion annotatie in plaats van spion() zoals in het volgende voorbeeld:

@Spy List spyList = nieuwe ArrayList (); @Test openbare leegte whenUsingTheSpyAnnotation_thenObjectIsSpied () {spyList.add ("een"); spyList.add ("twee"); Mockito.verify (spyList) .add ("één"); Mockito.verify (spyList) .add ("twee"); assertEquals (2, spyList.size ()); }

Om zo te Mockito-annotatie inschakelen (zoals @Spion, @Bespotten, ...) - we moeten een van de volgende dingen doen:

  • Roep de methode aan MockitoAnnotations.initMocks (dit) om geannoteerde velden te initialiseren
  • Gebruik de ingebouwde geleider @RunWith (MockitoJUnitRunner.class)

4. Stoppen een Spion

Nu - Laten we eens kijken hoe we een Spion. We kunnen het gedrag van een methode configureren / overschrijven met dezelfde syntaxis die we zouden gebruiken bij een mock.

In het volgende voorbeeld gebruiken we doReturn () om de grootte() methode:

@Test openbare leegte whenStubASpy_thenStubbed () {Lijstlijst = nieuwe ArrayList (); List spyList = Mockito.spy (lijst); assertEquals (0, spyList.size ()); Mockito.doReturn (100) .when (spyList) .size (); assertEquals (100, spyList.size ()); }

5. Bespotten vs. Spion in Mockito

Laten we nu het verschil bespreken tussen Bespotten en Spion in Mockito - niet de theoretische verschillen tussen de twee concepten, maar hoe ze verschillen binnen Mockito zelf.

Wanneer Mockito een mock-up maakt, gebeurt dit vanuit de Klasse van een type, niet van een daadwerkelijke instantie. De mock creëert gewoon een kale shell-instantie van de Klasse, volledig uitgerust om interacties ermee te volgen.

Aan de andere kant, de spion zal een bestaande instantie inpakken. Het zal zich nog steeds op dezelfde manier gedragen als de normale instantie - het enige verschil is dat het ook wordt gebruikt om alle interacties ermee bij te houden.

In het volgende voorbeeld maken we een bespotten van de ArrayList klasse:

@Test openbare leegte whenCreateMock_thenCreated () {List mockedList = Mockito.mock (ArrayList.class); mockedList.add ("een"); Mockito.verify (mockedList) .add ("één"); assertEquals (0, mockedList.size ()); }

Zoals we kunnen zien - het toevoegen van een element aan de bespotte lijst voegt eigenlijk niets toe - het roept gewoon de methode aan zonder ander neveneffect.

Een spion daarentegen zal zich anders gedragen - het zal eigenlijk de echte implementatie van de toevoegen methode en voeg het element toe aan de onderliggende lijst:

@Test openbare leegte whenCreateSpy_thenCreate () {List spyList = Mockito.spy (nieuwe ArrayList ()); spyList.add ("een"); Mockito.verify (spyList) .add ("één"); assertEquals (1, spyList.size ()); }

6. Inzicht in de Mockito NotAMockException

In dit laatste gedeelte leren we over de Mockito NotAMockException. Deze uitzondering is een van de meest voorkomende uitzonderingen die we waarschijnlijk zullen tegenkomen bij misbruik van spot of spionnen.

Laten we beginnen met te kijken onder welke omstandigheden deze uitzondering kan optreden:

Lijstlijst = nieuwe ArrayList (); Mockito.doReturn (100) .when (lijst) .size (); assertEquals ("Grootte moet 100 zijn:", 100, list.size ()); 

Wanneer we dit codefragment uitvoeren, krijgen we de volgende foutmelding:

org.mockito.exceptions.misusing.NotAMockException: Argument doorgegeven aan when () is geen nep! Voorbeeld van correct stubbing: doThrow (new RuntimeException ()). When (mock) .someMethod (); 

Gelukkig wordt uit de Mockito-foutmelding duidelijk wat hier het probleem is. In ons voorbeeld is de lijst object is geen schijnvertoning. De Mockito wanneer() methode verwacht een nep- of spionage-object als argument.

Zoals we ook kunnen zien, beschrijft het uitzonderingsbericht zelfs hoe een correcte aanroep eruit zou moeten zien. Nu we een beter begrip hebben van wat het probleem is, laten we het oplossen volgens de aanbeveling:

laatste lijst spyList = Mockito.spy (nieuwe ArrayList ()); Mockito.doReturn (100) .when (spyList) .size (); assertEquals ("Grootte moet 100 zijn:", 100, spyList.size ()); 

Ons voorbeeld gedraagt ​​zich nu zoals verwacht en we zien de Mockito niet meer NotAMockException.

7. Conclusie

In dit korte artikel hebben we de handigste voorbeelden besproken van het gebruik van Mockito-spionnen.

We hebben geleerd hoe we een spion, hoe te gebruiken @Spion annotatie, hoe een spion en, tot slot - het verschil tussen Bespotten en Spion.

De implementatie van al deze voorbeelden is te vinden op GitHub.

Dit is een Maven-project, dus het moet gemakkelijk te importeren en uit te voeren zijn zoals het is.

En natuurlijk, voor meer Mockito-goedheid, bekijk de serie hier.