Adnotări de bază Mockito

2.1 @Adnotare simulată

Există două moduri de a lucra cu obiecte simulate în Mockito. Primul este de a crea un obiect complet virtual , al doilea este de a împacheta un obiect existent într-un înveliș. Să începem cu primul.

Pentru a crea un obiect complet virtual, trebuie să scrieți codul:

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

Să creăm o clasă simulată ArrayList ca exemplu:

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

În acest exemplu, creăm un ArrayList fals și stocăm o referință la acesta în variabila mockList. Metodele acestui obiect nu fac nimic.

Apropo, acest cod poate fi scris și mai scurt, deoarece există o adnotare specială pentru acest @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");
    }
}

În al doilea caz, MockitoExtensionva analiza codul clasei în sine și va crea stub-urile necesare. Nu trebuie să apelați metoda Mockito.mock(). O adnotare și obiectul virtual este gata. Frumuseţe.

2.2 Adnotare @Spy

Al doilea tip important de obiecte din Mockito sunt învelișurile peste obiectele existente. Ele permit, pe de o parte, utilizarea claselor existente, iar pe de altă parte, interceptarea apelurilor către toate metodele și variabilele unor astfel de obiecte: pentru a le corecta munca acolo unde este necesar. Sunt folosite la fel de des ca și obiectele simulate.

Pentru a crea un wrapper peste un obiect, trebuie să scrieți codul:

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

Un exemplu cu un wrapper în jurul clasei 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");
    }
}

În forma sa cea mai simplă, un apel către un obiect wrapper redirecționează pur și simplu apelurile către obiectul original, referința la care o păstrează în sine . Totul va funcționa la fel ca cu obiectul original.

De asemenea, puteți crea un wrapper folosind adnotarea - @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");
    }
}

Aceste două exemple de cod sunt echivalente.