Anotações Mockito Básicas

2.1 Anotação @Mock

Existem duas maneiras de trabalhar com objetos fictícios no Mockito. A primeira é criar um objeto totalmente virtual , a segunda é envolver um objeto existente em um wrapper. Vamos começar com o primeiro.

Para criar um objeto totalmente virtual, você precisa escrever o código:

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

Vamos criar uma classe simulada de ArrayList como exemplo:

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

Neste exemplo, criamos um ArrayList falso e armazenamos uma referência a ele na variável mockList. Os métodos deste objeto não fazem nada.

A propósito, esse código pode ser escrito ainda mais curto, pois há uma anotação especial para isso @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");
    }
}

No segundo caso, MockitoExtensionele analisará o próprio código da classe e criará os stubs necessários. Você não precisa chamar o método Mockito.mock(). Uma anotação e o objeto virtual está pronto. Beleza.

2.2 Anotação @Spy

O segundo tipo importante de objetos no Mockito são wrappers sobre objetos existentes. Eles permitem, por um lado, usar classes existentes e, por outro lado, interceptar chamadas para todos os métodos e variáveis ​​​​de tais objetos: corrigir seu trabalho quando necessário. Eles são usados ​​com a mesma frequência que os objetos Mock.

Para criar um wrapper sobre um objeto, você precisa escrever o código:

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

Um exemplo com um wrapper em torno da 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");
    }
}

Em sua forma mais simples, uma chamada para um objeto wrapper simplesmente redireciona as chamadas para o objeto original, cuja referência ele mantém dentro de si . Tudo funcionará exatamente como com o objeto original.

Você também pode criar um wrapper usando a anotação - @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");
    }
}

Esses dois exemplos de código são equivalentes.