Prueba JUnit para el sistema.fuera.println()

Sé que este es un hilo viejo, pero hay una bonita biblioteca para hacer esto:

Reglas del sistema

Ejemplo de los documentos:

public void MyTest {
    @Rule
    public final SystemOutRule systemOutRule = new SystemOutRule().enableLog();

    @Test
    public void overrideProperty() {
        System.out.print("hello world");
        assertEquals("hello world", systemOutRule.getLog());
    }
}

También le permitirá atrapar System.exit(-1) y otras cosas para las que una herramienta de línea de comandos tendría que ser probada.

Puede configurar el Sistema.out print stream vía setOut() (y para in y err). ¿Puede redirigir esto a un flujo de impresión que registra una cadena y luego inspeccionarlo ? Ese parece ser el mecanismo más sencillo.

(Yo abogaría, en algún momento, convertir la aplicación a algún marco de registro - pero sospecho que ya son conscientes de esto!)

En lugar de redireccionar System.out, refactorizaría la clase que usa System.out.println() pasando a PrintStream como colaborador y luego usando System.out en producción y a Test Spy en la prueba.

En producción

ConsoleWriter writer = new ConsoleWriter(System.out));

En la Prueba

ByteArrayOutputStream outSpy = new ByteArrayOutputStream();
ConsoleWriter writer = new ConsoleWriter(new PrintStream(outSpy));
writer.printSomething();
assertThat(outSpy.toString(), is("expected output"));

Discusión

De esta manera la clase bajo prueba se vuelve comprobable por una simple refactorización, sin tener la necesidad de redirección indirecta de la salida estándar o intercepción oscura con un regla del sistema.

Un poco fuera de tema, pero en caso de que algunas personas (como yo, cuando encontré este hilo por primera vez) podrían estar interesadas en capturar la salida de registro a través de SLF4J, commons-testing JUnit @Rule podría ayudar:

public class FooTest {
    @Rule
    public final ExpectedLogs logs = new ExpectedLogs() {{
        captureFor(Foo.class, LogLevel.WARN);
    }};

    @Test
    public void barShouldLogWarning() {
        assertThat(logs.isEmpty(), is(true)); // Nothing captured yet.

        // Logic using the class you are capturing logs for:
        Foo foo = new Foo();
        assertThat(foo.bar(), is(not(nullValue())));

        // Assert content of the captured logs:
        assertThat(logs.isEmpty(), is(false));
        assertThat(logs.contains("Your warning message here"), is(true));
    }
}

Descargo de responsabilidad :

• Desarrollé esta biblioteca ya que no pude encontrar ninguna solución adecuada para mis propias necesidades.
• Solo vinculaciones para log4j, log4j2 y logback están disponibles en este momento, pero estoy feliz de añadir más.

@dfa la respuesta es genial, así que lo llevé un paso más allá para hacer posible probar bloques de salida.

Primero creé TestHelper con un método captureOutput que acepta la clase annoymous CaptureTest. El método captureOutput hace el trabajo de establecer y derribar los flujos de salida. Cuando se llama a la implementación del método CaptureOutput's test, tiene acceso a la salida generada para el bloque de prueba.

Fuente para TestHelper:

public class TestHelper {

    public static void captureOutput( CaptureTest test ) throws Exception {
        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
        ByteArrayOutputStream errContent = new ByteArrayOutputStream();

        System.setOut(new PrintStream(outContent));
        System.setErr(new PrintStream(errContent));

        test.test( outContent, errContent );

        System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out)));
        System.setErr(new PrintStream(new FileOutputStream(FileDescriptor.out)));

    }
}

abstract class CaptureTest {
    public abstract void test( ByteArrayOutputStream outContent, ByteArrayOutputStream errContent ) throws Exception;
}

Tenga en cuenta que TestHelper y CaptureTest son definido en el mismo archivo.

Luego, en su prueba, puede importar el captureOutput estático. Aquí hay un ejemplo usando JUnit:

// imports for junit
import static package.to.TestHelper.*;

public class SimpleTest {

