UMC – ACET – SISTEMAS DE INFORMAÇÃO – TESTE DE SOFTWARE – PROF. MÁRIO G.

GODINHO
EXEMPLOS DE USO DA CAIXA DE FERRAMENTAS MOCKITO
OBJETIVO:
- Praticar o uso da caixa de ferramentas Mockito.
DESENVOLVIMENTO
Nesta aula você deverá criar um novo projeto de biblioteca de classe Java. Neste projeto, você criará várias classes de
teste JUnit4 para exercitar o uso de algumas funcionalidades do Mockito.
1. Para criar um objeto duble de uma determinada classe (ou mock object), use mock(class). Depois de criado o
objeto, use when(mock.método_invocado()).thenReturn(valor) para fazer com que o Mockito retorne “valor”
quando o método_invocado() for chamado. Se você especificar mais do que um valor, eles serão retornados na
mesma sequência na qual foram especificados até que o último valor da sequência seja usado. Depois disso, o
método do duble retornará sempre o ultimo valor especificado. No exemplo a seguir, o Mockito é usado para
criar um duble de um iterador (cursor ou iterator) e para fazer o duble retornar “Olá” da primeira vez que o
método next() for chamado. Todas as chamadas subsequentes para o método next() retornarão “Mundo”.
Feitos esses ajustes, podemos fazer asserções. O primeiro teste a ser inserido no seu projeto é o abaixo. Digite-
o e execute-o.
import static org.mockito.Mockito.*;
import static org.junit.Assert.*;
import java.util.Iterator;
import org.junit.Test;

@Test
public void iterator_deve_retornar_ola_mundo(){
// organização
Iterator i=mock(Iterator.class);
when(i.next()).thenReturn("Hello").thenReturn("World");
//ação
String result=i.next()+" "+i.next();
//asserção
assertEquals("Hello World", result);
}

2. Os dubles também conseguem retornar valores diferentes dependendo dos argumentos passados dentro do
método. No exemplo a seguir o Mockito é usado para criar um objeto duble da classe Comparable. O duble é
instruído a retornar 1 quando for comparado com a String “Teste”. Digite e execute o teste abaixo no mesmo
projeto.
@Test
public void with_arguments(){
Comparable c=mock(Comparable.class);
when(c.compareTo("Teste")).thenReturn(1);
assertEquals(1,c.compareTo("Test"));
}
3. Se o método tiver que receber argumentos mas não for possível prever qual valor será passado ou não fizer
diferença o valor passado, pode-se usar anyInt() (e comparadores diferentes para outros tipos de dados). No
exemplo a seguir, o objeto duble da classe Comparable retorna -1 para qualquer valor inteiro passado como
parâmetro. Digite e execute o terceiro teste, como está listado abaixo.
@Test
public void with_unspecified_arguments(){
Comparable c=mock(Comparable.class);
when(c.compareTo(anyInt())).thenReturn(-1);
assertEquals(-1,c.compareTo(5));
}
4. O uso com métodos que retornam void é um pouco intrincado, já que não é possível usa-los na chamada a
when(). A sintaxe alternativa é usar doReturn(result).when(mock_object).void_method_call(); Ao invés de
retornar, também pode-se usar thenThrow() ou doThrow() para métodos void. No exemplo a seguir, é
disparada uma exceção IOException quando o método close do duble de OutputStream é chamado. Verifica-se
que OutputStreamWriter redispara a exceção do fluxo de saída empacotado por ele.
@Test(expected=IOException.class)
public void OutputStreamWriter_rethrows_an_exception_from_OutputStream()
throws IOException{
// organiza
OutputStream mock=mock(OutputStream.class);
OutputStreamWriter osw=new OutputStreamWriter(mock);
 doThrow(new IOException()).when(mock).close();
// atua
osw.close();
}
5. Para verificar chamadas a métodos de objetos (uso típico de objetos duble), pode-se usar
verify(mock_object).method_call. O exemplo a seguir verifica que OutputStreamWriter propaga a chamada ao
método close para o fluxo de saída empacotado. É possível usar argumentos e comparadores (como anyInt())
em métodos de modo semelhante ao usado no exemplo anterior. Note que não é possível misturar literais com
comparadores, assim, se existirem múltiplos arguments eles devem ser todos literais ou todos comparadores.
Use o comparador eq(value) para converter um literal em um comparador que seja equivalente. O Mockito
vem com muitos comparadores. Digite e execute o teste abaixo no mesmo projeto.
@Test
public void OutputStreamWriter_Closes_OutputStream_on_Close()
throws IOException{
OutputStream mock=mock(OutputStream.class);
OutputStreamWriter osw=new OutputStreamWriter(mock);
osw.close();
verify(mock).close();
}
6. Feche seu projeto e o IDE NetBeans.