test_ok2/testing/test_runner_xunit.py

"""
 test correct setup/teardowns at
 module, class, and instance level
"""
from __future__ import absolute_import, division, print_function
import pytest


def test_module_and_function_setup(testdir):
    reprec = testdir.inline_runsource("""
        modlevel = []
        def setup_module(module):
            assert not modlevel
            module.modlevel.append(42)

        def teardown_module(module):
            modlevel.pop()

        def setup_function(function):
            function.answer = 17

        def teardown_function(function):
            del function.answer

        def test_modlevel():
            assert modlevel[0] == 42
            assert test_modlevel.answer == 17

        class TestFromClass(object):
            def test_module(self):
                assert modlevel[0] == 42
                assert not hasattr(test_modlevel, 'answer')
    """)
    rep = reprec.matchreport("test_modlevel")
    assert rep.passed
    rep = reprec.matchreport("test_module")
    assert rep.passed

def test_module_setup_failure_no_teardown(testdir):
    reprec = testdir.inline_runsource("""
        l = []
        def setup_module(module):
            l.append(1)
            0/0

        def test_nothing():
            pass

        def teardown_module(module):
            l.append(2)
    """)
    reprec.assertoutcome(failed=1)
    calls = reprec.getcalls("pytest_runtest_setup")
    assert calls[0].item.module.l == [1]

def test_setup_function_failure_no_teardown(testdir):
    reprec = testdir.inline_runsource("""
        modlevel = []
        def setup_function(function):
            modlevel.append(1)
            0/0

        def teardown_function(module):
            modlevel.append(2)

        def test_func():
            pass
    """)
    calls = reprec.getcalls("pytest_runtest_setup")
    assert calls[0].item.module.modlevel == [1]

def test_class_setup(testdir):
    reprec = testdir.inline_runsource("""
        class TestSimpleClassSetup(object):
            clslevel = []
            def setup_class(cls):
                cls.clslevel.append(23)

            def teardown_class(cls):
                cls.clslevel.pop()

            def test_classlevel(self):
                assert self.clslevel[0] == 23

        class TestInheritedClassSetupStillWorks(TestSimpleClassSetup):
            def test_classlevel_anothertime(self):
                assert self.clslevel == [23]

        def test_cleanup():
            assert not TestSimpleClassSetup.clslevel
            assert not TestInheritedClassSetupStillWorks.clslevel
    """)
    reprec.assertoutcome(passed=1+2+1)

def test_class_setup_failure_no_teardown(testdir):
    reprec = testdir.inline_runsource("""
        class TestSimpleClassSetup(object):
            clslevel = []
            def setup_class(cls):
                0/0

            def teardown_class(cls):
                cls.clslevel.append(1)

            def test_classlevel(self):
                pass

        def test_cleanup():
            assert not TestSimpleClassSetup.clslevel
    """)
    reprec.assertoutcome(failed=1, passed=1)

def test_method_setup(testdir):
    reprec = testdir.inline_runsource("""
        class TestSetupMethod(object):
            def setup_method(self, meth):
                self.methsetup = meth
            def teardown_method(self, meth):
                del self.methsetup

            def test_some(self):
                assert self.methsetup == self.test_some

            def test_other(self):
                assert self.methsetup == self.test_other
    """)
    reprec.assertoutcome(passed=2)

def test_method_setup_failure_no_teardown(testdir):
    reprec = testdir.inline_runsource("""
        class TestMethodSetup(object):
            clslevel = []
            def setup_method(self, method):
                self.clslevel.append(1)
                0/0

            def teardown_method(self, method):
                self.clslevel.append(2)

            def test_method(self):
                pass

        def test_cleanup():
            assert TestMethodSetup.clslevel == [1]
    """)
    reprec.assertoutcome(failed=1, passed=1)

