Bagaimana cara menegaskan keluaran dengan nosetest / unittest di python?

Saya sedang menulis tes untuk fungsi seperti berikut:

def foo():
    print 'hello world!'

Jadi ketika saya ingin menguji fungsi ini kodenya akan seperti ini:

import sys
from foomodule import foo
def test_foo():
    foo()
    output = sys.stdout.getline().strip() # because stdout is an StringIO instance
    assert output == 'hello world!'

Tetapi jika saya menjalankan nosetests dengan parameter -s, pengujian akan macet. Bagaimana saya bisa menangkap output dengan modul unittest atau nose?

Saya menggunakan manajer konteks ini untuk menangkap keluaran. Ini pada akhirnya menggunakan teknik yang sama seperti beberapa jawaban lainnya dengan mengganti sementara sys.stdout. Saya lebih suka manajer konteks karena ini membungkus semua pembukuan menjadi satu fungsi, jadi saya tidak perlu menulis ulang kode coba-akhirnya, dan saya tidak perlu menulis fungsi penyiapan dan pembongkaran hanya untuk ini.

import sys
from contextlib import contextmanager
from StringIO import StringIO

@contextmanager
def captured_output():
    new_out, new_err = StringIO(), StringIO()
    old_out, old_err = sys.stdout, sys.stderr
    try:
        sys.stdout, sys.stderr = new_out, new_err
        yield sys.stdout, sys.stderr
    finally:
        sys.stdout, sys.stderr = old_out, old_err

Gunakan seperti ini:

with captured_output() as (out, err):
    foo()
# This can go inside or outside the `with` block
output = out.getvalue().strip()
self.assertEqual(output, 'hello world!')

Selanjutnya, karena status keluaran asli dipulihkan setelah keluar dari withblok, kita dapat mengatur blok penangkapan kedua dalam fungsi yang sama seperti yang pertama, yang tidak mungkin menggunakan fungsi pengaturan dan pembongkaran, dan menjadi bertele-tele saat menulis coba-akhirnya memblokir secara manual. Kemampuan itu berguna saat tujuan pengujian adalah untuk membandingkan hasil dari dua fungsi relatif satu sama lain daripada dengan beberapa nilai yang telah dihitung sebelumnya.

Jika Anda benar-benar ingin melakukan ini, Anda dapat menetapkan kembali sys.stdout selama pengujian.

def test_foo():
    import sys
    from foomodule import foo
    from StringIO import StringIO

    saved_stdout = sys.stdout
    try:
        out = StringIO()
        sys.stdout = out
        foo()
        output = out.getvalue().strip()
        assert output == 'hello world!'
    finally:
        sys.stdout = saved_stdout

Jika saya menulis kode ini, bagaimanapun, saya lebih suka memberikan outparameter opsional ke foofungsi.

def foo(out=sys.stdout):
    out.write("hello, world!")

Maka tesnya jauh lebih sederhana:

def test_foo():
    from foomodule import foo
    from StringIO import StringIO

    out = StringIO()
    foo(out=out)
    output = out.getvalue().strip()
    assert output == 'hello world!'

Sejak versi 2.7, Anda tidak perlu lagi menetapkan kembali sys.stdout, ini disediakan melalui bufferflag . Selain itu, ini adalah perilaku default nosetest.

Berikut ini contoh yang gagal dalam konteks non buffer:

import sys
import unittest

def foo():
    print 'hello world!'

class Case(unittest.TestCase):
    def test_foo(self):
        foo()
        if not hasattr(sys.stdout, "getvalue"):
            self.fail("need to run in buffered mode")
        output = sys.stdout.getvalue().strip() # because stdout is an StringIO instance
        self.assertEquals(output,'hello world!')

Anda dapat mengatur buffer melalui unit2bendera baris perintah -b, --bufferatau dalam unittest.mainopsi. Kebalikannya dicapai melalui nosetestbendera --nocapture.

