Grundläggande Mockito-anteckningar

2.1 @Slötkommentar

Det finns två sätt att arbeta med skenobjekt i Mockito. Det första är att skapa ett helt virtuellt objekt , det andra är att linda in ett befintligt objekt i ett omslag. Låt oss börja med den första.

För att skapa ett helt virtuellt objekt måste du skriva koden:

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

Låt oss skapa en mock ArrayList-klass som ett exempel:

@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 det här exemplet skapar vi en falsk ArrayList och lagrar en referens till den i mockList-variabeln. Metoderna för detta objekt gör ingenting.

Förresten, den här koden kan skrivas ännu kortare, eftersom det finns en speciell anteckning för detta @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 andra fallet MockitoExtensionkommer den att analysera själva klasskoden och skapa de nödvändiga stubbarna. Du behöver inte anropa metoden Mockito.mock(). En anteckning och det virtuella objektet är klart. Skönhet.

2.2 @Spy-anteckning

Den andra viktiga typen av objekt i Mockito är omslag över befintliga objekt. De tillåter å ena sidan att använda befintliga klasser, och å andra sidan att fånga upp anrop till alla metoder och variabler för sådana objekt: att korrigera deras arbete där det behövs. De används lika ofta som Mock-objekt.

För att skapa ett omslag över ett objekt måste du skriva koden:

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

Ett exempel med ett omslag runt 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 enklaste form, omdirigerar ett anrop till ett wrapper-objekt helt enkelt anrop till det ursprungliga objektet, referensen till vilket det håller i sig självt . Allt kommer att fungera precis som med originalobjektet.

Du kan också skapa ett omslag med anteckningen - @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");
    }
}

Dessa två kodexempel är likvärdiga.