def test_method_generator_setup(testdir):
    reprec = testdir.inline_runsource("""
        class TestSetupTeardownOnInstance(object):
            def setup_class(cls):
                cls.classsetup = True

            def setup_method(self, method):
                self.methsetup = method

            def test_generate(self):
                assert self.classsetup
                assert self.methsetup == self.test_generate
                yield self.generated, 5
                yield self.generated, 2

            def generated(self, value):
                assert self.classsetup
                assert self.methsetup == self.test_generate
                assert value == 5
    """)
    reprec.assertoutcome(passed=1, failed=1)

def test_func_generator_setup(testdir):
    reprec = testdir.inline_runsource("""
        import sys

        def setup_module(mod):
            print ("setup_module")
            mod.x = []

        def setup_function(fun):
            print ("setup_function")
            x.append(1)

        def teardown_function(fun):
            print ("teardown_function")
            x.pop()

        def test_one():
            assert x == [1]
            def check():
                print ("check")
                sys.stderr.write("e\\n")
                assert x == [1]
            yield check
            assert x == [1]
    """)
    rep = reprec.matchreport("test_one", names="pytest_runtest_logreport")
    assert rep.passed

def test_method_setup_uses_fresh_instances(testdir):
    reprec = testdir.inline_runsource("""
        class TestSelfState1(object):
            memory = []
            def test_hello(self):
                self.memory.append(self)

            def test_afterhello(self):
                assert self != self.memory[0]
    """)
    reprec.assertoutcome(passed=2, failed=0)

def test_setup_that_skips_calledagain(testdir):
    p = testdir.makepyfile("""
        import pytest
        def setup_module(mod):
            pytest.skip("x")
        def test_function1():
            pass
        def test_function2():
            pass
    """)
    reprec = testdir.inline_run(p)
    reprec.assertoutcome(skipped=2)

def test_setup_fails_again_on_all_tests(testdir):
    p = testdir.makepyfile("""
        import pytest
        def setup_module(mod):
            raise ValueError(42)
        def test_function1():
            pass
        def test_function2():
            pass
    """)
    reprec = testdir.inline_run(p)
    reprec.assertoutcome(failed=2)

def test_setup_funcarg_setup_when_outer_scope_fails(testdir):
    p = testdir.makepyfile("""
        import pytest
        def setup_module(mod):
            raise ValueError(42)
        @pytest.fixture
        def hello(request):
            raise ValueError("xyz43")
        def test_function1(hello):
            pass
        def test_function2(hello):
            pass
    """)
    result = testdir.runpytest(p)
    result.stdout.fnmatch_lines([
        "*function1*",
        "*ValueError*42*",
        "*function2*",
        "*ValueError*42*",
        "*2 error*"
    ])
    assert "xyz43" not in result.stdout.str()


@pytest.mark.parametrize('arg', ['', 'arg'])
def test_setup_teardown_function_level_with_optional_argument(testdir, monkeypatch, arg):
    """parameter to setup/teardown xunit-style functions parameter is now optional (#1728)."""
    import sys
    trace_setups_teardowns = []
    monkeypatch.setattr(sys, 'trace_setups_teardowns', trace_setups_teardowns, raising=False)
    p = testdir.makepyfile("""
        import pytest
        import sys

        trace = sys.trace_setups_teardowns.append

        def setup_module({arg}): trace('setup_module')
        def teardown_module({arg}): trace('teardown_module')

        def setup_function({arg}): trace('setup_function')
        def teardown_function({arg}): trace('teardown_function')

        def test_function_1(): pass
        def test_function_2(): pass

        class Test(object):
            def setup_method(self, {arg}): trace('setup_method')
            def teardown_method(self, {arg}): trace('teardown_method')

            def test_method_1(self): pass
            def test_method_2(self): pass
    """.format(arg=arg))
    result = testdir.inline_run(p)
    result.assertoutcome(passed=4)

    expected = [
        'setup_module',

        'setup_function',
        'teardown_function',
        'setup_function',
        'teardown_function',

        'setup_method',
        'teardown_method',

        'setup_method',
        'teardown_method',

        'teardown_module',
    ]
    assert trace_setups_teardowns == expected