Mockito: cómo verificar que nunca se invocó un simulacro

Question

Estoy buscando una forma de verificar con Mockito, que no hubo interacción con un simulacro determinado durante una prueba. Es fácil lograr eso para un método dado con el modo de verificación never(), pero todavía no he encontrado una solución para el simulacro completo.

Lo que realmente quiero lograr: verificar en las pruebas, que nada se imprima en la consola. La idea general con jUnit va así:

private PrintStream systemOut; 

@Before 
public void setUp() { 
    // spy on System.out 
    systemOut = spy(System.out); 
} 

@After 
public void tearDown() { 
    verify(systemOut, never()); // <-- that doesn't work, just shows the intention 
} 

Un PrintStream tiene toneladas de métodos y realmente no quieren para verificar todos y cada uno por separado con verificar - y lo mismo para System.err ...

Así que espero, si hay una solución fácil, que puedo, dado que tengo una buena cobertura de prueba, forzar a los ingenieros de software (y a mí) a eliminar su (mi) código de depuración como System.out.println("Breakpoint#1"); o e.printStacktrace(); antes de confirmar los cambios.

Answer 1

Utilice esta:

import static org.mockito.Mockito.verifyZeroInteractions; 

// ... 

private PrintStream backup = System.out; 

@Before 
public void setUp() { 
    System.setOut(mock(PrintStream.class)); 
} 

@After 
public void tearDown() { 
    verifyZeroInteractions(System.out); 
    System.setOut(backup); 
} 

Answer 2

verifyZeroInteractions(systemOut); 

Como se señala en los comentarios, esto no funciona con un espía.

Para una respuesta más o menos equivalente, pero más completa, vea la respuesta de gontard a esta pregunta.

Answer 3

usted podría intentar un rumbo ligeramente diferente:

private PrintStream stdout; 

@Before public void before() { 
    stdout = System.out; 
    OutputStream out = new OutputStream() { 
     @Override public void write(int arg0) throws IOException { 
      throw new RuntimeException("Not allowed"); 
     } 
    }; 
    System.setOut(new PrintStream(out)); 
} 

@After public void after() { 
    System.setOut(stdout); 
} 

Si se prefiere, se puede cambiar el tipo anónimo para una maqueta y verificar as Don Roby suggests.

Answer 4

Una forma de resolver este problema es refactorizar la clase que se está probando, para permitir la inyección de un PrintStream que se puede utilizar para la salida. Esto le permitirá probarlo en una unidad, sin depender del comportamiento de la clase System. Puede usar un constructor privado de paquete para esta inyección, ya que solo lo usará de la clase de prueba correspondiente. Por lo tanto, podría verse algo como esto.

public class MyClass{ 
    private PrintWriter systemOut; 

    public MyClass(){ 
     this(System.out); 
    } 

    MyClass(PrintWriter systemOut){ 
     this.systemOut = systemOut; 

     // ...any other initialisation processing that you need to do 
    } 
} 

y dentro de la propia clase, utilizar la variable SystemOut en lugar de System.out donde se llama a este último.

Ahora, dentro de la clase de prueba, haga una simulación PrintStream y páselo al constructor privado del paquete para obtener el objeto que va a probar. Ahora puede ejecutar las acciones que desee de sus pruebas y usar verify para verificar sus efectos en su simulacro PrintStream.