Merge remote-tracking branch 'upstream/master' into merge-master-into-features

testing/code/test_code.py

@@ -1,13 +1,19 @@
 # coding: utf-8
 from __future__ import absolute_import, division, print_function
+
 import sys
 
 import _pytest._code
 import pytest
-import mock
-from test_excinfo import TWMock
 from six import text_type
 
+from test_excinfo import TWMock
+
+try:
+    import mock
+except ImportError:
+    import unittest.mock as mock
+
 
 def test_ne():
     code1 = _pytest._code.Code(compile('foo = "bar"', "", "exec"))

testing/example_scripts/collect/package_init_given_as_arg/pkg/test_foo.py

@@ -0,0 +1,2 @@
+def test():
+    pass

testing/python/collect.py

@@ -1597,6 +1597,13 @@ def test_package_collection_infinite_recursion(testdir):
     result.stdout.fnmatch_lines("*1 passed*")
 
 
+def test_package_collection_init_given_as_argument(testdir):
+    """Regression test for #3749"""
+    p = testdir.copy_example("collect/package_init_given_as_arg")
+    result = testdir.runpytest(p / "pkg" / "__init__.py")
+    result.stdout.fnmatch_lines("*1 passed*")
+
+
 def test_package_with_modules(testdir):
     """
     .

testing/python/fixture.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import sys
 import textwrap
 
 import pytest
@@ -488,6 +489,10 @@ class TestRequestBasic(object):
         assert len(arg2fixturedefs) == 1
         assert arg2fixturedefs["something"][0].argname == "something"
 
+    @pytest.mark.skipif(
+        hasattr(sys, "pypy_version_info"),
+        reason="this method of test doesn't work on pypy",
+    )
     def test_request_garbage(self, testdir):
         testdir.makepyfile(
             """
@@ -498,33 +503,32 @@ class TestRequestBasic(object):
 
             @pytest.fixture(autouse=True)
             def something(request):
-                # this method of test doesn't work on pypy
-                if hasattr(sys, "pypy_version_info"):
-                    yield
-                else:
-                    original = gc.get_debug()
-                    gc.set_debug(gc.DEBUG_SAVEALL)
-                    gc.collect()
+                original = gc.get_debug()
+                gc.set_debug(gc.DEBUG_SAVEALL)
+                gc.collect()
 
-                    yield
+                yield
 
+                try:
                     gc.collect()
                     leaked_types = sum(1 for _ in gc.garbage
                                        if isinstance(_, PseudoFixtureDef))
 
+                    # debug leaked types if the test fails
+                    print(leaked_types)
+
                     gc.garbage[:] = []
 
