zombando de objetos

3.1 Método doReturn()

Agora vem a mágica...

Digamos que você criou um objeto fictício falso, mas precisa que funcione de alguma forma. Quando certos métodos foram chamados, algo importante foi feito ou os métodos retornaram um determinado resultado. O que fazer?

A biblioteca Mockito permite adicionar o comportamento desejado a um objeto fictício.

Se você deseja que um objeto simulado retorne um determinado resultado quando um determinado método é chamado, essa “regra” pode ser adicionada ao objeto usando o código:

Mockito.doReturn(result).when(an object).method name();

Você vê, no final da chamada do método, method name?não há realmente nenhuma chamada acontecendo aqui. O método doReturn()retorna um objeto proxy especial com a ajuda do qual monitora as chamadas dos métodos do objeto e, assim, a regra é escrita.

De novo. É uma maneira inteligente de escrever uma regra para adicionar a um objeto fictício . É preciso alguma habilidade para interpretar corretamente esse código em sua cabeça quando você o vê. Vem com experiência.

Acho que é necessário um exemplo concreto. Vamos criar um objeto de classe fictícia ArrayListe pedir a seu método size()que retorne o número 10. O código completo ficará assim:

@ExtendWith(MockitoExtension.class)
class DoReturnTest {
    @Mock
    List mockList;

    @Test
    public void whenMockAnnotation () {
         //create a rule: return 10 when calling the size method
        Mockito.doReturn(10).when(mockList).size();

        //the method is called here and will return 10!!
        assertEquals(10, mockList.size());
    }
}

Sim, este código funcionará, o teste não falhará.

3.2 método when()

Há outra maneira de adicionar uma regra de comportamento a um objeto fictício - chamando o método Mockito.when(). Se parece com isso:

Mockito.when(an object.method name()).thenReturn(result);

Essa é a mesma maneira de escrever uma regra de comportamento de objeto fictício como a anterior. Comparar:

Mockito.doReturn(result).when(an object).method name();

Aqui acontece exatamente a mesma coisa - a construção de uma nova regra.

É verdade que o primeiro exemplo tem dois pontos negativos:

• a chamada é muito confusa.an object.method name()
• não funcionará se o método methodname()retornar void.

Bem, vamos escrever nosso exemplo favorito usandoMockito.when()

@ExtendWith(MockitoExtension.class)
class WhenTest {
    @Mock
    List mockList;

    @Test
    public void whenMockAnnotation() {
        //create a rule: return 10 when calling the size method
        Mockito.when(mockList.size() ).thenReturn(10);

        //the method is called here and will return 10!!
        assertEquals(10, mockList.size());
    }
}

3.3 método doThrow()

Descobrimos como fazer um método de objeto fictício retornar um resultado específico. Como posso fazer isso lançar uma exceção específica? Enviar para doReturn()?

Para evitar que o método retorne, ou seja, lançar uma exceção, você precisa definir a regra usando o doThrow().

Mockito.doThrow(exception.class).when(an object).method name();

E então a segunda opção:

Mockito.when(an object.method name()).thenThrow(exception.class);

Um pouco esperado, certo?

Bem, você vê, você já está começando a entender. Vamos consertar com um exemplo:

@ExtendWith(MockitoExtension.class)
class DoThrowTest {
    @Mock
    List mockList;

    @Test
    public void whenMockAnnotation() {
        Mockito.when(mockList.size() ).thenThrow(IllegalStateException.class);
        mockList.size(); //an exception will be thrown here
    }
}

Se você precisar lançar um objeto de exceção específico, use a construção do formulário:

Mockito.doThrow(new Exception()).when(an object).method name();

Basta passar doThrow()um objeto de exceção para o método e ele será lançado durante a chamada do método.