merge with upstream

2013-07-06 10:06:12 +02:00
parent c93fbb0e57 ab637e028b
commit 2c7613c15c
60 changed files with 1623 additions and 477 deletions
--- a/testing/python/fixture.py
+++ b/testing/python/fixture.py
@@ -1712,6 +1712,20 @@ class TestFixtureMarker:
        reprec = testdir.inline_run("-v")
        reprec.assertoutcome(passed=6)

+    def test_fixture_marked_function_not_collected_as_test(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+            @pytest.fixture
+            def test_app():
+                return 1
+
+            def test_something(test_app):
+                assert test_app == 1
+        """)
+        reprec = testdir.inline_run()
+        reprec.assertoutcome(passed=1)
+
+
 class TestRequestScopeAccess:
    pytestmark = pytest.mark.parametrize(("scope", "ok", "error"),[
        ["session", "", "fspath class function module"],
@@ -1852,3 +1866,101 @@ class TestShowFixtures:
            *hello world*
        """)

+
+
+class TestContextManagerFixtureFuncs:
+    def test_simple(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+            @pytest.fixture
+            def arg1():
+                print ("setup")
+                yield 1
+                print ("teardown")
+            def test_1(arg1):
+                print ("test1 %s" % arg1)
+            def test_2(arg1):
+                print ("test2 %s" % arg1)
+                assert 0
+        """)
+        result = testdir.runpytest("-s")
+        result.stdout.fnmatch_lines("""
+            setup
+            test1 1
+            teardown
+            setup
+            test2 1
+            teardown
+        """)
+
+    def test_scoped(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+            @pytest.fixture(scope="module")
+            def arg1():
+                print ("setup")
+                yield 1
+                print ("teardown")
+            def test_1(arg1):
+                print ("test1 %s" % arg1)
+            def test_2(arg1):
+                print ("test2 %s" % arg1)
+        """)
+        result = testdir.runpytest("-s")
+        result.stdout.fnmatch_lines("""
+            setup
+            test1 1
+            test2 1
+            teardown
+        """)
+
+    def test_setup_exception(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+            @pytest.fixture(scope="module")
+            def arg1():
+                pytest.fail("setup")
+                yield 1
+            def test_1(arg1):
+                pass
+        """)
+        result = testdir.runpytest("-s")
+        result.stdout.fnmatch_lines("""
+            *pytest.fail*setup*
+            *1 error*
+        """)
+
+    def test_teardown_exception(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+            @pytest.fixture(scope="module")
+            def arg1():
+                yield 1
+                pytest.fail("teardown")
+            def test_1(arg1):
+                pass
+        """)
+        result = testdir.runpytest("-s")
+        result.stdout.fnmatch_lines("""
+            *pytest.fail*teardown*
+            *1 passed*1 error*
+        """)
+
+
+    def test_yields_more_than_one(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+            @pytest.fixture(scope="module")
+            def arg1():
+                yield 1
+                yield 2
+            def test_1(arg1):
+                pass
+        """)
+        result = testdir.runpytest("-s")
+        result.stdout.fnmatch_lines("""
+            *fixture function*
+            *test_yields*:2*
+        """)
+
+
--- a/testing/python/integration.py
+++ b/testing/python/integration.py
@@ -117,3 +117,35 @@ class TestMockDecoration:
        """)
        reprec = testdir.inline_run()
        reprec.assertoutcome(passed=2)
+
+
+class TestReRunTests:
+    def test_rerun(self, testdir):
+        testdir.makeconftest("""
+            from _pytest.runner import runtestprotocol
+            def pytest_runtest_protocol(item, nextitem):
+                runtestprotocol(item, log=False, nextitem=nextitem)
+                runtestprotocol(item, log=True, nextitem=nextitem)
+        """)
+        testdir.makepyfile("""
+            import pytest
+            count = 0
+            req = None
+            @pytest.fixture
+            def fix(request):
+                global count, req
+                assert request != req
+                req = request
+                print ("fix count %s" % count)
+                count += 1
+            def test_fix(fix):
+                pass
+        """)
+        result = testdir.runpytest("-s")
+        result.stdout.fnmatch_lines("""
+            *fix count 0*
+            *fix count 1*
+        """)
+        result.stdout.fnmatch_lines("""
+            *2 passed*
+        """)
--- a/testing/python/metafunc.py
+++ b/testing/python/metafunc.py
@@ -221,6 +221,16 @@ class TestMetafunc:
            "*6 fail*",
        ])

+    def test_parametrize_CSV(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+            @pytest.mark.parametrize("x, y,", [(1,2), (2,3)])
+            def test_func(x, y):
+                assert x+1 == y
+        """)
+        reprec = testdir.inline_run()
+        reprec.assertoutcome(passed=2)
+
    def test_parametrize_class_scenarios(self, testdir):
        testdir.makepyfile("""
        # same as doc/en/example/parametrize scenario example
@@ -545,6 +555,20 @@ class TestMetafuncFunctional:
        reprec = testdir.inline_run()
        reprec.assertoutcome(passed=5)

+    def test_parametrize_issue323(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+
+            @pytest.fixture(scope='module', params=range(966))
+            def foo(request):
+                return request.param
+
+            def test_it(foo):
+                pass
+        """)
+        reprec = testdir.inline_run("--collectonly")
+        assert not reprec.getcalls("pytest_internalerror")
+
    def test_usefixtures_seen_in_generate_tests(self, testdir):
        testdir.makepyfile("""
            import pytest
@@ -578,3 +602,186 @@ class TestMetafuncFunctional:
        ])


