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