if __name__=="__main__":   
    assert not hasattr(sys.stdout, "getvalue")
    unittest.main(module=__name__, buffer=True, exit=False)
    #.
    #----------------------------------------------------------------------
    #Ran 1 test in 0.000s
    #
    #OK
    assert not hasattr(sys.stdout, "getvalue")

    unittest.main(module=__name__, buffer=False)
    #hello world!
    #F
    #======================================================================
    #FAIL: test_foo (__main__.Case)
    #----------------------------------------------------------------------
    #Traceback (most recent call last):
    #  File "test_stdout.py", line 15, in test_foo
    #    self.fail("need to run in buffered mode")
    #AssertionError: need to run in buffered mode
    #
    #----------------------------------------------------------------------
    #Ran 1 test in 0.002s
    #
    #FAILED (failures=1)

Banyak dari jawaban ini gagal untuk saya karena Anda tidak bisa from StringIO import StringIOmenggunakan Python 3. Berikut cuplikan kerja minimum berdasarkan komentar @ naxa dan Python Cookbook.

from io import StringIO
from unittest.mock import patch

with patch('sys.stdout', new=StringIO()) as fakeOutput:
    print('hello world')
    self.assertEqual(fakeOutput.getvalue().strip(), 'hello world')

Di python 3.5 Anda dapat menggunakan contextlib.redirect_stdout()dan StringIO(). Berikut modifikasi pada kode Anda

import contextlib
from io import StringIO
from foomodule import foo

def test_foo():
    temp_stdout = StringIO()
    with contextlib.redirect_stdout(temp_stdout):
        foo()
    output = temp_stdout.getvalue().strip()
    assert output == 'hello world!'

Saya baru saja belajar Python dan mendapati diri saya berjuang dengan masalah yang mirip dengan masalah di atas dengan pengujian unit untuk metode dengan keluaran. Uji unit kelulusan saya untuk modul foo di atas akhirnya terlihat seperti ini:

import sys
import unittest
from foo import foo
from StringIO import StringIO

class FooTest (unittest.TestCase):
    def setUp(self):
        self.held, sys.stdout = sys.stdout, StringIO()

    def test_foo(self):
        foo()
        self.assertEqual(sys.stdout.getvalue(),'hello world!\n')

Tes menulis sering kali menunjukkan kepada kita cara yang lebih baik untuk menulis kode kita. Mirip dengan jawaban Shane, saya ingin menyarankan cara lain untuk melihat ini. Apakah Anda benar-benar ingin menegaskan bahwa program Anda mengeluarkan string tertentu, atau hanya ia membangun string tertentu untuk keluaran? Ini menjadi lebih mudah untuk diuji, karena kita mungkin dapat berasumsi bahwa printpernyataan Python melakukan tugasnya dengan benar.

def foo_msg():
    return 'hello world'

def foo():
    print foo_msg()

Maka tes Anda sangat sederhana:

def test_foo_msg():
    assert 'hello world' == foo_msg()

Tentu saja, jika Anda benar-benar perlu menguji keluaran aktual program Anda, abaikan saja. :)

Berdasarkan jawaban Rob Kennedy, saya menulis versi manajer konteks berbasis kelas untuk menyangga keluaran.

Penggunaannya seperti:

with OutputBuffer() as bf:
    print('hello world')
assert bf.out == 'hello world\n'

Berikut implementasinya:

from io import StringIO
import sys


class OutputBuffer(object):

    def __init__(self):
        self.stdout = StringIO()
        self.stderr = StringIO()

    def __enter__(self):
        self.original_stdout, self.original_stderr = sys.stdout, sys.stderr
        sys.stdout, sys.stderr = self.stdout, self.stderr
        return self

    def __exit__(self, exception_type, exception, traceback):
        sys.stdout, sys.stderr = self.original_stdout, self.original_stderr

    @property
    def out(self):
        return self.stdout.getvalue()

    @property
    def err(self):
        return self.stderr.getvalue()

Atau pertimbangkan untuk menggunakan pytest, ia memiliki dukungan built-in untuk menegaskan stdout dan stderr. Lihat dokumen

