Grundlæggende Mockito-anmærkninger

2.1 @Mock annotation

Der er to måder at arbejde med falske objekter på i Mockito. Den første er at skabe et fuldstændig virtuelt objekt , den anden er at pakke et eksisterende objekt ind i en wrapper. Lad os starte med den første.

For at oprette et fuldstændig virtuelt objekt skal du skrive koden:

ClassName variable name = Mockito.mock(ClassName.class);

Lad os oprette en mock ArrayList-klasse som et eksempel:

@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");
    }
}

I dette eksempel opretter vi en falsk ArrayList og gemmer en reference til den i mockList-variablen. Metoderne til dette objekt gør intet.

Forresten kan denne kode skrives endnu kortere, da der er en speciel anmærkning til denne @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");
    }
}

I det andet tilfælde MockitoExtensionvil den analysere selve klassekoden og skabe de nødvendige stubber. Du behøver ikke at kalde metoden Mockito.mock(). En annotation og det virtuelle objekt er klar. Skønhed.

2.2 @Spion-anmærkning

Den anden vigtige type objekter i Mockito er indpakninger over eksisterende objekter. De tillader på den ene side at bruge eksisterende klasser, og på den anden side at opsnappe opkald til alle metoder og variabler for sådanne objekter: at rette deres arbejde, hvor det er nødvendigt. De bruges lige så ofte som Mock-objekter.

For at oprette en indpakning over et objekt skal du skrive koden:

ClassName variable name = Mockito.spy(an object);

Et eksempel med en indpakning omkring ArrayList-klassen:

@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");
    }
}

I sin enkleste form omdirigerer et kald til et wrapper-objekt blot kald til det originale objekt, den reference, som det holder inde i sig selv . Alt fungerer ligesom med det originale objekt.

Du kan også oprette en indpakning ved hjælp af annoteringen - @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");
    }
}

Disse to kodeeksempler er ækvivalente.