2.1 @Mock-annotatie
Er zijn twee manieren om met namaakobjecten in Mockito te werken. De eerste is om een volledig virtueel object te maken , de tweede is om een bestaand object in een wikkel te wikkelen. Laten we beginnen met de eerste.
Om een volledig virtueel object te maken, moet u de code schrijven:
ClassName variable name = Mockito.mock(ClassName.class);
Laten we als voorbeeld een mock ArrayList-klasse maken:
@ExtendWith(MockitoExtension.class)
class MockTest {
@Test
public void whenNotUseMockAnnotation_thenCorrect() {
List mockList = Mockito.mock(ArrayList.class);
//these methods won't do anything - they are stubs
mockList.add("one");
mockList.add("two");
}
}
In dit voorbeeld maken we een valse ArrayList en slaan we een verwijzing daarnaar op in de mockList-variabele. De methoden van dit object doen niets.
Overigens kan deze code nog korter worden geschreven, aangezien hier een speciale annotatie voor is @Mock
.
@ExtendWith(MockitoExtension.class)
class MockTest {
@Mock
List mockList;
@Test
public void whenNotUseMockAnnotation_thenCorrect() {
//these methods won't do anything - they are stubs
mockList.add("one");
mockList.add("two");
}
}
In het tweede geval MockitoExtension
zal het de klassecode zelf analyseren en de nodige stubs maken. U hoeft de methode niet aan te roepen Mockito.mock()
. Eén annotatie en het virtuele object is klaar. Schoonheid.
2.2 @Spy-annotatie
Het tweede belangrijke type objecten in Mockito zijn wikkels over bestaande objecten. Ze maken het enerzijds mogelijk om bestaande klassen te gebruiken en anderzijds om oproepen naar alle methoden en variabelen van dergelijke objecten te onderscheppen: om hun werk waar nodig te corrigeren. Ze worden net zo vaak gebruikt als Mock-objecten.
Om een omslag over een object te maken, moet u de code schrijven:
ClassName variable name = Mockito.spy(an object);
Een voorbeeld met een wrapper rond de klasse ArrayList:
@ExtendWith(MockitoExtension.class)
class SpyTest {
@Test
public void whenMockAnnotation() {
List<String> mockList = Mockito.spy(new ArrayList<String>());
//these methods will work!
mockList.add("one");
mockList.add("two");
}
}
In zijn eenvoudigste vorm leidt een oproep naar een wrapper-object eenvoudigweg oproepen om naar het oorspronkelijke object, de verwijzing waarnaar het in zichzelf bewaart . Alles zal net zo werken als met het originele object.
U kunt ook een wrapper maken met behulp van de annotatie - @Spy
.
@ExtendWith(MockitoExtension.class)
class SpyTest {
@Spy
List mockList = new ArrayList<String>();
@Test
public void whenMockAnnotation() {
// these methods will work!
mockList.add("one");
mockList.add("two");
}
}
Deze twee codevoorbeelden zijn equivalent.
GO TO FULL VERSION