Mock pequeño => Mockito

Una cosa que nos gusta a todos los técnicos es poder comparar las diferentes alternativas para poder o bien elegir una de ellas o bien saber cual usar en cada caso. Pues bien, el otro día vimos el post explicando el inicio a la programación basada en mocks explicado con el ejemplo de EasyMock. En este post, como ya habréis podido adivinar, hablaré sobre una alternativa llamada Mockito.

Antes de nada vayamos a la historia para poder ser justos en la comparación, mockito nace a partir de EasyMock, de hecho nace creado por Szczepan Faber en 2008 dentro de The Guardian pues los actuales frameworks de mocks le parecían muy engorrosos. Inicialmente se basa en la sintaxis y funcionalidad de EasyMock, pero posteriormente pasa casi a reescribirlo por completo.

Por su parte EasyMock data de 2001 que algo ha llovido, y ya va por su versión 3.2, se trata de un framework con mucha más historia.

Ahora pasamos a ver la comparación directa con el caso de estudio del post anterior y después comentaremos las diferencias

Simulación de comportamiento

public class ReportMakerTest {

   @Test

   public void calculateReport_someUsers() {

       UserDao mock = Mockito.mock(UserDao.class);

       int expectedActiveUsers = 1;

       int expectedInactiveUsers = 3;

       Mockito.when(mock.getUsers()).thenReturn(createUsersToReturnByDao(expectedActiveUsers, expectedInactiveUsers));

       ReportMaker reportMaker = new ReportMaker(mock);

       Report actualReport = reportMaker.calculateReportFromPersistence();

       assertEquals(actualReport.getActiveUsers(), expectedActiveUsers);

       assertEquals(actualReport.getInactiveUsers(), expectedInactiveUsers);

   }

}

En mockito la simulación del comportamiento, que se conoce como stubbing, se hace usando el estilo when(…).thenReturn(…) muy similar al expect(…).andReturn(…) de EasyMock.

Comprobar la colaboración

    @Test
    public void calculateReport_checkCollaborationOnDao() {
        UserDao mock = Mockito.mock(UserDao.class);
        Mockito.when(mock.getUsers()).thenReturn(Collections.<User>emptySet());

        ReportMaker reportMaker = new ReportMaker(mock);
        reportMaker.calculateReportFromPersistence();

        Mockito.verify(mock).getUsers();
    }

Como véis es de manera muy parecida a EasyMock, usando el método verify.

Diferencias

Simulación de comportamiento

En el caso de mockito la inicialización es casi nula, sólo se debe llamar al método mock:

UserDao mock = Mockito.mock(UserDao.class);

y a partir de aquí se puede llamar a los métodos realizando, directamente en la misma llamada la sustitución del comportamiento deseado.

Mockito.when(mock.getUsers()).thenReturn(createUsersToReturnByDao(expectedActiveUsers, expectedInactiveUsers));

En el caso de EasyMock antes de poder empezar la ejecución debemos tener ya listos todos nuestros mocks y haberles dado al “replay”:

EasyMock.expect(userDao.getUsers()).andReturn(usersToReturnByDao);
EasyMock.replay(userDao);

Verificación

Siguiendo lo explicado anteriormente, la verificación también está en un punto diferente, en este caso se configura lo que queremos verificar justo en el momento de verificar:

Mockito.verify(mock).getUsers();

Al igual que con EasyMock se pueden configurar situaciones de ejecuciones N veces o situaciones de error, pero la gran diferencia es el lugar donde se verifican las cosas.

Conclusiones

Como podéis ver en el código fuente de github el código es algo más liviano en mockito. Otra cosa muy importante es que la configuración está en puntos distintos, en el caso de EasyMock es más una especificación a priori de lo que debe pasar, mientras que en el caso de mockito vamos diciendo a cada paso que queremos que pase y que queremos verificar.

Mockito tiene algunas cosas muy interesantes, como el poder espiar o suplantar objetos reales (no mocks). Esto puede oler mal, pero puede tener mucho sentido cuando se trabaja con legacy code. Otra cosa interesante es que no obliga a la verificación siempre en orden, sino que es relajado en este sentido. Y también cosas como verificar con timeout. O incluso tiene cosas como la inyección de dependencias!

En cierto sentido mockito es menos estricto y más flexible y parece ser menos verboso, lo cual se agradece. Obviamente también se puede argumentar que EasyMock deja mucho más claro lo que se está haciendo y tal vez es más formal.

Ah, se me olvidaba, el logo de mockito es muy molón! 😛

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s