+class TestMarkersWithParametrization:
+    pytestmark = pytest.mark.issue308
+    def test_simple_mark(self, testdir):
+        s = """
+            import pytest
+
+            @pytest.mark.foo
+            @pytest.mark.parametrize(("n", "expected"), [
+                (1, 2),
+                pytest.mark.bar((1, 3)),
+                (2, 3),
+            ])
+            def test_increment(n, expected):
+                assert n + 1 == expected
+        """
+        items = testdir.getitems(s)
+        assert len(items) == 3
+        for item in items:
+            assert 'foo' in item.keywords
+        assert 'bar' not in items[0].keywords
+        assert 'bar' in items[1].keywords
+        assert 'bar' not in items[2].keywords
+
+    def test_select_based_on_mark(self, testdir):
+        s = """
+            import pytest
+
+            @pytest.mark.parametrize(("n", "expected"), [
+                (1, 2),
+                pytest.mark.foo((2, 3)),
+                (3, 4),
+            ])
+            def test_increment(n, expected):
+                assert n + 1 == expected
+        """
+        testdir.makepyfile(s)
+        rec = testdir.inline_run("-m", 'foo')
+        passed, skipped, fail = rec.listoutcomes()
+        assert len(passed) == 1
+        assert len(skipped) == 0
+        assert len(fail) == 0
+
+    @pytest.mark.xfail(reason="is this important to support??")
+    def test_nested_marks(self, testdir):
+        s = """
+            import pytest
+            mastermark = pytest.mark.foo(pytest.mark.bar)
+
+            @pytest.mark.parametrize(("n", "expected"), [
+                (1, 2),
+                mastermark((1, 3)),
+                (2, 3),
+            ])
+            def test_increment(n, expected):
+                assert n + 1 == expected
+        """
+        items = testdir.getitems(s)
+        assert len(items) == 3
+        for mark in ['foo', 'bar']:
+            assert mark not in items[0].keywords
+            assert mark in items[1].keywords
+            assert mark not in items[2].keywords
+
+    def test_simple_xfail(self, testdir):
+        s = """
+            import pytest
+
+            @pytest.mark.parametrize(("n", "expected"), [
+                (1, 2),
+                pytest.mark.xfail((1, 3)),
+                (2, 3),
+            ])
+            def test_increment(n, expected):
+                assert n + 1 == expected
+        """
+        testdir.makepyfile(s)
+        reprec = testdir.inline_run()
+        # xfail is skip??
+        reprec.assertoutcome(passed=2, skipped=1)
+
+    def test_simple_xfail_single_argname(self, testdir):
+        s = """
+            import pytest
+
+            @pytest.mark.parametrize("n", [
+                2,
+                pytest.mark.xfail(3),
+                4,
+            ])
+            def test_isEven(n):
+                assert n % 2 == 0
+        """
+        testdir.makepyfile(s)
+        reprec = testdir.inline_run()
+        reprec.assertoutcome(passed=2, skipped=1)
+
+    def test_xfail_with_arg(self, testdir):
+        s = """
+            import pytest
+
+            @pytest.mark.parametrize(("n", "expected"), [
+                (1, 2),
+                pytest.mark.xfail("True")((1, 3)),
+                (2, 3),
+            ])
+            def test_increment(n, expected):
+                assert n + 1 == expected
+        """
+        testdir.makepyfile(s)
+        reprec = testdir.inline_run()
+        reprec.assertoutcome(passed=2, skipped=1)
+
+    def test_xfail_with_kwarg(self, testdir):
+        s = """
+            import pytest
+
+            @pytest.mark.parametrize(("n", "expected"), [
+                (1, 2),
+                pytest.mark.xfail(reason="some bug")((1, 3)),
+                (2, 3),
+            ])
+            def test_increment(n, expected):
+                assert n + 1 == expected
+        """
+        testdir.makepyfile(s)
+        reprec = testdir.inline_run()
+        reprec.assertoutcome(passed=2, skipped=1)
+
+    def test_xfail_with_arg_and_kwarg(self, testdir):
+        s = """
+            import pytest
+
+            @pytest.mark.parametrize(("n", "expected"), [
+                (1, 2),
+                pytest.mark.xfail("True", reason="some bug")((1, 3)),
+                (2, 3),
+            ])
+            def test_increment(n, expected):
+                assert n + 1 == expected
+        """
+        testdir.makepyfile(s)
+        reprec = testdir.inline_run()
+        reprec.assertoutcome(passed=2, skipped=1)
+
+    def test_xfail_passing_is_xpass(self, testdir):
+        s = """
+            import pytest
+
+            @pytest.mark.parametrize(("n", "expected"), [
+                (1, 2),
+                pytest.mark.xfail("sys.version > 0", reason="some bug")((2, 3)),
+                (3, 4),
+            ])
+            def test_increment(n, expected):
+                assert n + 1 == expected
+        """
+        testdir.makepyfile(s)
+        reprec = testdir.inline_run()
+        # xpass is fail, obviously :)
+        reprec.assertoutcome(passed=2, failed=1)
+
+    def test_parametrize_called_in_generate_tests(self, testdir):
+        s = """
+            import pytest
+
+
+            def pytest_generate_tests(metafunc):
+                passingTestData = [(1, 2),
+                                   (2, 3)]
+                failingTestData = [(1, 3),
+                                   (2, 2)]
+
+                testData = passingTestData + [pytest.mark.xfail(d)
+                                  for d in failingTestData]
+                metafunc.parametrize(("n", "expected"), testData)
+
+
+            def test_increment(n, expected):
+                assert n + 1 == expected
+        """
+        testdir.makepyfile(s)
+        reprec = testdir.inline_run()
+        reprec.assertoutcome(passed=2, skipped=2)