def test_myoutput(capsys): # or use "capfd" for fd-level
    print("hello")
    captured = capsys.readouterr()
    assert captured.out == "hello\n"
    print("next")
    captured = capsys.readouterr()
    assert captured.out == "next\n"

Baik n611x007 dan Noumenon sudah menyarankan penggunaan unittest.mock, tetapi jawaban ini menyesuaikan Acumenus untuk menunjukkan bagaimana Anda dapat dengan mudah membungkus unittest.TestCasemetode untuk berinteraksi dengan tiruan stdout.

import io
import unittest
import unittest.mock

msg = "Hello World!"


# function we will be testing
def foo():
    print(msg, end="")


# create a decorator which wraps a TestCase method and pass it a mocked
# stdout object
mock_stdout = unittest.mock.patch('sys.stdout', new_callable=io.StringIO)


class MyTests(unittest.TestCase):

    @mock_stdout
    def test_foo(self, stdout):
        # run the function whose output we want to test
        foo()
        # get its output from the mocked stdout
        actual = stdout.getvalue()
        expected = msg
        self.assertEqual(actual, expected)

Membangun semua jawaban luar biasa di utas ini, inilah cara saya menyelesaikannya. Saya ingin menyimpannya sebagai stok. Aku ditambah mekanisme uji unit menggunakan setUp()untuk menangkap sys.stdoutdan sys.stderr, menambahkan API menegaskan baru untuk memeriksa nilai-nilai yang diambil terhadap nilai yang diharapkan dan kemudian mengembalikan sys.stdoutdan sys.stderrpada tearDown(). I did this to keep a similar unit test API as the built-inunittest API while still being able to unit test values printed tosys.stdout orsys.stderr`.

import io
import sys
import unittest


class TestStdout(unittest.TestCase):

    # before each test, capture the sys.stdout and sys.stderr
    def setUp(self):
        self.test_out = io.StringIO()
        self.test_err = io.StringIO()
        self.original_output = sys.stdout
        self.original_err = sys.stderr
        sys.stdout = self.test_out
        sys.stderr = self.test_err

    # restore sys.stdout and sys.stderr after each test
    def tearDown(self):
        sys.stdout = self.original_output
        sys.stderr = self.original_err

    # assert that sys.stdout would be equal to expected value
    def assertStdoutEquals(self, value):
        self.assertEqual(self.test_out.getvalue().strip(), value)

    # assert that sys.stdout would not be equal to expected value
    def assertStdoutNotEquals(self, value):
        self.assertNotEqual(self.test_out.getvalue().strip(), value)

    # assert that sys.stderr would be equal to expected value
    def assertStderrEquals(self, value):
        self.assertEqual(self.test_err.getvalue().strip(), value)

    # assert that sys.stderr would not be equal to expected value
    def assertStderrNotEquals(self, value):
        self.assertNotEqual(self.test_err.getvalue().strip(), value)

    # example of unit test that can capture the printed output
    def test_print_good(self):
        print("------")

        # use assertStdoutEquals(value) to test if your
        # printed value matches your expected `value`
        self.assertStdoutEquals("------")

    # fails the test, expected different from actual!
    def test_print_bad(self):
        print("@=@=")
        self.assertStdoutEquals("@-@-")


if __name__ == '__main__':
    unittest.main()

Saat unit test dijalankan, hasilnya adalah:

$ python3 -m unittest -v tests/print_test.py
test_print_bad (tests.print_test.TestStdout) ... FAIL
test_print_good (tests.print_test.TestStdout) ... ok

======================================================================
FAIL: test_print_bad (tests.print_test.TestStdout)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/tests/print_test.py", line 51, in test_print_bad
    self.assertStdoutEquals("@-@-")
  File "/tests/print_test.py", line 24, in assertStdoutEquals
    self.assertEqual(self.test_out.getvalue().strip(), value)
AssertionError: '@=@=' != '@-@-'
- @=@=
+ @-@-


----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)