def test_teardown_exact_stack_empty(self, pytester: Pytester) -> None:
item = pytester.getitem("def test_func(): pass")
ss = item.session._setupstate
ss.prepare(item)
ss.teardown_exact(None)
ss.teardown_exact(None)
ss.teardown_exact(None)
def test_func_reportinfo(self, pytester: Pytester) -> None:
item = pytester.getitem("def test_func(): pass")
fspath, lineno, modpath = item.reportinfo()
with pytest.warns(DeprecationWarning):
assert fspath == item.fspath
assert lineno == 0
assert modpath == "test_func"
def test_skipif_using_platform(self, pytester: Pytester) -> None:
item = pytester.getitem("""
import pytest
@pytest.mark.skipif("platform.platform() == platform.platform()")
def test_func():
pass
""")
pytest.raises(pytest.skip.Exception,
lambda: pytest_runtest_setup(item))
def test_setup(self, pytester: Pytester) -> None:
item = pytester.getitem("def test_func(): pass")
ss = item.session._setupstate
values = [1]
ss.prepare(item)
ss.addfinalizer(values.pop, item)
assert values
ss.teardown_exact(None)
assert not values
def test_setup(self, pytester: Pytester) -> None:
ss = runner.SetupState()
item = pytester.getitem("def test_func(): pass")
values = [1]
ss.prepare(item)
ss.addfinalizer(values.pop, colitem=item)
assert values
ss._pop_and_teardown()
assert not values
def test_make_hook_recorder(pytester: Pytester) -> None:
item = pytester.getitem("def test_func(): pass")
recorder = pytester.make_hook_recorder(item.config.pluginmanager)
assert not recorder.getfailures()
# (The silly condition is to fool mypy that the code below this is reachable)
if 1 + 1 == 2:
pytest.xfail("internal reportrecorder tests need refactoring")
class rep:
excinfo = None
passed = False
failed = True
skipped = False
when = "call"
recorder.hook.pytest_runtest_logreport(
report=rep) # type: ignore[attr-defined]
failures = recorder.getfailures()
assert failures == [rep] # type: ignore[comparison-overlap]
failures = recorder.getfailures()
assert failures == [rep] # type: ignore[comparison-overlap]
class rep2:
excinfo = None
passed = False
failed = False
skipped = True
when = "call"
rep2.passed = False
rep2.skipped = True
recorder.hook.pytest_runtest_logreport(
report=rep2) # type: ignore[attr-defined]
modcol = pytester.getmodulecol("")
rep3 = modcol.config.hook.pytest_make_collect_report(collector=modcol)
rep3.passed = False
rep3.failed = True
rep3.skipped = False
recorder.hook.pytest_collectreport(
report=rep3) # type: ignore[attr-defined]
passed, skipped, failed = recorder.listoutcomes()
assert not passed and skipped and failed
numpassed, numskipped, numfailed = recorder.countoutcomes()
assert numpassed == 0
assert numskipped == 1
assert numfailed == 1
assert len(recorder.getfailedcollections()) == 1
recorder.unregister() # type: ignore[attr-defined]
recorder.clear()
recorder.hook.pytest_runtest_logreport(
report=rep3) # type: ignore[attr-defined]
pytest.raises(ValueError, recorder.getfailures)
def test_marked_skipif_no_args(self, pytester: Pytester) -> None:
item = pytester.getitem("""
import pytest
@pytest.mark.skipif
def test_func():
pass
""")
skipped = evaluate_skip_marks(item)
assert skipped
assert skipped.reason == ""
def test_marked_one_arg(self, pytester: Pytester) -> None:
item = pytester.getitem("""
import pytest
@pytest.mark.skipif("hasattr(os, 'sep')")
def test_func():
pass
""")
skipped = evaluate_skip_marks(item)
assert skipped
assert skipped.reason == "condition: hasattr(os, 'sep')"
def test_marked_one_arg_with_reason(self, pytester: Pytester) -> None:
item = pytester.getitem("""
import pytest
@pytest.mark.skipif("hasattr(os, 'sep')", attr=2, reason="hello world")
def test_func():
pass
""")
skipped = evaluate_skip_marks(item)
assert skipped
assert skipped.reason == "hello world"
def test_skipif_conditional(self, pytester: Pytester) -> None:
item = pytester.getitem("""
import pytest
@pytest.mark.skipif("hasattr(os, 'sep')")
def test_func():
pass
""")
x = pytest.raises(pytest.skip.Exception,
lambda: pytest_runtest_setup(item))
assert x.value.msg == "condition: hasattr(os, 'sep')"
def test_setup_fails_and_failure_is_cached(self,
pytester: Pytester) -> None:
item = pytester.getitem("""
def setup_module(mod):
raise ValueError(42)
def test_func(): pass
""")
ss = runner.SetupState()
pytest.raises(ValueError, lambda: ss.prepare(item))
pytest.raises(ValueError, lambda: ss.prepare(item))
def test_marked_xfail_no_args(self, pytester: Pytester) -> None:
item = pytester.getitem("""
import pytest
@pytest.mark.xfail
def test_func():
pass
""")
xfailed = evaluate_xfail_marks(item)
assert xfailed
assert xfailed.reason == ""
assert xfailed.run
def test_xfail_simple(self, pytester: Pytester, strict: bool) -> None:
item = pytester.getitem("""
import pytest
@pytest.mark.xfail(strict=%s)
def test_func():
assert 0
""" % strict)
reports = runtestprotocol(item, log=False)
assert len(reports) == 3
callreport = reports[1]
assert callreport.skipped
assert callreport.wasxfail == ""
def test_xfail_xpassed(self, pytester: Pytester) -> None:
item = pytester.getitem("""
import pytest
@pytest.mark.xfail(reason="this is an xfail")
def test_func():
assert 1
""")
reports = runtestprotocol(item, log=False)
assert len(reports) == 3
callreport = reports[1]
assert callreport.passed
assert callreport.wasxfail == "this is an xfail"
def test_xfail_using_platform(self, pytester: Pytester) -> None:
"""Verify that platform can be used with xfail statements."""
item = pytester.getitem("""
import pytest
@pytest.mark.xfail("platform.platform() == platform.platform()")
def test_func():
assert 0
""")
reports = runtestprotocol(item, log=False)
assert len(reports) == 3
callreport = reports[1]
assert callreport.wasxfail
def test_setup_fails_and_failure_is_cached(self,
pytester: Pytester) -> None:
item = pytester.getitem("""
def setup_module(mod):
raise ValueError(42)
def test_func(): pass
""")
ss = item.session._setupstate
with pytest.raises(ValueError):
ss.prepare(item)
with pytest.raises(ValueError):
ss.prepare(item)
def test_xfail_evalfalse_but_fails(self, pytester: Pytester) -> None:
item = pytester.getitem("""
import pytest
@pytest.mark.xfail('False')
def test_func():
assert 0
""")
reports = runtestprotocol(item, log=False)
callreport = reports[1]
assert callreport.failed
assert not hasattr(callreport, "wasxfail")
assert "xfail" in callreport.keywords
def test_xfail_xpassed_strict(self, pytester: Pytester) -> None:
item = pytester.getitem("""
import pytest
@pytest.mark.xfail(strict=True, reason="nope")
def test_func():
assert 1
""")
reports = runtestprotocol(item, log=False)
assert len(reports) == 3
callreport = reports[1]
assert callreport.failed
assert str(callreport.longrepr) == "[XPASS(strict)] nope"
assert not hasattr(callreport, "wasxfail")
def test_itemreport_reportinfo(self, pytester: Pytester) -> None:
pytester.makeconftest("""
import pytest
class MyFunction(pytest.Function):
def reportinfo(self):
return "ABCDE", 42, "custom"
def pytest_pycollect_makeitem(collector, name, obj):
if name == "test_func":
return MyFunction.from_parent(name=name, parent=collector)
""")
item = pytester.getitem("def test_func(): pass")
item.config.pluginmanager.getplugin("runner")
assert item.location == ("ABCDE", 42, "custom")
def test_marked_skipif_with_boolean_without_reason(
self, pytester: Pytester) -> None:
item = pytester.getitem("""
import pytest
@pytest.mark.skipif(False)
def test_func():
pass
""")
with pytest.raises(pytest.fail.Exception) as excinfo:
evaluate_skip_marks(item)
assert excinfo.value.msg is not None
assert (
"""Error evaluating 'skipif': you need to specify reason=STRING when using booleans as conditions."""
in excinfo.value.msg)
def test_pyfunc_call(self, pytester: Pytester) -> None:
item = pytester.getitem("def test_func(): raise ValueError")
config = item.config
class MyPlugin1:
def pytest_pyfunc_call(self):
raise ValueError
class MyPlugin2:
def pytest_pyfunc_call(self):
return True
config.pluginmanager.register(MyPlugin1())
config.pluginmanager.register(MyPlugin2())
config.hook.pytest_runtest_setup(item=item)
config.hook.pytest_pyfunc_call(pyfuncitem=item)
def test_teardown_multiple_fail(self, pytester: Pytester) -> None:
# Ensure the first exception is the one which is re-raised.
# Ideally both would be reported however.
def fin1():
raise Exception("oops1")
def fin2():
raise Exception("oops2")
item = pytester.getitem("def test_func(): pass")
ss = runner.SetupState()
ss.addfinalizer(fin1, item)
ss.addfinalizer(fin2, item)
with pytest.raises(Exception) as err:
ss._callfinalizers(item)
assert err.value.args == ("oops2", )
def test_marked_one_arg_twice(self, pytester: Pytester) -> None:
lines = [
"""@pytest.mark.skipif("not hasattr(os, 'murks')")""",
"""@pytest.mark.skipif(condition="hasattr(os, 'murks')")""",
]
for i in range(0, 2):
item = pytester.getitem("""
import pytest
%s
%s
def test_func():
pass
""" % (lines[i], lines[(i + 1) % 2]))
skipped = evaluate_skip_marks(item)
assert skipped
assert skipped.reason == "condition: not hasattr(os, 'murks')"
def test_teardown_multiple_scopes_one_fails(self,
pytester: Pytester) -> None:
module_teardown = []
def fin_func():
raise Exception("oops1")
def fin_module():
module_teardown.append("fin_module")
item = pytester.getitem("def test_func(): pass")
ss = runner.SetupState()
ss.addfinalizer(fin_module, item.listchain()[-2])
ss.addfinalizer(fin_func, item)
ss.prepare(item)
with pytest.raises(Exception, match="oops1"):
ss.teardown_exact(item, None)
assert module_teardown
def test_marked_skipif_with_invalid_boolean(self,
pytester: Pytester) -> None:
item = pytester.getitem("""
import pytest
class InvalidBool:
def __bool__(self):
raise TypeError("INVALID")
@pytest.mark.skipif(InvalidBool(), reason="xxx")
def test_func():
pass
""")
with pytest.raises(pytest.fail.Exception) as excinfo:
evaluate_skip_marks(item)
assert excinfo.value.msg is not None
assert "Error evaluating 'skipif' condition as a boolean" in excinfo.value.msg
assert "INVALID" in excinfo.value.msg
def test_teardown_multiple_scopes_one_fails(self,
pytester: Pytester) -> None:
module_teardown = []
def fin_func():
raise Exception("oops1")
def fin_module():
module_teardown.append("fin_module")
item = pytester.getitem("def test_func(): pass")
mod = item.listchain()[-2]
ss = item.session._setupstate
ss.setup(item)
ss.addfinalizer(fin_module, mod)
ss.addfinalizer(fin_func, item)
with pytest.raises(Exception, match="oops1"):
ss.teardown_exact(None)
assert module_teardown == ["fin_module"]
def test_teardown_multiple_one_fails(self, pytester: Pytester) -> None:
r = []
def fin1():
r.append("fin1")
def fin2():
raise Exception("oops")
def fin3():
r.append("fin3")
item = pytester.getitem("def test_func(): pass")
ss = runner.SetupState()
ss.addfinalizer(fin1, item)
ss.addfinalizer(fin2, item)
ss.addfinalizer(fin3, item)
with pytest.raises(Exception) as err:
ss._callfinalizers(item)
assert err.value.args == ("oops", )
assert r == ["fin3", "fin1"]
def test_teardown_multiple_one_fails(self, pytester: Pytester) -> None:
r = []
def fin1():
r.append("fin1")
def fin2():
raise Exception("oops")
def fin3():
r.append("fin3")
item = pytester.getitem("def test_func(): pass")
ss = item.session._setupstate
ss.prepare(item)
ss.addfinalizer(fin1, item)
ss.addfinalizer(fin2, item)
ss.addfinalizer(fin3, item)
with pytest.raises(Exception) as err:
ss.teardown_exact(None)
assert err.value.args == ("oops", )
assert r == ["fin3", "fin1"]
def test_teardown_exact_stack_empty(self, pytester: Pytester) -> None:
item = pytester.getitem("def test_func(): pass")
ss = runner.SetupState()
ss.teardown_exact(item, None)
ss.teardown_exact(item, None)
ss.teardown_exact(item, None)
def test_no_marker(self, pytester: Pytester) -> None:
item = pytester.getitem("def test_func(): pass")
skipped = evaluate_skip_marks(item)
assert not skipped
