Annotazioni Mockito di base

2.1 Annotazione @Mock

Ci sono due modi per lavorare con oggetti fittizi in Mockito. Il primo è creare un oggetto completamente virtuale , il secondo è avvolgere un oggetto esistente in un wrapper. Iniziamo con il primo.

Per creare un oggetto completamente virtuale, devi scrivere il codice:

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

Creiamo una finta classe ArrayList come esempio:

@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 questo esempio, creiamo un falso ArrayList e memorizziamo un riferimento ad esso nella variabile mockList. I metodi di questo oggetto non fanno nulla.

A proposito, questo codice può essere scritto anche più breve, poiché esiste un'annotazione speciale per questo @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");
    }
}

Nel secondo caso, MockitoExtensionanalizzerà il codice della classe stesso e creerà gli stub necessari. Non è necessario chiamare il metodo Mockito.mock(). Un'annotazione e l'oggetto virtuale è pronto. Bellezza.

2.2 Annotazione @Spy

Il secondo importante tipo di oggetti in Mockito sono i wrapper su oggetti esistenti. Consentono, da un lato, di utilizzare le classi esistenti e, dall'altro, di intercettare le chiamate a tutti i metodi e le variabili di tali oggetti: per correggere il loro lavoro ove necessario. Sono usati tanto spesso quanto gli oggetti Mock.

Per creare un wrapper su un oggetto, devi scrivere il codice:

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

Un esempio con un wrapper attorno alla classe 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");
    }
}

Nella sua forma più semplice, una chiamata a un oggetto wrapper reindirizza semplicemente le chiamate all'oggetto originale, il riferimento a cui mantiene dentro di sé . Tutto funzionerà proprio come con l'oggetto originale.

Puoi anche creare un wrapper usando l'annotazione - @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");
    }
}

Questi due esempi di codice sono equivalenti.