Mock Objects con Mockito

mockito es un framework para trabajar con objetos mock, es decir objetos falsos o simulados. Mockito trata de ser más simple de usar que otras librerías predecesoras como jmock o easymock.

¿Para qué necesitamos objetos simulados? por muchos motivos cuando queremos hacer pruebas unitarias de nuestras clases puede que dependamos de otras clases que tengan alguna pega:

- Son lentas (jdbc, redes, ...)

- No devuelven un resultado concreto

- No se tienen a mano o dependen de algo externo.

- Sencillamente aún no están creadas

En fin, el caso es que puede que haya objetos que necesitemos simularlos a la hora de poder hacer test unitarios de nuestras clases.

Vamos a ver un par de ejemplos en los que se crea una instancia de la clase List falsa y otro ejemplo en el que creamos un BufferedReader de palo.

Mocked List

import static org.mockito.Mockito.*;

import java.util.List;
/**
 * @author Pello Altadill
 * @greetz ñañañaa MOOOOOOOOOCK (vuvuzela)
 */
public class MockList {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // We create a mock list using List interface
        // So, this is a false or mocked list
        List mockedList = mock(List.class);
        
        // We add something to the list
        mockedList.add("Example");
        mockedList.add("Another example");

        // This will return null
        System.out.println("Is anything there?: " + mockedList.get(0));
        
        
        // Now we establish: when we call get(0) on out list we
        // want to return "Pain in the ass"
        // This is Stubbing
        when(mockedList.get(0)).thenReturn("Pain in the ass");
        
        // We verify that we have stubbed this invocation
        // nothing will happen in this case.
        verify(mockedList).add("Example");
        
        // Now, this will return: "Pain in the ass"
        System.out.println("Let's see: " + mockedList.get(0));
        
        // And this one will return  null
        System.out.println("And what about this: " + mockedList.get(1));
        
        // This will throw an Exception because add("Another Exception")
        // invocation is not stubbed
        verify(mockedList).add("Another Example");
        
    }

}
 

Mocked BufferedReader

import static org.mockito.Mockito.*;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;


/**
 * We mock a BufferedReader using mockito
 * @author Pello Xabier Altadill Izura
 * @greetz UuuuuuoooAaaaaUUUaa
 */
public class MockFile {

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        // We create an instance of a false or mocked BufferedReader
        BufferedReader mockBufferedReader = mock(BufferedReader.class);
        
        // Then we stub readLine() function. It will return "747:John:Doe"
        when(mockBufferedReader.readLine()).thenReturn("747:John:Doe");
        
        // We establish that when mocked reader calls close an exception
        // will be thrown
        doThrow(new IOException()).when(mockBufferedReader).close();
        
        // Let's try
        System.out.println("First line: " + mockBufferedReader.readLine());
        
        // Now we close...
        mockBufferedReader.close();
        
        BufferedReader anotherMockReader;
        
        
    }

}