Basis Mockito-annotaties

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 MockitoExtensionzal 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.