-                    try:
-                        assert leaked_types == 0
-                    finally:
-                        gc.set_debug(original)
+                    assert leaked_types == 0
+                finally:
+                    gc.set_debug(original)
 
             def test_func():
                 pass
         """
         )
-        reprec = testdir.inline_run()
-        reprec.assertoutcome(passed=1)
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines("* 1 passed in *")
 
     def test_getfixturevalue_recursive(self, testdir):
         testdir.makeconftest(

testing/python/metafunc.py

@@ -132,6 +132,52 @@ class TestMetafunc(object):
         except ValueError as ve:
             assert "has an unsupported scope value 'doggy'" in str(ve)
 
+    def test_find_parametrized_scope(self):
+        """unittest for _find_parametrized_scope (#3941)"""
+        from _pytest.python import _find_parametrized_scope
+
+        @attr.s
+        class DummyFixtureDef(object):
+            scope = attr.ib()
+
+        fixtures_defs = dict(
+            session_fix=[DummyFixtureDef("session")],
+            package_fix=[DummyFixtureDef("package")],
+            module_fix=[DummyFixtureDef("module")],
+            class_fix=[DummyFixtureDef("class")],
+            func_fix=[DummyFixtureDef("function")],
+        )
+
+        # use arguments to determine narrow scope; the cause of the bug is that it would look on all
+        # fixture defs given to the method
+        def find_scope(argnames, indirect):
+            return _find_parametrized_scope(argnames, fixtures_defs, indirect=indirect)
+
+        assert find_scope(["func_fix"], indirect=True) == "function"
+        assert find_scope(["class_fix"], indirect=True) == "class"
+        assert find_scope(["module_fix"], indirect=True) == "module"
+        assert find_scope(["package_fix"], indirect=True) == "package"
+        assert find_scope(["session_fix"], indirect=True) == "session"
+
+        assert find_scope(["class_fix", "func_fix"], indirect=True) == "function"
+        assert find_scope(["func_fix", "session_fix"], indirect=True) == "function"
+        assert find_scope(["session_fix", "class_fix"], indirect=True) == "class"
+        assert find_scope(["package_fix", "session_fix"], indirect=True) == "package"
+        assert find_scope(["module_fix", "session_fix"], indirect=True) == "module"
+
+        # when indirect is False or is not for all scopes, always use function
+        assert find_scope(["session_fix", "module_fix"], indirect=False) == "function"
+        assert (
+            find_scope(["session_fix", "module_fix"], indirect=["module_fix"])
+            == "function"
+        )
+        assert (
+            find_scope(
+                ["session_fix", "module_fix"], indirect=["session_fix", "module_fix"]
+            )
+            == "module"
+        )
+
     def test_parametrize_and_id(self):
         def func(x, y):
             pass
@@ -796,7 +842,7 @@ class TestMetafuncFunctional(object):
         p = testdir.makepyfile(
             """
             # assumes that generate/provide runs in the same process
-            import sys, pytest
+            import sys, pytest, six
             def pytest_generate_tests(metafunc):
                 metafunc.addcall(param=metafunc)
 
@@ -815,11 +861,7 @@ class TestMetafuncFunctional(object):
                 def test_method(self, metafunc, pytestconfig):
                     assert metafunc.config == pytestconfig
                     assert metafunc.module.__name__ == __name__
-                    if sys.version_info > (3, 0):
-                        unbound = TestClass.test_method
-                    else:
-                        unbound = TestClass.test_method.im_func
-                    # XXX actually have an unbound test function here?
+                    unbound = six.get_unbound_function(TestClass.test_method)
                     assert metafunc.function == unbound
                     assert metafunc.cls == TestClass
         """
@@ -1387,6 +1429,39 @@ class TestMetafuncFunctionalAuto(object):
         result = testdir.runpytest()
         result.stdout.fnmatch_lines(["* 3 passed *"])
 
+    def test_parametrize_some_arguments_auto_scope(self, testdir, monkeypatch):
+        """Integration test for (#3941)"""
+        class_fix_setup = []
+        monkeypatch.setattr(sys, "class_fix_setup", class_fix_setup, raising=False)
+        func_fix_setup = []
+        monkeypatch.setattr(sys, "func_fix_setup", func_fix_setup, raising=False)
+
+        testdir.makepyfile(
+            """
+            import pytest
+            import sys
+
+            @pytest.fixture(scope='class', autouse=True)
+            def class_fix(request):
+                sys.class_fix_setup.append(request.param)
+
+            @pytest.fixture(autouse=True)
+            def func_fix():
+                sys.func_fix_setup.append(True)
+
+            @pytest.mark.parametrize('class_fix', [10, 20], indirect=True)
+            class Test:
+                def test_foo(self):
+                    pass
+                def test_bar(self):
+                    pass
+            """
+        )
+        result = testdir.runpytest_inprocess()
+        result.stdout.fnmatch_lines(["* 4 passed in *"])
+        assert func_fix_setup == [True] * 4
+        assert class_fix_setup == [10, 20]
+
     def test_parametrize_issue634(self, testdir):
         testdir.makepyfile(
             """

testing/test_assertrewrite.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 from __future__ import absolute_import, division, print_function
 
 import glob
@@ -57,7 +58,7 @@ def getmsg(f, extra_ns=None, must_pass=False):
     except AssertionError:
         if must_pass:
             pytest.fail("shouldn't have raised")
-        s = str(sys.exc_info()[1])
+        s = six.text_type(sys.exc_info()[1])
         if not s.startswith("assert"):
             return "AssertionError: " + s
         return s
@@ -608,6 +609,21 @@ class TestAssertionRewrite(object):
 
         assert r"where 1 = \n{ \n~ \n}.a" in util._format_lines([getmsg(f)])[0]
 
+    def test_custom_repr_non_ascii(self):
+        def f():
+            class A(object):
+                name = u"ä"
+
+                def __repr__(self):
+                    return self.name.encode("UTF-8")  # only legal in python2
+
+            a = A()
+            assert not a.name
+
+        msg = getmsg(f)
+        assert "UnicodeDecodeError" not in msg
+        assert "UnicodeEncodeError" not in msg
+
 
 class TestRewriteOnImport(object):
     def test_pycache_is_a_file(self, testdir):
@@ -1232,3 +1248,27 @@ class TestEarlyRewriteBailout(object):
         hook.fnpats[:] = ["tests/**.py"]
         assert hook.find_module("file") is not None
         assert self.find_module_calls == ["file"]
+
+    @pytest.mark.skipif(
+        sys.platform.startswith("win32"), reason="cannot remove cwd on Windows"
+    )
+    def test_cwd_changed(self, testdir):
+        testdir.makepyfile(
+            **{
+                "test_bar.py": """
+                import os
+                import shutil
+                import tempfile
+
+                d = tempfile.mkdtemp()
+                os.chdir(d)
+                shutil.rmtree(d)
+            """,
+                "test_foo.py": """
+                def test():
+                    pass
+            """,
+            }
+        )
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines("* 1 passed in *")

testing/test_cacheprovider.py

@@ -884,3 +884,14 @@ class TestReadme(object):
         )
         testdir.runpytest()
         assert self.check_readme(testdir) is True
+
+
+def test_gitignore(testdir):
+    """Ensure we automatically create .gitignore file in the pytest_cache directory (#3286)."""
+    from _pytest.cacheprovider import Cache
+
+    config = testdir.parseconfig()
+    cache = Cache.for_config(config)
+    cache.set("foo", "bar")
+    msg = "# created by pytest automatically, do not change\n*"
+    assert cache._cachedir.joinpath(".gitignore").read_text(encoding="UTF-8") == msg

testing/test_paths.py

@@ -0,0 +1,69 @@
+import sys
+
+import py
+
+import pytest
+
+from _pytest.paths import fnmatch_ex
+
+
+class TestPort:
+    """Test that our port of py.common.FNMatcher (fnmatch_ex) produces the same results as the
+    original py.path.local.fnmatch method.
+    """
+
+    @pytest.fixture(params=["pathlib", "py.path"])
+    def match(self, request):
+        if request.param == "py.path":
+
+            def match_(pattern, path):
+                return py.path.local(path).fnmatch(pattern)
+
+        else:
+            assert request.param == "pathlib"
+
+            def match_(pattern, path):
+                return fnmatch_ex(pattern, path)
+
+        return match_
+
+    if sys.platform == "win32":
+        drv1 = "c:"
+        drv2 = "d:"
+    else:
+        drv1 = "/c"
+        drv2 = "/d"
+
+    @pytest.mark.parametrize(
+        "pattern, path",
+        [
+            ("*.py", "foo.py"),
+            ("*.py", "bar/foo.py"),
+            ("test_*.py", "foo/test_foo.py"),
+            ("tests/*.py", "tests/foo.py"),
+            (drv1 + "/*.py", drv1 + "/foo.py"),
+            (drv1 + "/foo/*.py", drv1 + "/foo/foo.py"),
+            ("tests/**/test*.py", "tests/foo/test_foo.py"),
+            ("tests/**/doc/test*.py", "tests/foo/bar/doc/test_foo.py"),
+            ("tests/**/doc/**/test*.py", "tests/foo/doc/bar/test_foo.py"),
+        ],
+    )
+    def test_matching(self, match, pattern, path):
+        assert match(pattern, path)
+
+    @pytest.mark.parametrize(
+        "pattern, path",
+        [
+            ("*.py", "foo.pyc"),
+            ("*.py", "foo/foo.pyc"),
+            ("tests/*.py", "foo/foo.py"),
+            (drv1 + "/*.py", drv2 + "/foo.py"),
+            (drv1 + "/foo/*.py", drv2 + "/foo/foo.py"),
+            ("tests/**/test*.py", "tests/foo.py"),
+            ("tests/**/test*.py", "foo/test_foo.py"),
+            ("tests/**/doc/test*.py", "tests/foo/bar/doc/foo.py"),
+            ("tests/**/doc/test*.py", "tests/foo/bar/test_foo.py"),
+        ],
+    )
+    def test_not_matching(self, match, pattern, path):
+        assert not match(pattern, path)

testing/test_pdb.py

@@ -397,6 +397,24 @@ class TestPDB(object):
         child.read()
         self.flush(child)
 
+    def test_pdb_with_caplog_on_pdb_invocation(self, testdir):
+        p1 = testdir.makepyfile(
+            """
+            def test_1(capsys, caplog):
+                import logging
+                logging.getLogger(__name__).warning("some_warning")
+                assert 0
+        """
+        )
+        child = testdir.spawn_pytest("--pdb %s" % str(p1))
+        child.send("caplog.record_tuples\n")
+        child.expect_exact(
+            "[('test_pdb_with_caplog_on_pdb_invocation', 30, 'some_warning')]"
+        )
+        child.sendeof()
+        child.read()
+        self.flush(child)
+
     def test_set_trace_capturing_afterwards(self, testdir):
         p1 = testdir.makepyfile(
             """