En el tutorial de introducción
a mockito vimos ciertos ejemplo de cómo realizar ciertas operaciones con
mockito. En este tutorial vamos a ver un ejemplo más cercano a la vida real que
nos ilustre la potencia de utilizar mock objects en nuestras pruebas.
El ejemplo trata de un manager de sistemas remotos, que accede a dos capas
de datos diferentes: una de autenticación de usuarios y otra donde busca los
datos de los sistemas remotos con losa que trabajar (pensad que es un ejemplo y
el código no es funcional, pero eso es lo interesante).
Para el ejemplo sólo se han definido las interfaces de los DAO de
autenticación y de acceso a datos de sistemas, y sin embargo podremos hacer
pruebas de nuestro manager, ¡gracias a mockito!, potente, ¿no creeis?.
Código de ejemplo
Os podéis descargar el proyecto completo de eclipse de SystemManager (contruido con Maven).
Veamos el código de la clase a probar:
public class SystemManager {
private final AuthDAO authDao;
private final GenericDAO dao;
public SystemManager(AuthDAO authDao, GenericDAO dao) {
super();
this.authDao = authDao;
this.dao = dao;
}
public void startRemoteSystem(String userId, String remoteId) throws SystemManagerException {
final User auth = authDao.getAuthData(userId);
try {
Collection
los dao no son mas que interfaces:
public interface GenericDAO {
/**
* Obtiene datos filtrados de la capa subyacente
*
* @param auth informacion de autenticacion para roles
* @param filter filtro para la informacion. Si filter es null se devuelven todos los datos
* @return coleccion de objetos obtenidos
* @throws OperationNotSupportedException si no se puede realizar la operacion por
* permisos
*/
public Collection
No nos queda ver más que los test, que son autoexplicativos, utilizando
mockito y junit 4
package com.autentia.mockitoExample;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import static org.mockito.Matchers.*;
import java.util.ArrayList;
import javax.naming.OperationNotSupportedException;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnit44Runner;
import com.autentia.mockitoExample.dao.AuthDAO;
import com.autentia.mockitoExample.dao.GenericDAO;
import com.autentia.mockitoExample.dao.User;
//runner de mockito que detecta las anotaciones
@RunWith(MockitoJUnit44Runner.class)
public class SystemManagerTest {
// generamos un mock con anotaciones
@Mock
private AuthDAO mockAuthDao;
// generamos un mock mediante el metodo mock
private GenericDAO mockGenericDao = mock(GenericDAO.class);
// variable inOrder de mockito para comprobar llamadas en orden
private InOrder ordered;
// el manager a testear
private SystemManager manager;
// Un usuario valido, para pruebas
private static final User validUser = new User("1", "German", "Jimenez",
"Madrid", new ArrayList
Conclusiones
Podéis observar lo sencillo que es realizar pruebas usando mocks. De esta
forma nos centramos en probar el manager, olvidando los posibles errores, o los
requisitos de configuración de las capas subyacentes. Lo más importante es ver
que no estamos probando nada del dao, sólo verificando que el manager realiza
las llamadas correctas.
Ya sabéis que podéis contactar con nosotros en Autentia si tenéis alguna duda o
necesitáis de nuestros servicios.
