System.out.println () için JUnit testi

Kötü tasarlanmış ve standart çıktıya bir sürü hata iletisi yazıyor eski bir uygulama için JUnit testleri yazmak gerekir. Ne zaman getResponse(String request)yöntemi doğru davranır bir XML yanıt verir:

@BeforeClass
public static void setUpClass() throws Exception {
    Properties queries = loadPropertiesFile("requests.properties");
    Properties responses = loadPropertiesFile("responses.properties");
    instance = new ResponseGenerator(queries, responses);
}

@Test
public void testGetResponse() {
    String request = "<some>request</some>";
    String expResult = "<some>response</some>";
    String result = instance.getResponse(request);
    assertEquals(expResult, result);
}

Ancak hatalı biçimlendirilmiş XML aldığında veya isteği anlamadığında, nullstandart çıktıya bazı şeyler döndürür ve yazar.

JUnit'te konsol çıktısını onaylamanın bir yolu var mı? Gibi davaları yakalamak için:

System.out.println("match found: " + strExpr);
System.out.println("xml not well formed: " + e.getMessage());

kullanarak ByteArrayOutputStream ve System.setXXX basittir:

private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
private final ByteArrayOutputStream errContent = new ByteArrayOutputStream();
private final PrintStream originalOut = System.out;
private final PrintStream originalErr = System.err;

@Before
public void setUpStreams() {
    System.setOut(new PrintStream(outContent));
    System.setErr(new PrintStream(errContent));
}

@After
public void restoreStreams() {
    System.setOut(originalOut);
    System.setErr(originalErr);
}

örnek test kılıfları:

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

@Test
public void err() {
    System.err.print("hello again");
    assertEquals("hello again", errContent.toString());
}

Komut satırı seçeneğini test etmek için bu kodu kullandım (-version'un sürüm dizesi vb.

Düzenleme: Bu cevabın önceki sürümleri System.setOut(null)testlerden sonra çağrılır ; NullPointerExceptions yorumcularının başvurabilmelerinin nedeni budur.

Bu eski bir iş parçacığı olduğunu biliyorum, ama bunu yapmak için güzel bir kütüphane var:

Sistem Kuralları

Dokümanlardan örnek:

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());
    }
}

Ayrıca, System.exit(-1)bir komut satırı aracının test edilmesi gereken tuzak ve diğer şeyleri de yapmanızı sağlar.

Yönlendirme yerine, bir ortak çalışan olarak geçip daha sonra üretimde ve testte bir Test Casusu kullanarak kullanılan System.outsınıfı yeniden düzenlerdim . Yani, standart çıkış akımının doğrudan kullanımını ortadan kaldırmak için Bağımlılık Enjeksiyonu kullanın.System.out.println()PrintStreamSystem.out

Üretimde

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

Testte

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

Tartışma

Bu şekilde test edilen sınıf, standart çıktının dolaylı olarak yeniden yönlendirilmesine veya bir sistem kuralıyla belirsiz müdahaleye gerek kalmadan basit bir yeniden düzenleme ile test edilebilir hale gelir.

System.out yazdırma akışını setOut () (ve için inve err) aracılığıyla ayarlayabilirsiniz . Bunu bir dizeye kayıt yapan bir yazdırma akışına yönlendirebilir ve ardından inceleyebilir misiniz? Bu en basit mekanizma gibi görünüyor.

(Bir aşamada, uygulamayı bir günlük çerçevesine dönüştürürüm - ancak bunun farkında olduğunuzu sanıyorum!)

(Ben ilk Konuyu bulunca benim gibi) Hafif konu dışı, ama durumda bazı insanlar SLF4J aracılığıyla günlük çıkışını yakalayan ilgilenen olabilir, commons-test 'ın JUnit @Rulekudreti yardım:

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));
    }
}

Feragatname :

• Kendi ihtiyacım için uygun bir çözüm bulamadığım için bu kütüphaneyi geliştirdim.
• Yalnızca bağlamaları log4j, log4j2ve logbackşu anda mevcuttur, ancak ben daha eklemek için mutluyum.

@ dfa cevabı harika, bu yüzden çıkış bloklarını test etmeyi mümkün kılmak için bir adım daha attım.

İlk olarak , rahatsız edici sınıfı kabul eden TestHelperbir yöntemle captureOutputyarattım CaptureTest. CaptureOutput yöntemi, çıktı akışlarını ayarlama ve yırtma işini yapar. Uygulanması zaman CaptureOutputbireyin testyöntemi olarak adlandırılır, bu çıkış erişim testi bloğu oluşturmak yer alır.

TestHelper için kaynak:

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;
}

TestHelper ve CaptureTest öğelerinin aynı dosyada tanımlandığını unutmayın.

Ardından, testinizde statik captureOutput dosyasını içe aktarabilirsiniz. İşte JUnit kullanan bir örnek:

// 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() );
            }
        });
}

Spring Boot kullanıyorsanız (eski bir uygulama ile çalıştığınızdan bahsetmiştiniz, muhtemelen kullanmıyorsunuz, ancak başkaları için yararlı olabilir), o zaman org.springframework.boot.test.rule.OutputCapture öğesini kullanabilirsiniz. aşağıdaki şekilde:

@Rule
public OutputCapture outputCapture = new OutputCapture();

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

Dayanarak DFA cevap @ ve gösteriler nasıl System.in test etmek başka cevap , bir programa bir giriş vermek ve çıkışını test etmek için benim çözüm paylaşmak istiyorum.

Referans olarak, JUnit 4.12 kullanıyorum.

Diyelim ki girdiyi çıktıya kopyalayan bu programımız var:

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();
    }
}

Test etmek için aşağıdaki sınıfı kullanabiliriz:

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());
    }
}

Çok fazla açıklamayacağım, çünkü kodun okunabilir olduğuna ve kaynaklarıma atıfta bulunduğuna inanıyorum.

JUnit çalıştığında testCase1(), yardımcı yöntemleri göründükleri sırayla çağıracaktır:

1. setUpOutput(), @Beforeek açıklama nedeniyle
2. provideInput(String data), denilen testCase1()
3. getOutput(), denilen testCase1()
4. restoreSystemInputOutput(), @Afterek açıklama nedeniyle

Test etmedim System.errçünkü ihtiyacım yoktu, ama teste benzer şekilde uygulanması kolay olmalı System.out.

ENTIRE JVM için yeniden yönlendirmeler yaptığı için system.out akışını yeniden yönlendirmek istemezsiniz. JVM üzerinde çalışan her şey berbat olabilir. Girdi / çıktıyı test etmenin daha iyi yolları vardır. Saplamalara / alaylara bakın.

Test etmek için tam JUnit 5 örneği System.out(when parçasını değiştirin):

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");
    }
}

Doğrudan kullanarak baskı olamaz System.out.println veya kullanarak logger api kullanırken JUnit . Ancak, herhangi bir değeri kontrol etmek istiyorsanız,

Assert.assertEquals("value", str);

İddia hatasının altına atılacaktır:

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

Değeriniz 21.92 olmalıdır. Şimdi bu değeri kullanarak test edecek olursanız, test durumunuz geçecektir.

 Assert.assertEquals(21.92, str);

dışarıya

@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);
}

hata için

@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);
}