java - examples - Cómo hacer simulacros de anular métodos con mockito.

mockito examples in java

Question

¿Cómo simular métodos con tipo de retorno vacío?

Implementé un patrón de observador pero no puedo burlarme de Mockito porque no sé cómo.

Y traté de encontrar un ejemplo en Internet, pero no tuve éxito.

Mi clase se parece a

public class World {
List<Listener> listeners;
void addListener(Listener item) {
listeners.add(item);
}
void doAction(Action goal,Object obj) {
setState("i received");
goal.doAction(obj);
setState("i finished");
}
private string state;
//setter getter state
}
public class WorldTest implements Listener {
@Test public void word{
World w= mock(World.class);
w.addListener(this);
...
...
}
}
interface Listener {
void doAction();
}

El sistema no se activa con el simulacro. = (Quiero mostrar el estado del sistema mencionado anteriormente. Y hacer una afirmación de acuerdo con ellos.

Answer 1

@ashley: funciona para mí

public class AssetChangeListenerImpl extends
AbstractAssetChangeListener implements AssetChangeListener {
@Override
public void onChangeEvent(final EventMessage message) throws EventHubClientException {
execute(message);
}
}
}
public class AbstractAssetChangeListener {
protected void execute( final EventMessage message ) throws EventHubClientException {
executor.execute( new PublishTask(getClient(), message) );
} } @RunWith(MockitoJUnitRunner.class) public class AssetChangeListenerTest extends AbstractAssetChangeListenerTest {
public void testExecute() throws EventHubClientException {
EventMessage message = createEventMesage(EventType.CREATE);
assetChangeListener.execute(message);
verify(assetChangeListener, times(1)).execute(message);
} }

Answer 2

Añadiendo otra respuesta al grupo (sin juego de palabras) ...

Es necesario que llame al método doAnswer si no puede / no quiere usar el espía. Sin embargo, no necesariamente tiene que hacer rodar su propia Answer . Hay varias implementaciones por defecto. En particular, CallsRealMethods .

En la práctica, se ve algo como esto:

doAnswer(new CallsRealMethods()).when(mock)
.voidMethod(any(SomeParamClass.class));

O:

doAnswer(Answers.CALLS_REAL_METHODS.get()).when(mock)
.voidMethod(any(SomeParamClass.class));

Answer 3

Agregando a lo que dijo @sateesh, cuando solo quieres simular un método vacío para evitar que la prueba lo llame, podrías usar un Spy esta manera:

World world = new World();
World spy = Mockito.spy(world);
Mockito.doNothing().when(spy).methodToMock();

Cuando desee ejecutar su prueba, asegúrese de llamar al método en prueba en el objeto spy y no en el objeto world . Por ejemplo:

assertEquals(0,spy.methodToTestThatShouldReturnZero());

Answer 4

Creo que he encontrado una respuesta más sencilla a esa pregunta, para llamar al método real para un solo método (incluso si tiene un retorno nulo), puede hacer esto:

Mockito.doCallRealMethod().when(<objectInstance>).<method>();
<objectInstance>.<method>();

O bien, podría llamar al método real para todos los métodos de esa clase, haciendo esto:

<Object> <objectInstance> = mock(<Object>.class, Mockito.CALLS_REAL_METHODS);

Answer 5

Creo que tus problemas se deben a la estructura de tu prueba. Me ha resultado difícil mezclar la burla con el método tradicional de implementación de interfaces en la clase de prueba (como lo ha hecho aquí).

Si implementa el oyente como un simulacro, puede verificar la interacción.

Listener listener = mock(Listener.class);
w.addListener(listener);
world.doAction(..);
verify(listener).doAction();

Esto debería satisfacerle de que el ''Mundo'' está haciendo lo correcto.

Answer 6

