Diferencia entre revisiones de «Mockito»

De Dos Ideas.
Saltar a: navegación, buscar
(PTAaewZPdqrIQ)
(Deshecha la edición 6179 de 209.0.141.71 (disc.))
Línea 1: Línea 1:
Thanky Thanky for all this good ifnoartmion!
+
Mockito es una librería [[Java]] para la creación de [[Mock Object]] muy usados para el testeo unitario en [[Test Driven Development]], basado en [[EasyMock]].
 +
 
 +
Mockito fue creado con el objetivo de simplificar y solucionar algunos de los temas antes mencionados. EasyMock y Mockito puede hacer exactamente las mismas cosas, pero Mockito tiene un API más natural y práctico de usar.
 +
 
 +
==Características principales==
 +
# Se pueden crear mocks de interfaces y clases concretas.
 +
# Verificación de invocaciones (cantidad exacta, al menos una vez, órden de invocación, etc.)
 +
# El stack trace se mantiene limpio, ya que los errores ocurren en los assert que se hagan (y no dentro del método bajo prueba, como en EasyMock).
 +
# Un API más clara para crear stubs y verificaciones
 +
 
 +
==Ejemplo de uso==
 +
<code java>
 +
import static org.mockito.Mockito.*;
 +
.....
 +
//creamos el mock y el stub
 +
ArrayList instance = mock(ArrayList.class);
 +
doReturn("hola mundo").when(instance).get(0);
 +
 +
//ejecutamos la lógica a probar
 +
instance.get(0);   
 +
 +
//verificamos que se hayan invocado los métodos
 +
verify(instance).get(0);
 +
</code>
 +
 
 +
==Más de una invocación a un mismo método==
 +
 
 +
Algunas veces necesitamos que un método retorne un valor y que en la segunda invocación retorne nulo o una excepción. Para eso, anidamos los retornos:
 +
 
 +
<code html4strict>
 +
 
 +
//Retornos para las 2 invocaciones
 +
doReturn("algo").doReturn(null).when(instance).scrollNext();
 +
 
 +
//ejecutamos la lógica a probar
 +
instance.unMetodoQueUsaScroll();   
 +
 
 +
//verificamos que se haya invocado el mismo método dos veces
 +
verify(instance, times(2)).scrollNext();
 +
 
 +
</code>
 +
 
 +
* [http://mockito.googlecode.com/svn/branches/1.5/javadoc/org/mockito/Mockito.html Leer más en Mockito API]
 +
 
 +
It's spooky how celevr some ppl are. Thanks!
 +
 
 +
==Ejemplo de Mockito para mockear appender de log4j==
 +
 
 +
<code java>
 +
//Inicializamos mock.
 +
Appender mockAppender = mock(AppenderSkeleton.class);
 +
//Inicializamos logger de la clase bajo test
 +
Logger log = Logger.getLogger(ClaseATestear.class);
 +
//Agregamos el mock del appender al logger.
 +
log.addAppender(mockAppender);
 +
//Seteamos el nivel de log que nos interesa recuperar.
 +
log.setLevel(Level.DEBUG);
 +
</code>
 +
 
 +
Para poder obtener los log que se produjeron utilizamos la clase ArgumentCaptor de mockito que nos permite, entre otras cosas, capturar los eventos de log.
 +
 
 +
<code java>
 +
ArgumentCaptor loggingEventCaptor = ArgumentCaptor.forClass(LoggingEvent.class);
 +
 
 +
loggingEventCaptor.capture());
 +
</code>
 +
 
 +
Una posible forma de obtener un mensaje particular es iterando la lista de mensajes que nos da la clase capturada.
 +
 
 +
<code java>
 +
List<LoggingEvent> loggingEvent = (List<LoggingEvent>) loggingEventCaptor.getAllValues();
 +
</code>
 +
 
 +
== BDDMockito ==
 +
BDDMokcito es una clase alternativa que ofrece [[Mockito]] para crear pruebas al estilo [[Behavior Driven Development]] (BDD) (es decir, con bloques dado / cuando / entonces).
 +
 
 +
El problema es que el API de Mockito usa la palabra "when" y no se integra bien con los comentarios //given //when //then (según BDD, el stubbing forma parte del área //given, y no del //when).
 +
 
 +
BDDMockito agrega una clase que tiene alias para los métodos de stub, usando given(Object).
 +
 
 +
<code java5>
 +
import static org.mockito.BDDMockito.*;
 +
 +
Vendedor vendedor = mock(Vendedor.class);
 +
Negocio negocio = new Negocio(vendedor);
 +
 +
@Test
 +
public void comprarPan() throws Exception {
 +
  //given 
 +
  given(vendedor.buscarPan()).willReturn(new Pan());
 +
 
 +
  //when
 +
  Compra compra = negocio.comprarPan();
 +
 
 +
  //then
 +
  assertThat(compra, contienePan());
 +
}
 +
