test_ok2/testing/test_capture.py

1583 lines
47 KiB
Python
Raw Normal View History

import contextlib
import io
2014-01-25 04:22:19 +08:00
import os
import subprocess
2014-01-25 04:22:19 +08:00
import sys
import textwrap
from io import UnsupportedOperation
2020-01-26 01:11:38 +08:00
from typing import BinaryIO
from typing import cast
2020-01-26 02:21:19 +08:00
from typing import Generator
from typing import TextIO
import pytest
2014-01-25 04:22:19 +08:00
from _pytest import capture
from _pytest.capture import _get_multicapture
from _pytest.capture import CaptureManager
from _pytest.capture import MultiCapture
from _pytest.config import ExitCode
# note: py.io capture tests where copied from
# pylib 1.4.20.dev2 (rev 13d9af95547e)
def StdCaptureFD(out: bool = True, err: bool = True, in_: bool = True) -> MultiCapture:
return capture.MultiCapture(
in_=capture.FDCapture(0) if in_ else None,
out=capture.FDCapture(1) if out else None,
err=capture.FDCapture(2) if err else None,
)
def StdCapture(out: bool = True, err: bool = True, in_: bool = True) -> MultiCapture:
return capture.MultiCapture(
in_=capture.SysCapture(0) if in_ else None,
out=capture.SysCapture(1) if out else None,
err=capture.SysCapture(2) if err else None,
)
def TeeStdCapture(out: bool = True, err: bool = True, in_: bool = True) -> MultiCapture:
return capture.MultiCapture(
in_=capture.SysCapture(0, tee=True) if in_ else None,
out=capture.SysCapture(1, tee=True) if out else None,
err=capture.SysCapture(2, tee=True) if err else None,
)
2019-06-03 06:32:00 +08:00
class TestCaptureManager:
@pytest.mark.parametrize("method", ["no", "sys", "fd"])
def test_capturing_basic_api(self, method):
capouter = StdCaptureFD()
old = sys.stdout, sys.stderr, sys.stdin
try:
capman = CaptureManager(method)
capman.start_global_capturing()
capman.suspend_global_capture()
outerr = capman.read_global_capture()
assert outerr == ("", "")
capman.suspend_global_capture()
outerr = capman.read_global_capture()
assert outerr == ("", "")
print("hello")
capman.suspend_global_capture()
out, err = capman.read_global_capture()
if method == "no":
assert old == (sys.stdout, sys.stderr, sys.stdin)
else:
assert not out
capman.resume_global_capture()
print("hello")
capman.suspend_global_capture()
out, err = capman.read_global_capture()
if method != "no":
assert out == "hello\n"
capman.stop_global_capturing()
finally:
capouter.stop_capturing()
def test_init_capturing(self):
capouter = StdCaptureFD()
try:
capman = CaptureManager("fd")
capman.start_global_capturing()
pytest.raises(AssertionError, capman.start_global_capturing)
capman.stop_global_capturing()
finally:
capouter.stop_capturing()
2014-01-25 04:22:19 +08:00
2018-05-23 22:48:46 +08:00
@pytest.mark.parametrize("method", ["fd", "sys"])
def test_capturing_unicode(testdir, method):
obj = "'b\u00f6y'"
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
"""\
# taken from issue 227 from nosetests
def test_unicode():
import sys
2018-11-22 16:15:14 +08:00
print(sys.stdout)
print(%s)
"""
2018-05-23 22:48:46 +08:00
% obj
)
result = testdir.runpytest("--capture=%s" % method)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(["*1 passed*"])
2014-01-25 04:22:19 +08:00
2018-05-23 22:48:46 +08:00
@pytest.mark.parametrize("method", ["fd", "sys"])
def test_capturing_bytes_in_utf8_encoding(testdir, method):
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
"""\
def test_unicode():
2018-11-22 16:15:14 +08:00
print('b\\u00f6y')
"""
2018-05-23 22:48:46 +08:00
)
result = testdir.runpytest("--capture=%s" % method)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(["*1 passed*"])
2014-01-25 04:22:19 +08:00
def test_collect_capturing(testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""
import sys
2018-11-22 16:15:14 +08:00
print("collect %s failure" % 13)
sys.stderr.write("collect %s_stderr failure" % 13)
import xyz42123
2018-05-23 22:48:46 +08:00
"""
)
result = testdir.runpytest(p)
result.stdout.fnmatch_lines(
[
"*Captured stdout*",
"collect 13 failure",
"*Captured stderr*",
"collect 13_stderr failure",
]
)
2014-01-25 04:22:19 +08:00
2019-06-03 06:32:00 +08:00
class TestPerTestCapturing:
def test_capture_and_fixtures(self, testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""
def setup_module(mod):
2018-11-22 16:15:14 +08:00
print("setup module")
def setup_function(function):
2018-11-22 16:15:14 +08:00
print("setup " + function.__name__)
def test_func1():
2018-11-22 16:15:14 +08:00
print("in func1")
assert 0
def test_func2():
2018-11-22 16:15:14 +08:00
print("in func2")
assert 0
2018-05-23 22:48:46 +08:00
"""
)
result = testdir.runpytest(p)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
[
"setup module*",
"setup test_func1*",
"in func1*",
"setup test_func2*",
"in func2*",
]
)
@pytest.mark.xfail(reason="unimplemented feature")
def test_capture_scope_cache(self, testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""
import sys
def setup_module(func):
2018-11-22 16:15:14 +08:00
print("module-setup")
def setup_function(func):
2018-11-22 16:15:14 +08:00
print("function-setup")
def test_func():
2018-11-22 16:15:14 +08:00
print("in function")
assert 0
def teardown_function(func):
2018-11-22 16:15:14 +08:00
print("in teardown")
2018-05-23 22:48:46 +08:00
"""
)
result = testdir.runpytest(p)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
[
"*test_func():*",
"*Captured stdout during setup*",
"module-setup*",
"function-setup*",
"*Captured stdout*",
"in teardown*",
]
)
def test_no_carry_over(self, testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""
def test_func1():
2018-11-22 16:15:14 +08:00
print("in func1")
def test_func2():
2018-11-22 16:15:14 +08:00
print("in func2")
assert 0
2018-05-23 22:48:46 +08:00
"""
)
result = testdir.runpytest(p)
s = result.stdout.str()
assert "in func1" not in s
assert "in func2" in s
def test_teardown_capturing(self, testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""
def setup_function(function):
2018-11-22 16:15:14 +08:00
print("setup func1")
def teardown_function(function):
2018-11-22 16:15:14 +08:00
print("teardown func1")
assert 0
def test_func1():
2018-11-22 16:15:14 +08:00
print("in func1")
pass
2018-05-23 22:48:46 +08:00
"""
)
result = testdir.runpytest(p)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
[
"*teardown_function*",
"*Captured stdout*",
"setup func1*",
"in func1*",
"teardown func1*",
# "*1 fixture failure*"
]
)
def test_teardown_capturing_final(self, testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""
def teardown_module(mod):
2018-11-22 16:15:14 +08:00
print("teardown module")
assert 0
def test_func():
pass
2018-05-23 22:48:46 +08:00
"""
)
result = testdir.runpytest(p)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
[
"*def teardown_module(mod):*",
"*Captured stdout*",
"*teardown module*",
"*1 error*",
]
)
def test_capturing_outerr(self, testdir):
2018-05-23 22:48:46 +08:00
p1 = testdir.makepyfile(
"""\
import sys
def test_capturing():
2018-11-22 16:15:14 +08:00
print(42)
sys.stderr.write(str(23))
def test_capturing_error():
2018-11-22 16:15:14 +08:00
print(1)
sys.stderr.write(str(2))
raise ValueError
"""
2018-05-23 22:48:46 +08:00
)
result = testdir.runpytest(p1)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
[
"*test_capturing_outerr.py .F*",
"====* FAILURES *====",
"____*____",
"*test_capturing_outerr.py:8: ValueError",
"*--- Captured stdout *call*",
"1",
"*--- Captured stderr *call*",
"2",
]
)
2014-01-25 04:22:19 +08:00
2019-06-03 06:32:00 +08:00
class TestLoggingInteraction:
def test_logging_stream_ownership(self, testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""\
def test_logging():
import logging
import pytest
stream = capture.CaptureIO()
logging.basicConfig(stream=stream)
stream.close() # to free memory/release resources
"""
2018-05-23 22:48:46 +08:00
)
result = testdir.runpytest_subprocess(p)
assert result.stderr.str().find("atexit") == -1
def test_logging_and_immediate_setupteardown(self, testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""\
import logging
def setup_function(function):
logging.warning("hello1")
def test_logging():
logging.warning("hello2")
assert 0
def teardown_function(function):
logging.warning("hello3")
assert 0
"""
2018-05-23 22:48:46 +08:00
)
for optargs in (("--capture=sys",), ("--capture=fd",)):
print(optargs)
result = testdir.runpytest_subprocess(p, *optargs)
s = result.stdout.str()
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
["*WARN*hello3", "*WARN*hello1", "*WARN*hello2"] # errors show first!
)
# verify proper termination
assert "closed" not in s
def test_logging_and_crossscope_fixtures(self, testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""\
import logging
def setup_module(function):
logging.warning("hello1")
def test_logging():
logging.warning("hello2")
assert 0
def teardown_module(function):
logging.warning("hello3")
assert 0
"""
2018-05-23 22:48:46 +08:00
)
for optargs in (("--capture=sys",), ("--capture=fd",)):
print(optargs)
result = testdir.runpytest_subprocess(p, *optargs)
s = result.stdout.str()
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
["*WARN*hello3", "*WARN*hello1", "*WARN*hello2"] # errors come first
)
# verify proper termination
assert "closed" not in s
def test_conftestlogging_is_shown(self, testdir):
2018-05-23 22:48:46 +08:00
testdir.makeconftest(
"""\
import logging
logging.basicConfig()
logging.warning("hello435")
"""
2018-05-23 22:48:46 +08:00
)
# make sure that logging is still captured in tests
result = testdir.runpytest_subprocess("-s", "-p", "no:capturelog")
assert result.ret == ExitCode.NO_TESTS_COLLECTED
2018-05-23 22:48:46 +08:00
result.stderr.fnmatch_lines(["WARNING*hello435*"])
assert "operation on closed file" not in result.stderr.str()
def test_conftestlogging_and_test_logging(self, testdir):
2018-05-23 22:48:46 +08:00
testdir.makeconftest(
"""\
import logging
logging.basicConfig()
"""
2018-05-23 22:48:46 +08:00
)
# make sure that logging is still captured in tests
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""\
def test_hello():
import logging
logging.warning("hello433")
assert 0
"""
2018-05-23 22:48:46 +08:00
)
result = testdir.runpytest_subprocess(p, "-p", "no:capturelog")
assert result.ret != 0
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(["WARNING*hello433*"])
assert "something" not in result.stderr.str()
assert "operation on closed file" not in result.stderr.str()
def test_logging_after_cap_stopped(self, testdir):
testdir.makeconftest(
"""\
import pytest
import logging
log = logging.getLogger(__name__)
@pytest.fixture
def log_on_teardown():
yield
log.warning('Logging on teardown')
"""
)
# make sure that logging is still captured in tests
p = testdir.makepyfile(
"""\
def test_hello(log_on_teardown):
import logging
logging.warning("hello433")
assert 1
raise KeyboardInterrupt()
"""
)
result = testdir.runpytest_subprocess(p, "--log-cli-level", "info")
assert result.ret != 0
2018-12-03 20:58:22 +08:00
result.stdout.fnmatch_lines(
["*WARNING*hello433*", "*WARNING*Logging on teardown*"]
)
assert (
"AttributeError: 'NoneType' object has no attribute 'resume_capturing'"
not in result.stderr.str()
)
2019-06-03 06:32:00 +08:00
class TestCaptureFixture:
@pytest.mark.parametrize("opt", [[], ["-s"]])
def test_std_functional(self, testdir, opt):
2018-05-23 22:48:46 +08:00
reprec = testdir.inline_runsource(
"""\
def test_hello(capsys):
2018-11-22 16:15:14 +08:00
print(42)
out, err = capsys.readouterr()
assert out.startswith("42")
""",
2020-03-07 08:40:48 +08:00
*opt,
2018-05-23 22:48:46 +08:00
)
reprec.assertoutcome(passed=1)
def test_capsyscapfd(self, testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""\
def test_one(capsys, capfd):
pass
def test_two(capfd, capsys):
pass
"""
2018-05-23 22:48:46 +08:00
)
result = testdir.runpytest(p)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
[
"*ERROR*setup*test_one*",
"E*capfd*capsys*same*time*",
"*ERROR*setup*test_two*",
"E*capsys*capfd*same*time*",
"*2 errors*",
2018-05-23 22:48:46 +08:00
]
)
def test_capturing_getfixturevalue(self, testdir):
"""Test that asking for "capfd" and "capsys" using request.getfixturevalue
in the same test is an error.
"""
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
"""\
def test_one(capsys, request):
request.getfixturevalue("capfd")
def test_two(capfd, request):
request.getfixturevalue("capsys")
"""
2018-05-23 22:48:46 +08:00
)
result = testdir.runpytest()
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
[
"*test_one*",
"E * cannot use capfd and capsys at the same time",
2018-05-23 22:48:46 +08:00
"*test_two*",
"E * cannot use capsys and capfd at the same time",
2018-05-23 22:48:46 +08:00
"*2 failed in*",
]
)
def test_capsyscapfdbinary(self, testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""\
def test_one(capsys, capfdbinary):
pass
"""
2018-05-23 22:48:46 +08:00
)
result = testdir.runpytest(p)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
["*ERROR*setup*test_one*", "E*capfdbinary*capsys*same*time*", "*1 error*"]
)
@pytest.mark.parametrize("method", ["sys", "fd"])
def test_capture_is_represented_on_failure_issue128(self, testdir, method):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""\
def test_hello(cap{}):
2018-11-22 16:15:14 +08:00
print("xxx42xxx")
assert 0
""".format(
method
)
2018-05-23 22:48:46 +08:00
)
result = testdir.runpytest(p)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(["xxx42xxx"])
def test_stdfd_functional(self, testdir):
2018-05-23 22:48:46 +08:00
reprec = testdir.inline_runsource(
"""\
def test_hello(capfd):
import os
os.write(1, b"42")
out, err = capfd.readouterr()
assert out.startswith("42")
capfd.close()
"""
2018-05-23 22:48:46 +08:00
)
reprec.assertoutcome(passed=1)
def test_capfdbinary(self, testdir):
2018-05-23 22:48:46 +08:00
reprec = testdir.inline_runsource(
"""\
def test_hello(capfdbinary):
import os
# some likely un-decodable bytes
os.write(1, b'\\xfe\\x98\\x20')
out, err = capfdbinary.readouterr()
assert out == b'\\xfe\\x98\\x20'
assert err == b''
"""
2018-05-23 22:48:46 +08:00
)
reprec.assertoutcome(passed=1)
def test_capsysbinary(self, testdir):
p1 = testdir.makepyfile(
r"""
def test_hello(capsysbinary):
import sys
sys.stdout.buffer.write(b'hello')
# Some likely un-decodable bytes.
sys.stdout.buffer.write(b'\xfe\x98\x20')
sys.stdout.buffer.flush()
# Ensure writing in text mode still works and is captured.
# https://github.com/pytest-dev/pytest/issues/6871
print("world", flush=True)
out, err = capsysbinary.readouterr()
assert out == b'hello\xfe\x98\x20world\n'
assert err == b''
print("stdout after")
print("stderr after", file=sys.stderr)
"""
2018-05-23 22:48:46 +08:00
)
result = testdir.runpytest(str(p1), "-rA")
result.stdout.fnmatch_lines(
[
"*- Captured stdout call -*",
"stdout after",
"*- Captured stderr call -*",
"stderr after",
"*= 1 passed in *",
]
)
def test_partial_setup_failure(self, testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""\
def test_hello(capsys, missingarg):
pass
"""
2018-05-23 22:48:46 +08:00
)
result = testdir.runpytest(p)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(["*test_partial_setup_failure*", "*1 error*"])
def test_keyboardinterrupt_disables_capturing(self, testdir):
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""\
def test_hello(capfd):
import os
os.write(1, b'42')
raise KeyboardInterrupt()
"""
2018-05-23 22:48:46 +08:00
)
result = testdir.runpytest_subprocess(p)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(["*KeyboardInterrupt*"])
assert result.ret == 2
def test_capture_and_logging(self, testdir):
"""#14"""
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""\
import logging
def test_log(capsys):
logging.error('x')
2018-05-23 22:48:46 +08:00
"""
)
result = testdir.runpytest_subprocess(p)
2018-05-23 22:48:46 +08:00
assert "closed" not in result.stderr.str()
2018-05-23 22:48:46 +08:00
@pytest.mark.parametrize("fixture", ["capsys", "capfd"])
@pytest.mark.parametrize("no_capture", [True, False])
def test_disabled_capture_fixture(self, testdir, fixture, no_capture):
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
"""\
def test_disabled({fixture}):
print('captured before')
with {fixture}.disabled():
print('while capture is disabled')
print('captured after')
assert {fixture}.readouterr() == ('captured before\\ncaptured after\\n', '')
def test_normal():
print('test_normal executed')
2018-05-23 22:48:46 +08:00
""".format(
fixture=fixture
)
)
args = ("-s",) if no_capture else ()
result = testdir.runpytest_subprocess(*args)
result.stdout.fnmatch_lines(["*while capture is disabled*", "*= 2 passed in *"])
result.stdout.no_fnmatch_line("*captured before*")
result.stdout.no_fnmatch_line("*captured after*")
if no_capture:
2018-05-23 22:48:46 +08:00
assert "test_normal executed" in result.stdout.str()
else:
result.stdout.no_fnmatch_line("*test_normal executed*")
2018-05-23 22:48:46 +08:00
@pytest.mark.parametrize("fixture", ["capsys", "capfd"])
def test_fixture_use_by_other_fixtures(self, testdir, fixture):
"""
Ensure that capsys and capfd can be used by other fixtures during setup and teardown.
"""
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
"""\
import sys
import pytest
@pytest.fixture
def captured_print({fixture}):
print('stdout contents begin')
print('stderr contents begin', file=sys.stderr)
out, err = {fixture}.readouterr()
yield out, err
print('stdout contents end')
print('stderr contents end', file=sys.stderr)
out, err = {fixture}.readouterr()
assert out == 'stdout contents end\\n'
assert err == 'stderr contents end\\n'
def test_captured_print(captured_print):
out, err = captured_print
assert out == 'stdout contents begin\\n'
assert err == 'stderr contents begin\\n'
2018-05-23 22:48:46 +08:00
""".format(
fixture=fixture
)
)
result = testdir.runpytest_subprocess()
result.stdout.fnmatch_lines(["*1 passed*"])
result.stdout.no_fnmatch_line("*stdout contents begin*")
result.stdout.no_fnmatch_line("*stderr contents begin*")
@pytest.mark.parametrize("cap", ["capsys", "capfd"])
def test_fixture_use_by_other_fixtures_teardown(self, testdir, cap):
"""Ensure we can access setup and teardown buffers from teardown when using capsys/capfd (##3033)"""
testdir.makepyfile(
"""\
import sys
import pytest
import os
@pytest.fixture()
def fix({cap}):
print("setup out")
sys.stderr.write("setup err\\n")
yield
out, err = {cap}.readouterr()
assert out == 'setup out\\ncall out\\n'
assert err == 'setup err\\ncall err\\n'
def test_a(fix):
print("call out")
sys.stderr.write("call err\\n")
""".format(
cap=cap
)
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
def test_setup_failure_does_not_kill_capturing(testdir):
sub1 = testdir.mkpydir("sub1")
2018-05-23 22:48:46 +08:00
sub1.join("conftest.py").write(
textwrap.dedent(
"""\
def pytest_runtest_setup(item):
raise ValueError(42)
2018-05-23 22:48:46 +08:00
"""
)
)
sub1.join("test_mod.py").write("def test_func1(): pass")
2018-05-23 22:48:46 +08:00
result = testdir.runpytest(testdir.tmpdir, "--traceconfig")
result.stdout.fnmatch_lines(["*ValueError(42)*", "*1 error*"])
2014-01-25 04:22:19 +08:00
def test_capture_conftest_runtest_setup(testdir):
2018-05-23 22:48:46 +08:00
testdir.makeconftest(
"""
def pytest_runtest_setup():
2018-11-22 16:15:14 +08:00
print("hello19")
2018-05-23 22:48:46 +08:00
"""
)
testdir.makepyfile("def test_func(): pass")
result = testdir.runpytest()
assert result.ret == 0
result.stdout.no_fnmatch_line("*hello19*")
2014-01-25 04:22:19 +08:00
def test_capture_badoutput_issue412(testdir):
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
"""
2014-03-27 20:53:59 +08:00
import os
def test_func():
omg = bytearray([1,129,1])
os.write(1, omg)
assert 0
2018-05-23 22:48:46 +08:00
"""
)
2019-06-25 11:51:33 +08:00
result = testdir.runpytest("--capture=fd")
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
"""
*def test_func*
*assert 0*
*Captured*
*1 failed*
2018-05-23 22:48:46 +08:00
"""
)
2014-03-27 20:53:59 +08:00
def test_capture_early_option_parsing(testdir):
2018-05-23 22:48:46 +08:00
testdir.makeconftest(
"""
def pytest_runtest_setup():
2018-11-22 16:15:14 +08:00
print("hello19")
2018-05-23 22:48:46 +08:00
"""
)
testdir.makepyfile("def test_func(): pass")
result = testdir.runpytest("-vs")
assert result.ret == 0
2018-05-23 22:48:46 +08:00
assert "hello19" in result.stdout.str()
2014-01-25 04:22:19 +08:00
def test_capture_binary_output(testdir):
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
r"""
import pytest
def test_a():
import sys
import subprocess
subprocess.call([sys.executable, __file__])
def test_foo():
import os;os.write(1, b'\xc3')
if __name__ == '__main__':
test_foo()
2018-05-23 22:48:46 +08:00
"""
)
result = testdir.runpytest("--assert=plain")
result.assert_outcomes(passed=2)
2014-01-25 04:22:19 +08:00
def test_error_during_readouterr(testdir):
2017-02-15 23:00:18 +08:00
"""Make sure we suspend capturing if errors occur during readouterr"""
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
pytest_xyz="""
from _pytest.capture import FDCapture
def bad_snap(self):
raise Exception('boom')
2015-07-26 07:28:00 +08:00
assert FDCapture.snap
FDCapture.snap = bad_snap
2018-05-23 22:48:46 +08:00
"""
)
result = testdir.runpytest_subprocess("-p", "pytest_xyz", "--version")
2018-05-23 22:48:46 +08:00
result.stderr.fnmatch_lines(
["*in bad_snap", " raise Exception('boom')", "Exception: boom"]
)
2019-06-03 06:32:00 +08:00
class TestCaptureIO:
2014-01-25 04:22:19 +08:00
def test_text(self):
f = capture.CaptureIO()
2014-01-25 04:22:19 +08:00
f.write("hello")
s = f.getvalue()
assert s == "hello"
f.close()
def test_unicode_and_str_mixture(self):
f = capture.CaptureIO()
f.write("\u00f6")
pytest.raises(TypeError, f.write, b"hello")
2014-01-25 04:22:19 +08:00
def test_write_bytes_to_buffer(self):
"""In python3, stdout / stderr are text io wrappers (exposing a buffer
property of the underlying bytestream). See issue #1407
"""
f = capture.CaptureIO()
2018-05-23 22:48:46 +08:00
f.buffer.write(b"foo\r\n")
assert f.getvalue() == "foo\r\n"
2014-01-25 04:22:19 +08:00
class TestTeeCaptureIO(TestCaptureIO):
def test_text(self):
sio = io.StringIO()
f = capture.TeeCaptureIO(sio)
f.write("hello")
s1 = f.getvalue()
assert s1 == "hello"
s2 = sio.getvalue()
assert s2 == s1
f.close()
sio.close()
def test_unicode_and_str_mixture(self):
sio = io.StringIO()
f = capture.TeeCaptureIO(sio)
f.write("\u00f6")
pytest.raises(TypeError, f.write, b"hello")
2014-01-25 04:22:19 +08:00
def test_dontreadfrominput():
from _pytest.capture import DontReadFromInput
2018-05-23 22:48:46 +08:00
2014-01-25 04:22:19 +08:00
f = DontReadFromInput()
assert f.buffer is f
2014-01-25 04:22:19 +08:00
assert not f.isatty()
pytest.raises(OSError, f.read)
pytest.raises(OSError, f.readlines)
iter_f = iter(f)
pytest.raises(OSError, next, iter_f)
pytest.raises(UnsupportedOperation, f.fileno)
2014-01-25 04:22:19 +08:00
f.close() # just for completeness
2016-08-25 06:44:43 +08:00
@pytest.fixture
2020-01-26 02:21:19 +08:00
def tmpfile(testdir) -> Generator[BinaryIO, None, None]:
2018-05-23 22:48:46 +08:00
f = testdir.makepyfile("").open("wb+")
yield f
if not f.closed:
f.close()
2014-01-25 04:22:19 +08:00
@contextlib.contextmanager
def lsof_check():
2014-01-25 04:22:19 +08:00
pid = os.getpid()
try:
out = subprocess.check_output(("lsof", "-p", str(pid))).decode()
except (OSError, subprocess.CalledProcessError, UnicodeDecodeError) as exc:
# about UnicodeDecodeError, see note on pytester
pytest.skip("could not run 'lsof' ({!r})".format(exc))
yield
out2 = subprocess.check_output(("lsof", "-p", str(pid))).decode()
2014-01-25 04:22:19 +08:00
len1 = len([x for x in out.split("\n") if "REG" in x])
len2 = len([x for x in out2.split("\n") if "REG" in x])
assert len2 < len1 + 3, out2
2019-06-03 06:32:00 +08:00
class TestFDCapture:
def test_simple(self, tmpfile):
2014-01-25 04:22:19 +08:00
fd = tmpfile.fileno()
cap = capture.FDCapture(fd)
data = b"hello"
2014-01-25 04:22:19 +08:00
os.write(fd, data)
pytest.raises(AssertionError, cap.snap)
cap.done()
2014-01-25 04:22:19 +08:00
cap = capture.FDCapture(fd)
cap.start()
2014-01-25 04:22:19 +08:00
os.write(fd, data)
s = cap.snap()
cap.done()
2014-01-25 04:22:19 +08:00
assert s == "hello"
def test_simple_many(self, tmpfile):
for i in range(10):
self.test_simple(tmpfile)
def test_simple_many_check_open_files(self, testdir):
with lsof_check():
2018-05-23 22:48:46 +08:00
with testdir.makepyfile("").open("wb+") as tmpfile:
self.test_simple_many(tmpfile)
2014-01-25 04:22:19 +08:00
def test_simple_fail_second_start(self, tmpfile):
fd = tmpfile.fileno()
cap = capture.FDCapture(fd)
cap.done()
pytest.raises(AssertionError, cap.start)
2014-01-25 04:22:19 +08:00
def test_stderr(self):
cap = capture.FDCapture(2)
cap.start()
print("hello", file=sys.stderr)
s = cap.snap()
cap.done()
2014-01-25 04:22:19 +08:00
assert s == "hello\n"
2020-01-17 02:42:29 +08:00
def test_stdin(self):
cap = capture.FDCapture(0)
cap.start()
2014-01-25 04:22:19 +08:00
x = os.read(0, 100).strip()
cap.done()
assert x == b""
2014-01-25 04:22:19 +08:00
def test_writeorg(self, tmpfile):
data1, data2 = b"foo", b"bar"
cap = capture.FDCapture(tmpfile.fileno())
cap.start()
tmpfile.write(data1)
tmpfile.flush()
cap.writeorg(data2.decode("ascii"))
scap = cap.snap()
cap.done()
assert scap == data1.decode("ascii")
2018-05-23 22:48:46 +08:00
with open(tmpfile.name, "rb") as stmp_file:
stmp = stmp_file.read()
assert stmp == data2
2014-01-25 04:22:19 +08:00
2020-01-17 02:42:29 +08:00
def test_simple_resume_suspend(self):
with saved_fd(1):
cap = capture.FDCapture(1)
cap.start()
data = b"hello"
os.write(1, data)
sys.stdout.write("whatever")
s = cap.snap()
assert s == "hellowhatever"
cap.suspend()
os.write(1, b"world")
sys.stdout.write("qlwkej")
assert not cap.snap()
cap.resume()
os.write(1, b"but now")
sys.stdout.write(" yes\n")
s = cap.snap()
assert s == "but now yes\n"
cap.suspend()
cap.done()
pytest.raises(AssertionError, cap.suspend)
assert repr(cap) == (
"<FDCapture 1 oldfd={} _state='done' tmpfile={!r}>".format(
cap.targetfd_save, cap.tmpfile
)
)
# Should not crash with missing "_old".
assert repr(cap.syscapture) == (
"<SysCapture stdout _old=<UNSET> _state='done' tmpfile={!r}>".format(
cap.syscapture.tmpfile
)
)
2019-05-15 05:54:03 +08:00
def test_capfd_sys_stdout_mode(self, capfd):
assert "b" not in sys.stdout.mode
@contextlib.contextmanager
def saved_fd(fd):
new_fd = os.dup(fd)
try:
yield
finally:
os.dup2(new_fd, fd)
os.close(new_fd)
2014-01-25 04:22:19 +08:00
2014-06-16 17:27:32 +08:00
2019-06-03 06:32:00 +08:00
class TestStdCapture:
2014-03-28 14:55:07 +08:00
captureclass = staticmethod(StdCapture)
@contextlib.contextmanager
2014-01-25 04:22:19 +08:00
def getcapture(self, **kw):
2014-03-28 14:55:07 +08:00
cap = self.__class__.captureclass(**kw)
cap.start_capturing()
2014-03-28 14:55:07 +08:00
try:
yield cap
finally:
cap.stop_capturing()
2014-01-25 04:22:19 +08:00
def test_capturing_done_simple(self):
2014-03-28 14:55:07 +08:00
with self.getcapture() as cap:
sys.stdout.write("hello")
sys.stderr.write("world")
out, err = cap.readouterr()
assert out == "hello"
assert err == "world"
2014-01-25 04:22:19 +08:00
def test_capturing_reset_simple(self):
2014-03-28 14:55:07 +08:00
with self.getcapture() as cap:
print("hello world")
sys.stderr.write("hello error\n")
out, err = cap.readouterr()
2014-01-25 04:22:19 +08:00
assert out == "hello world\n"
assert err == "hello error\n"
def test_capturing_readouterr(self):
2014-03-28 14:55:07 +08:00
with self.getcapture() as cap:
print("hello world")
2014-01-25 04:22:19 +08:00
sys.stderr.write("hello error\n")
out, err = cap.readouterr()
assert out == "hello world\n"
assert err == "hello error\n"
sys.stderr.write("error2")
out, err = cap.readouterr()
2014-01-25 04:22:19 +08:00
assert err == "error2"
def test_capture_results_accessible_by_attribute(self):
with self.getcapture() as cap:
sys.stdout.write("hello")
sys.stderr.write("world")
capture_result = cap.readouterr()
assert capture_result.out == "hello"
assert capture_result.err == "world"
2014-01-25 04:22:19 +08:00
def test_capturing_readouterr_unicode(self):
2014-03-28 14:55:07 +08:00
with self.getcapture() as cap:
print("hxąć")
2014-01-25 04:22:19 +08:00
out, err = cap.readouterr()
2019-06-03 06:32:00 +08:00
assert out == "hxąć\n"
2014-01-25 04:22:19 +08:00
def test_reset_twice_error(self):
2014-03-28 14:55:07 +08:00
with self.getcapture() as cap:
print("hello")
2014-03-28 14:55:07 +08:00
out, err = cap.readouterr()
pytest.raises(ValueError, cap.stop_capturing)
2014-01-25 04:22:19 +08:00
assert out == "hello\n"
assert not err
def test_capturing_modify_sysouterr_in_between(self):
oldout = sys.stdout
olderr = sys.stderr
2014-03-28 14:55:07 +08:00
with self.getcapture() as cap:
sys.stdout.write("hello")
sys.stderr.write("world")
sys.stdout = capture.CaptureIO()
sys.stderr = capture.CaptureIO()
print("not seen")
2014-03-28 14:55:07 +08:00
sys.stderr.write("not seen\n")
out, err = cap.readouterr()
2014-01-25 04:22:19 +08:00
assert out == "hello"
assert err == "world"
assert sys.stdout == oldout
assert sys.stderr == olderr
def test_capturing_error_recursive(self):
2014-03-28 14:55:07 +08:00
with self.getcapture() as cap1:
print("cap1")
2014-03-28 14:55:07 +08:00
with self.getcapture() as cap2:
print("cap2")
2014-03-28 14:55:07 +08:00
out2, err2 = cap2.readouterr()
out1, err1 = cap1.readouterr()
2014-01-25 04:22:19 +08:00
assert out1 == "cap1\n"
assert out2 == "cap2\n"
def test_just_out_capture(self):
2014-03-28 14:55:07 +08:00
with self.getcapture(out=True, err=False) as cap:
sys.stdout.write("hello")
sys.stderr.write("world")
out, err = cap.readouterr()
2014-01-25 04:22:19 +08:00
assert out == "hello"
assert not err
def test_just_err_capture(self):
2014-03-28 14:55:07 +08:00
with self.getcapture(out=False, err=True) as cap:
sys.stdout.write("hello")
sys.stderr.write("world")
out, err = cap.readouterr()
2014-01-25 04:22:19 +08:00
assert err == "world"
assert not out
def test_stdin_restored(self):
old = sys.stdin
with self.getcapture(in_=True):
2014-03-28 14:55:07 +08:00
newstdin = sys.stdin
2014-01-25 04:22:19 +08:00
assert newstdin != sys.stdin
assert sys.stdin is old
def test_stdin_nulled_by_default(self):
print("XXX this test may well hang instead of crashing")
print("XXX which indicates an error in the underlying capturing")
print("XXX mechanisms")
with self.getcapture():
pytest.raises(OSError, sys.stdin.read)
2014-01-25 04:22:19 +08:00
class TestTeeStdCapture(TestStdCapture):
captureclass = staticmethod(TeeStdCapture)
def test_capturing_error_recursive(self):
""" for TeeStdCapture since we passthrough stderr/stdout, cap1
should get all output, while cap2 should only get "cap2\n" """
with self.getcapture() as cap1:
print("cap1")
with self.getcapture() as cap2:
print("cap2")
out2, err2 = cap2.readouterr()
out1, err1 = cap1.readouterr()
assert out1 == "cap1\ncap2\n"
assert out2 == "cap2\n"
2014-01-25 04:22:19 +08:00
class TestStdCaptureFD(TestStdCapture):
2014-03-28 14:55:07 +08:00
captureclass = staticmethod(StdCaptureFD)
2014-01-25 04:22:19 +08:00
def test_simple_only_fd(self, testdir):
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
"""\
import os
def test_x():
os.write(1, b"hello\\n")
assert 0
"""
2018-05-23 22:48:46 +08:00
)
result = testdir.runpytest_subprocess()
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
"""
*test_x*
*assert 0*
*Captured stdout*
2018-05-23 22:48:46 +08:00
"""
)
2014-01-25 04:22:19 +08:00
def test_intermingling(self):
2014-03-28 14:55:07 +08:00
with self.getcapture() as cap:
os.write(1, b"1")
2014-03-28 14:55:07 +08:00
sys.stdout.write(str(2))
sys.stdout.flush()
os.write(1, b"3")
os.write(2, b"a")
2014-03-28 14:55:07 +08:00
sys.stderr.write("b")
sys.stderr.flush()
os.write(2, b"c")
2014-03-28 14:55:07 +08:00
out, err = cap.readouterr()
2014-01-25 04:22:19 +08:00
assert out == "123"
assert err == "abc"
def test_many(self, capfd):
with lsof_check():
2014-01-25 04:22:19 +08:00
for i in range(10):
cap = StdCaptureFD()
cap.start_capturing()
cap.stop_capturing()
2014-01-25 04:22:19 +08:00
2019-06-03 06:32:00 +08:00
class TestStdCaptureFDinvalidFD:
2014-01-25 04:22:19 +08:00
def test_stdcapture_fd_invalid_fd(self, testdir):
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
"""
2014-01-25 04:22:19 +08:00
import os
from fnmatch import fnmatch
from _pytest import capture
def StdCaptureFD(out=True, err=True, in_=True):
return capture.MultiCapture(
in_=capture.FDCapture(0) if in_ else None,
out=capture.FDCapture(1) if out else None,
err=capture.FDCapture(2) if err else None,
)
2014-01-25 04:22:19 +08:00
def test_stdout():
os.close(1)
cap = StdCaptureFD(out=True, err=False, in_=False)
assert fnmatch(repr(cap.out), "<FDCapture 1 oldfd=* _state='initialized' tmpfile=*>")
cap.start_capturing()
os.write(1, b"stdout")
assert cap.readouterr() == ("stdout", "")
cap.stop_capturing()
2014-01-25 04:22:19 +08:00
def test_stderr():
os.close(2)
cap = StdCaptureFD(out=False, err=True, in_=False)
assert fnmatch(repr(cap.err), "<FDCapture 2 oldfd=* _state='initialized' tmpfile=*>")
cap.start_capturing()
os.write(2, b"stderr")
assert cap.readouterr() == ("", "stderr")
cap.stop_capturing()
2014-01-25 04:22:19 +08:00
def test_stdin():
os.close(0)
cap = StdCaptureFD(out=False, err=False, in_=True)
assert fnmatch(repr(cap.in_), "<FDCapture 0 oldfd=* _state='initialized' tmpfile=*>")
cap.stop_capturing()
2018-05-23 22:48:46 +08:00
"""
)
result = testdir.runpytest_subprocess("--capture=fd")
2014-01-25 04:22:19 +08:00
assert result.ret == 0
2018-05-23 22:48:46 +08:00
assert result.parseoutcomes()["passed"] == 3
2014-01-25 04:22:19 +08:00
def test_fdcapture_invalid_fd_with_fd_reuse(self, testdir):
with saved_fd(1):
os.close(1)
cap = capture.FDCaptureBinary(1)
cap.start()
os.write(1, b"started")
cap.suspend()
os.write(1, b" suspended")
cap.resume()
os.write(1, b" resumed")
assert cap.snap() == b"started resumed"
cap.done()
with pytest.raises(OSError):
os.write(1, b"done")
def test_fdcapture_invalid_fd_without_fd_reuse(self, testdir):
with saved_fd(1), saved_fd(2):
os.close(1)
os.close(2)
cap = capture.FDCaptureBinary(2)
cap.start()
os.write(2, b"started")
cap.suspend()
os.write(2, b" suspended")
cap.resume()
os.write(2, b" resumed")
assert cap.snap() == b"started resumed"
cap.done()
with pytest.raises(OSError):
os.write(2, b"done")
2014-01-25 04:22:19 +08:00
def test_capture_not_started_but_reset():
capsys = StdCapture()
capsys.stop_capturing()
2014-01-25 04:22:19 +08:00
def test_using_capsys_fixture_works_with_sys_stdout_encoding(capsys):
2018-05-23 22:48:46 +08:00
test_text = "test text"
2018-05-23 22:48:46 +08:00
print(test_text.encode(sys.stdout.encoding, "replace"))
(out, err) = capsys.readouterr()
assert out
2018-05-23 22:48:46 +08:00
assert err == ""
def test_capsys_results_accessible_by_attribute(capsys):
sys.stdout.write("spam")
sys.stderr.write("eggs")
capture_result = capsys.readouterr()
assert capture_result.out == "spam"
assert capture_result.err == "eggs"
def test_fdcapture_tmpfile_remains_the_same() -> None:
cap = StdCaptureFD(out=False, err=True)
2014-01-25 04:22:19 +08:00
try:
cap.start_capturing()
2014-01-25 04:22:19 +08:00
capfile = cap.err.tmpfile
cap.readouterr()
2014-01-25 04:22:19 +08:00
finally:
cap.stop_capturing()
2014-01-25 04:22:19 +08:00
capfile2 = cap.err.tmpfile
assert capfile2 == capfile
2014-04-01 20:19:52 +08:00
def test_close_and_capture_again(testdir):
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
"""
2014-04-01 20:19:52 +08:00
import os
def test_close():
os.close(1)
def test_capture_again():
os.write(1, b"hello\\n")
2014-04-01 20:19:52 +08:00
assert 0
2018-05-23 22:48:46 +08:00
"""
)
result = testdir.runpytest_subprocess()
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
"""
2014-04-01 20:19:52 +08:00
*test_capture_again*
*assert 0*
*stdout*
*hello*
2018-05-23 22:48:46 +08:00
"""
)
2014-04-01 20:19:52 +08:00
@pytest.mark.parametrize(
"method", ["SysCapture(2)", "SysCapture(2, tee=True)", "FDCapture(2)"]
)
def test_capturing_and_logging_fundamentals(testdir, method: str) -> None:
2014-01-25 04:22:19 +08:00
# here we check a fundamental feature
2018-05-23 22:48:46 +08:00
p = testdir.makepyfile(
"""
2014-01-25 04:22:19 +08:00
import sys, os
import py, logging
from _pytest import capture
cap = capture.MultiCapture(
in_=None,
out=None,
err=capture.%s,
)
cap.start_capturing()
2014-01-25 04:22:19 +08:00
logging.warning("hello1")
outerr = cap.readouterr()
2018-11-22 16:15:14 +08:00
print("suspend, captured %%s" %%(outerr,))
logging.warning("hello2")
2014-01-25 04:22:19 +08:00
cap.pop_outerr_to_orig()
logging.warning("hello3")
2014-01-25 04:22:19 +08:00
outerr = cap.readouterr()
2018-11-22 16:15:14 +08:00
print("suspend2, captured %%s" %% (outerr,))
2018-05-23 22:48:46 +08:00
"""
% (method,)
)
2014-01-25 04:22:19 +08:00
result = testdir.runpython(p)
2018-05-23 22:48:46 +08:00
result.stdout.fnmatch_lines(
"""
suspend, captured*hello1*
suspend2, captured*WARNING:root:hello3*
2018-05-23 22:48:46 +08:00
"""
)
result.stderr.fnmatch_lines(
"""
WARNING:root:hello2
2018-05-23 22:48:46 +08:00
"""
)
2014-01-25 04:22:19 +08:00
assert "atexit" not in result.stderr.str()
def test_error_attribute_issue555(testdir):
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
"""
import sys
def test_capattr():
assert sys.stdout.errors == "replace"
assert sys.stderr.errors == "replace"
2018-05-23 22:48:46 +08:00
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
2018-05-23 22:48:46 +08:00
@pytest.mark.skipif(
not sys.platform.startswith("win") and sys.version_info[:2] >= (3, 6),
reason="only py3.6+ on windows",
)
def test_py36_windowsconsoleio_workaround_non_standard_streams() -> None:
"""
Ensure _py36_windowsconsoleio_workaround function works with objects that
do not implement the full ``io``-based stream protocol, for example execnet channels (#2666).
"""
from _pytest.capture import _py36_windowsconsoleio_workaround
2019-06-03 06:32:00 +08:00
class DummyStream:
def write(self, s):
pass
stream = cast(TextIO, DummyStream())
_py36_windowsconsoleio_workaround(stream)
def test_dontreadfrominput_has_encoding(testdir):
2018-05-23 22:48:46 +08:00
testdir.makepyfile(
"""
import sys
def test_capattr():
# should not raise AttributeError
assert sys.stdout.encoding
assert sys.stderr.encoding
2018-05-23 22:48:46 +08:00
"""
)
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
def test_crash_on_closing_tmpfile_py27(testdir):
p = testdir.makepyfile(
2018-05-23 22:48:46 +08:00
"""
import threading
import sys
printing = threading.Event()
def spam():
f = sys.stderr
print('SPAMBEFORE', end='', file=f)
printing.set()
while True:
try:
f.flush()
except (OSError, ValueError):
break
def test_spam_in_thread():
t = threading.Thread(target=spam)
t.daemon = True
t.start()
printing.wait()
2018-05-23 22:48:46 +08:00
"""
)
# Do not consider plugins like hypothesis, which might output to stderr.
testdir.monkeypatch.setenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "1")
result = testdir.runpytest_subprocess(str(p))
assert result.ret == 0
assert result.stderr.str() == ""
result.stdout.no_fnmatch_line("*OSError*")
def test_global_capture_with_live_logging(testdir):
2018-08-17 06:20:51 +08:00
# Issue 3819
2018-08-19 19:44:12 +08:00
# capture should work with live cli logging
# Teardown report seems to have the capture for the whole process (setup, capture, teardown)
2018-08-19 21:46:02 +08:00
testdir.makeconftest(
"""
2018-08-19 19:44:12 +08:00
def pytest_runtest_logreport(report):
if "test_global" in report.nodeid:
if report.when == "teardown":
2018-08-19 20:29:57 +08:00
with open("caplog", "w") as f:
f.write(report.caplog)
with open("capstdout", "w") as f:
f.write(report.capstdout)
"""
2018-08-19 21:46:02 +08:00
)
2018-08-19 19:44:12 +08:00
2018-08-17 06:20:51 +08:00
testdir.makepyfile(
"""
import logging
import sys
2018-08-19 20:29:57 +08:00
import pytest
2018-08-17 06:20:51 +08:00
logger = logging.getLogger(__name__)
2018-08-19 21:46:02 +08:00
2018-08-19 19:44:12 +08:00
@pytest.fixture
def fix1():
print("fix setup")
2018-08-19 20:29:57 +08:00
logging.info("fix setup")
2018-08-19 19:44:12 +08:00
yield
2018-08-19 20:29:57 +08:00
logging.info("fix teardown")
2018-08-19 19:44:12 +08:00
print("fix teardown")
2018-08-19 20:29:57 +08:00
def test_global(fix1):
2018-08-19 19:44:12 +08:00
print("begin test")
logging.info("something in test")
print("end test")
2018-08-17 06:20:51 +08:00
"""
)
result = testdir.runpytest_subprocess("--log-cli-level=INFO")
assert result.ret == 0
2018-08-19 20:29:57 +08:00
with open("caplog") as f:
2018-08-19 20:29:57 +08:00
caplog = f.read()
assert "fix setup" in caplog
assert "something in test" in caplog
assert "fix teardown" in caplog
with open("capstdout") as f:
2018-08-19 20:29:57 +08:00
capstdout = f.read()
assert "fix setup" in capstdout
assert "begin test" in capstdout
assert "end test" in capstdout
assert "fix teardown" in capstdout
@pytest.mark.parametrize("capture_fixture", ["capsys", "capfd"])
def test_capture_with_live_logging(testdir, capture_fixture):
# Issue 3819
# capture should work with live cli logging
2018-08-17 06:20:51 +08:00
testdir.makepyfile(
"""
import logging
import sys
logger = logging.getLogger(__name__)
def test_capture({0}):
2018-08-17 06:20:51 +08:00
print("hello")
sys.stderr.write("world\\n")
captured = {0}.readouterr()
2018-08-17 06:20:51 +08:00
assert captured.out == "hello\\n"
assert captured.err == "world\\n"
logging.info("something")
print("next")
2018-08-17 19:00:27 +08:00
logging.info("something")
captured = {0}.readouterr()
2018-08-17 06:20:51 +08:00
assert captured.out == "next\\n"
""".format(
capture_fixture
)
2018-08-17 06:20:51 +08:00
)
2018-08-17 06:20:51 +08:00
result = testdir.runpytest_subprocess("--log-cli-level=INFO")
assert result.ret == 0
def test_typeerror_encodedfile_write(testdir):
"""It should behave the same with and without output capturing (#4861)."""
p = testdir.makepyfile(
"""
def test_fails():
import sys
sys.stdout.write(b"foo")
"""
)
result_without_capture = testdir.runpytest("-s", str(p))
result_with_capture = testdir.runpytest(str(p))
assert result_with_capture.ret == result_without_capture.ret
out = result_with_capture.stdout.str()
assert ("TypeError: write() argument must be str, not bytes" in out) or (
"TypeError: unicode argument expected, got 'bytes'" in out
)
def test_stderr_write_returns_len(capsys):
"""Write on Encoded files, namely captured stderr, should return number of characters written."""
assert sys.stderr.write("Foo") == 3
2020-01-26 01:11:38 +08:00
def test_encodedfile_writelines(tmpfile: BinaryIO) -> None:
ef = capture.EncodedFile(tmpfile, encoding="utf-8")
with pytest.raises(TypeError):
ef.writelines([b"line1", b"line2"])
assert ef.writelines(["line3", "line4"]) is None # type: ignore[func-returns-value] # noqa: F821
ef.flush()
tmpfile.seek(0)
assert tmpfile.read() == b"line3line4"
tmpfile.close()
with pytest.raises(ValueError):
ef.read()
def test__get_multicapture() -> None:
assert isinstance(_get_multicapture("no"), MultiCapture)
pytest.raises(ValueError, _get_multicapture, "unknown").match(
r"^unknown capturing method: 'unknown'"
)
def test_logging_while_collecting(testdir):
"""Issue #6240: Calls to logging.xxx() during collection causes all logging calls to be duplicated to stderr"""
p = testdir.makepyfile(
"""\
import logging
logging.warning("during collection")
def test_logging():
logging.warning("during call")
assert False
"""
)
result = testdir.runpytest_subprocess(p)
assert result.ret == ExitCode.TESTS_FAILED
result.stdout.fnmatch_lines(
[
"*test_*.py F*",
"====* FAILURES *====",
"____*____",
"*--- Captured log call*",
"WARNING * during call",
"*1 failed*",
]
)
result.stdout.no_fnmatch_line("*Captured stderr call*")
result.stdout.no_fnmatch_line("*during collection*")