Echa un vistazo a los documentos API de Mockito. Como lo menciona el documento vinculado (Punto # 12), puede utilizar cualquiera de los doThrow() , doAnswer() , doNothing() , doReturn() de Mockito framework para simular los métodos del vacío.

Por ejemplo,

Mockito.doThrow(new Exception()).when(instance).methodName();

o si quieres combinarlo con un comportamiento de seguimiento,

Mockito.doThrow(new Exception()).doNothing().when(instance).methodName();

Suponiendo que usted está mirando burlándose del setState(String s) en la clase Mundo a continuación, el código utiliza el método doAnswer para burlarse del setState .

World mockWorld = mock(World.class);
doAnswer(new Answer<Void>() {
public Void answer(InvocationOnMock invocation) {
Object[] args = invocation.getArguments();
System.out.println("called with arguments: " + Arrays.toString(args));
return null;
}
}).when(mockWorld).setState(anyString());

Answer 7

En Java 8, esto se puede hacer un poco más limpio, asumiendo que tiene una importación estática para org.mockito.Mockito.doAnswer :

doAnswer(i -> {
// Do stuff with i.getArguments() here
return null;
}).when(*mock*).*method*(*methodArguments*);

La return null; es importante y sin ella la compilación fallará con algunos errores bastante oscuros, ya que no podrá encontrar una anulación adecuada para doAnswer .

Por ejemplo, un ExecutorService que ejecuta inmediatamente cualquier Runnable pasado a execute() podría implementarse usando:

doAnswer(i -> {
((Runnable) i.getArguments()[0]).run();
return null;
}).when(executor).execute(any());

Answer 8

En primer lugar: siempre debe importar mockito static, de esta manera el código será mucho más legible (e intuitivo):

import static org.mockito.Mockito.*;

Para burlarse parcialmente y aún mantener la funcionalidad original en el resto, mockito ofrece "Spy".

Puedes usarlo de la siguiente manera:

private World world = spy(World.class);

Para eliminar la ejecución de un método, puedes usar algo como esto:

doNothing().when(someObject).someMethod(anyObject());

para darle un comportamiento personalizado a un método, use "when" con un "thenReturn":

doReturn("something").when(this.world).someMethod(anyObject());

Para más ejemplos, por favor encuentre las muestras de mockito en el documento.

Answer 9

La solución del llamado problema es usar un spy Mockito.spy(...) lugar de un mock Mockito.mock(..) .

El espía nos permite una burla parcial. Mockito es bueno en este asunto. Debido a que tienes una clase que no está completa, de esta manera te burlas de algún lugar requerido en esta clase.

Answer 10

Cómo burlarse de los métodos del vacío con mockito: hay dos opciones:

1. doAnswer : si queremos que nuestro método de vacío simulado haga algo (simule el comportamiento a pesar de ser vacío).
2. doThrow : luego está Mockito.doThrow() si desea lanzar una excepción desde el método del vacío simulado.

A continuación se muestra un ejemplo de cómo usarlo (no es un caso de uso ideal, pero solo quería ilustrar el uso básico).

@Test
public void testUpdate() {
doAnswer(new Answer<Void>() {
@Override
public Void answer(InvocationOnMock invocation) throws Throwable {
Object[] arguments = invocation.getArguments();
if (arguments != null && arguments.length > 1 && arguments[0] != null && arguments[1] != null) {
Customer customer = (Customer) arguments[0];
String email = (String) arguments[1];
customer.setEmail(email);
}
return null;
}
}).when(daoMock).updateEmail(any(Customer.class), any(String.class));
// calling the method under test
Customer customer = service.changeEmail("[email protected]", "[email protected]");
//some asserts
assertThat(customer, is(notNullValue()));
assertThat(customer.getEmail(), is(equalTo("[email protected]")));
}
@Test(expected = RuntimeException.class)
public void testUpdate_throwsException() {
doThrow(RuntimeException.class).when(daoMock).updateEmail(any(Customer.class), any(String.class));
// calling the method under test
Customer customer = service.changeEmail("[email protected]", "[email protected]");
}
}

Puede encontrar más detalles sobre cómo simularse y probar métodos vacíos con Mockito en mi publicación Cómo simularse con Mockito (Una guía completa con ejemplos)