</code>
 +
 
 +
Stubbing con void y excepciones:
 +
<code java5>
 +
  //given
 +
  willThrow(new RuntimeException("boo")).given(mock).foo();
 +
 
 +
  //when
 +
  Result result = sistemaBajoPrueba.ejecutar();
 +
 
 +
  //then
 +
  assertEquals(failure, result);
 +
</code>
 +
 
 +
==Ver también==
 +
* [[EasyMock]]
 +
* [[Captura De Parametros]]
 +
* [[Inyeccion De Mocks De Mockito Con Spring]]
 +
* [http://www.dosideas.com/descargas/category/3-testing.html?download=11%3Ademo-de-mockito Proyecto de ejemplos con Mockito]
 +
* [http://www.dosideas.com/java/242-mockito-o-basta-de-easymock.html Introducción a Mockito]
 +
* [http://mockito.googlecode.com/svn/branches/1.8.0/javadoc/org/mockito/BDDMockito.html Javadoc de BDDMockito]
 +
 
 +
[[Category:TDD]]
 +
[[Category:BDD]]
 +
[[Category:JUnit]]

Revisión del 19:18 6 sep 2011

Mockito es una librería Java para la creación de Mock Object muy usados para el testeo unitario en Test Driven Development, basado en EasyMock.

Mockito fue creado con el objetivo de simplificar y solucionar algunos de los temas antes mencionados. EasyMock y Mockito puede hacer exactamente las mismas cosas, pero Mockito tiene un API más natural y práctico de usar.

Características principales

  1. Se pueden crear mocks de interfaces y clases concretas.
  2. Verificación de invocaciones (cantidad exacta, al menos una vez, órden de invocación, etc.)
  3. El stack trace se mantiene limpio, ya que los errores ocurren en los assert que se hagan (y no dentro del método bajo prueba, como en EasyMock).
  4. Un API más clara para crear stubs y verificaciones

Ejemplo de uso

import static org.mockito.Mockito.*; ..... //creamos el mock y el stub ArrayList instance = mock(ArrayList.class); doReturn("hola mundo").when(instance).get(0);

//ejecutamos la lógica a probar instance.get(0);

//verificamos que se hayan invocado los métodos verify(instance).get(0);

Más de una invocación a un mismo método

Algunas veces necesitamos que un método retorne un valor y que en la segunda invocación retorne nulo o una excepción. Para eso, anidamos los retornos:

//Retornos para las 2 invocaciones doReturn("algo").doReturn(null).when(instance).scrollNext();

//ejecutamos la lógica a probar instance.unMetodoQueUsaScroll();

//verificamos que se haya invocado el mismo método dos veces verify(instance, times(2)).scrollNext();

It's spooky how celevr some ppl are. Thanks!

Ejemplo de Mockito para mockear appender de log4j

//Inicializamos mock. Appender mockAppender = mock(AppenderSkeleton.class); //Inicializamos logger de la clase bajo test Logger log = Logger.getLogger(ClaseATestear.class); //Agregamos el mock del appender al logger. log.addAppender(mockAppender); //Seteamos el nivel de log que nos interesa recuperar. log.setLevel(Level.DEBUG);

Para poder obtener los log que se produjeron utilizamos la clase ArgumentCaptor de mockito que nos permite, entre otras cosas, capturar los eventos de log.

ArgumentCaptor loggingEventCaptor = ArgumentCaptor.forClass(LoggingEvent.class);

loggingEventCaptor.capture());

Una posible forma de obtener un mensaje particular es iterando la lista de mensajes que nos da la clase capturada.

List<LoggingEvent> loggingEvent = (List<LoggingEvent>) loggingEventCaptor.getAllValues();

BDDMockito

BDDMokcito es una clase alternativa que ofrece Mockito para crear pruebas al estilo Behavior Driven Development (BDD) (es decir, con bloques dado / cuando / entonces).

El problema es que el API de Mockito usa la palabra "when" y no se integra bien con los comentarios //given //when //then (según BDD, el stubbing forma parte del área //given, y no del //when).

BDDMockito agrega una clase que tiene alias para los métodos de stub, usando given(Object).

import static org.mockito.BDDMockito.*;

Vendedor vendedor = mock(Vendedor.class);
Negocio negocio = new Negocio(vendedor);

@Test
public void comprarPan() throws Exception {
  //given  
  given(vendedor.buscarPan()).willReturn(new Pan());
  
  //when
  Compra compra = negocio.comprarPan();
  
  //then
  assertThat(compra, contienePan());
} 

Stubbing con void y excepciones:

  //given
  willThrow(new RuntimeException("boo")).given(mock).foo();
  
  //when
  Result result = sistemaBajoPrueba.ejecutar();
  
  //then
  assertEquals(failure, result); 

Ver también