    @Test
    public void testOutput() throws Exception {

        captureOutput( new CaptureTest() {
            @Override
            public void test(ByteArrayOutputStream outContent, ByteArrayOutputStream errContent) throws Exception {

                // code that writes to System.out

                assertEquals( "the expected output\n", outContent.toString() );
            }
        });
}

Si estaba usando Spring Boot (mencionó que está trabajando con una aplicación antigua, por lo que probablemente no lo esté, pero podría ser útil para otros), entonces podría usar org.springframework.arranque.prueba.regla.OutputCapture de la siguiente manera:

@Rule
public OutputCapture outputCapture = new OutputCapture();

@Test
public void out() {
    System.out.print("hello");
    assertEquals(outputCapture.toString(), "hello");
}

No desea redirigir el sistema.out stream porque redirige para TODA la JVM. Cualquier otra cosa que se ejecute en la JVM puede estropearse. Hay mejores maneras de probar la entrada / salida. Mira en talones / burlas.

No se puede imprimir directamente usando el sistema .fuera.println o usando logger api mientras se usa JUnit. Pero si desea verificar cualquier valor, simplemente puede usar

Assert.assertEquals("value", str);

Lanzará debajo del error de aserción:

java.lang.AssertionError: expected [21.92] but found [value]

Su valor debe ser 21.92, ahora si va a probar usando este valor como debajo de su caso de prueba pasará.

 Assert.assertEquals(21.92, str);

For out

@Test
void it_prints_out() {

    PrintStream save_out=System.out;final ByteArrayOutputStream out = new ByteArrayOutputStream();System.setOut(new PrintStream(out));

    System.out.println("Hello World!");
    assertEquals("Hello World!\r\n", out.toString());

    System.setOut(save_out);
}

Para err

@Test
void it_prints_err() {

    PrintStream save_err=System.err;final ByteArrayOutputStream err= new ByteArrayOutputStream();System.setErr(new PrintStream(err));

    System.err.println("Hello World!");
    assertEquals("Hello World!\r\n", err.toString());

    System.setErr(save_err);
}

Ejemplo completo de JUnit 5 para probar System.out (reemplace la parte when):

package learning;

import static org.assertj.core.api.BDDAssertions.then;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

class SystemOutLT {

    private PrintStream originalSystemOut;
    private ByteArrayOutputStream systemOutContent;

    @BeforeEach
    void redirectSystemOutStream() {

        originalSystemOut = System.out;

        // given
        systemOutContent = new ByteArrayOutputStream();
        System.setOut(new PrintStream(systemOutContent));
    }

    @AfterEach
    void restoreSystemOutStream() {
        System.setOut(originalSystemOut);
    }

    @Test
    void shouldPrintToSystemOut() {

        // when
        System.out.println("example");

        then(systemOutContent.toString()).containsIgnoringCase("example");
    }
}

Basado en la respuesta de @dfa y otra respuesta que muestra cómo probar System.in , me gustaría compartir mi solución para dar una entrada a un programa y probar su salida.

Como referencia, utilizo JUnit 4.12.

Digamos que tenemos este programa que simplemente replica la entrada a la salida:{[18]]}

import java.util.Scanner;

public class SimpleProgram {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print(scanner.next());
        scanner.close();
    }
}

Para probarlo, podemos usar la siguiente clase:

import static org.junit.Assert.*;

import java.io.*;

import org.junit.*;

public class SimpleProgramTest {
    private final InputStream systemIn = System.in;
    private final PrintStream systemOut = System.out;

    private ByteArrayInputStream testIn;
    private ByteArrayOutputStream testOut;

    @Before
    public void setUpOutput() {
        testOut = new ByteArrayOutputStream();
        System.setOut(new PrintStream(testOut));
    }

    private void provideInput(String data) {
        testIn = new ByteArrayInputStream(data.getBytes());
        System.setIn(testIn);
    }

    private String getOutput() {
        return testOut.toString();
    }

    @After
    public void restoreSystemInputOutput() {
        System.setIn(systemIn);
        System.setOut(systemOut);
    }

    @Test
    public void testCase1() {
        final String testString = "Hello!";
        provideInput(testString);

        SimpleProgram.main(new String[0]);

        assertEquals(testString, getOutput());
    }
}

No voy a explicar mucho, porque creo que el código es legible y cité mi fuente.

Cuando JUnit ejecuta testCase1(), va a llamar a los métodos helper en el orden en que aparecen:

1. setUpOutput(), debido a la anotación @Before
2. provideInput(String data), llamado desde testCase1()
3. getOutput(), llamado desde testCase1()
4. restoreSystemInputOutput(), debido a la anotación @After

No probé System.err porque no lo necesitaba, pero debería ser fácil de implementar, similar a probar System.out.