collect_imported_tests option

Author: FreerGit

changelog/12749.feature.rst

@@ -1,3 +1,3 @@
-Add :confval:`discover_imports`, when disabled (default) will make sure to not consider classes which are imported by a test file and starts with Test.
+Add :confval:`collect_imported_tests`, when enabled (default is disabled) will make sure to not consider classes/functions which are imported by a test file and contains Test/test_*/*_test.
 
--- by :user:`FreerGit`
+-- by :user:`FreerGit`

src/_pytest/main.py

@@ -79,8 +79,9 @@ def pytest_addoption(parser: Parser) -> None:
         default=[],
     )
     parser.addini(
-        "discover_imports",
-        "Whether to discover tests in imported modules outside `testpaths`",
+        "collect_imported_tests",
+        "Whether to collect tests in imported modules outside `testpaths`",
+        type="bool",
         default=False,
     )
     group = parser.getgroup("general", "Running and selection options")
@@ -963,16 +964,41 @@ def collect(self) -> Iterator[nodes.Item | nodes.Collector]:
             self.trace.root.indent -= 1
 
     def genitems(self, node: nodes.Item | nodes.Collector) -> Iterator[nodes.Item]:
+        import inspect
+
+        from _pytest.python import Class
+        from _pytest.python import Function
+        from _pytest.python import Module
+
         self.trace("genitems", node)
         if isinstance(node, nodes.Item):
             node.ihook.pytest_itemcollected(item=node)
+            if self.config.getini("collect_imported_tests"):
+                if isinstance(node.parent, Module) and isinstance(node, Function):
+                    if inspect.isfunction(node._getobj()):
+                        fn_defined_at = node._getobj().__module__
+                        in_module = node.parent._getobj().__name__
+                        if fn_defined_at != in_module:
+                            return
             yield node
         else:
             assert isinstance(node, nodes.Collector)
             keepduplicates = self.config.getoption("keepduplicates")
             # For backward compat, dedup only applies to files.
             handle_dupes = not (keepduplicates and isinstance(node, nodes.File))
             rep, duplicate = self._collect_one_node(node, handle_dupes)
+
+            if self.config.getini("collect_imported_tests"):
+                for subnode in rep.result:
+                    if isinstance(subnode, Class) and isinstance(
+                        subnode.parent, Module
+                    ):
+                        if inspect.isclass(subnode._getobj()):
+                            class_defined_at = subnode._getobj().__module__
+                            in_module = subnode.parent._getobj().__name__
+                            if class_defined_at != in_module:
+                                rep.result.remove(subnode)
+
             if duplicate and not keepduplicates:
                 return
             if rep.passed:

src/_pytest/python.py

@@ -741,12 +741,6 @@ def newinstance(self):
         return self.obj()
 
     def collect(self) -> Iterable[nodes.Item | nodes.Collector]:
-        if self.config.getini("discover_imports") == ("false" or False):
-            paths = self.config.getini("testpaths")
-            class_file = inspect.getfile(self.obj)
-            if not any(string in class_file for string in paths):
-                return []
-
         if not safe_getattr(self.obj, "__test__", True):
             return []
         if hasinit(self.obj):

testing/test_discover_imports.py

@@ -1,29 +1,31 @@
-import pytest
+from __future__ import annotations
+
 import textwrap
 
-def test_discover_imports_enabled(pytester):
+from _pytest.pytester import Pytester
+
+
+def run_import_class_test(pytester: Pytester, passed: int = 0, errors: int = 0) -> None:
     src_dir = pytester.mkdir("src")
     tests_dir = pytester.mkdir("tests")
-    pytester.makeini("""
-        [pytest]
-        testpaths = "tests"
-        discover_imports = true
-    """)
-
     src_file = src_dir / "foo.py"
 
-    src_file.write_text(textwrap.dedent("""\
-    class TestClass(object):
+    src_file.write_text(
+        textwrap.dedent("""\
+    class Testament(object):
         def __init__(self):
             super().__init__()
+            self.collections = ["stamp", "coin"]
 
-        def test_foobar(self):
-            return true
-    """
-    ), encoding="utf-8")
+        def personal_property(self):
+            return [f"my {x} collection" for x in self.collections]
+    """),
+        encoding="utf-8",
+    )
 
     test_file = tests_dir / "foo_test.py"
-    test_file.write_text(textwrap.dedent("""\
+    test_file.write_text(
+        textwrap.dedent("""\
     import sys
     import os
 
@@ -32,42 +34,78 @@ def test_foobar(self):
     parent_dir = os.path.abspath(os.path.join(current_dir, '..'))
     sys.path.append(parent_dir)
 
-    from src.foo import TestClass
+    from src.foo import Testament
 
     class TestDomain:
         def test_testament(self):
-            testament = TestClass()
-            pass
-    """), encoding="utf-8")
+            testament = Testament()
+            assert testament.personal_property()
+    """),
+        encoding="utf-8",
+    )
 
     result = pytester.runpytest()
-    result.assert_outcomes(errors=1)
+    result.assert_outcomes(passed=passed, errors=errors)
 
-def test_discover_imports_disabled(pytester):
-    
-    src_dir = pytester.mkdir("src")
-    tests_dir = pytester.mkdir("tests")
+
+def test_collect_imports_disabled(pytester: Pytester) -> None:
+    pytester.makeini("""
+        [pytest]
+        testpaths = "tests"
+        collect_imported_tests = false
+    """)
+
+    run_import_class_test(pytester, errors=1)
+
+
+def test_collect_imports_default(pytester: Pytester) -> None:
+    pytester.makeini("""
+        [pytest]
+        testpaths = "tests"
+    """)
+
+    run_import_class_test(pytester, errors=1)
+
+
+def test_collect_imports_enabled(pytester: Pytester) -> None:
     pytester.makeini("""
         [pytest]
         testpaths = "tests"
-        discover_imports = false
+        collect_imported_tests = true
     """)
 
+    run_import_class_test(pytester, passed=1)
+
+
+def run_import_functions_test(
+    pytester: Pytester, passed: int, errors: int, failed: int
+) -> None:
+    src_dir = pytester.mkdir("src")
+    tests_dir = pytester.mkdir("tests")
+
     src_file = src_dir / "foo.py"
 
-    src_file.write_text(textwrap.dedent("""\
-    class Testament(object):
-        def __init__(self):
-            super().__init__()
-            self.collections = ["stamp", "coin"]
+    # Note that these "tests" are should _not_ be treated as tests.
+    # They are normal functions that happens to have test_* or *_test in the name.
+    # Thus should _not_ be collected!
+    src_file.write_text(
+        textwrap.dedent("""\
+        def test_function():
+            some_random_computation = 5
+            return some_random_computation
 
-        def personal_property(self):
-            return [f"my {x} collection" for x in self.collections]
-    """
-    ), encoding="utf-8")
+        def test_bar():
+            pass
+    """),
+        encoding="utf-8",
+    )
 
     test_file = tests_dir / "foo_test.py"
-    test_file.write_text(textwrap.dedent("""\
+
+    # Inferred from the comment above, this means that there is _only_ one actual test
+    # which should result in only 1 passing test being ran.
+    test_file.write_text(
+        textwrap.dedent("""\
     import sys
     import os
 
@@ -76,13 +114,37 @@ def personal_property(self):
     parent_dir = os.path.abspath(os.path.join(current_dir, '..'))
     sys.path.append(parent_dir)
 
-    from src.foo import Testament
+    from src.foo import *
 
     class TestDomain:
-        def test_testament(self):
-            testament = Testament()
-            assert testament.personal_property()
-    """), encoding="utf-8")
+        def test_important(self):
+            res = test_function()
+            if res == 5:
+                pass
+
+    """),
+        encoding="utf-8",
+    )
 
     result = pytester.runpytest()
-    result.assert_outcomes(passed=1)
+    result.assert_outcomes(passed=passed, errors=errors, failed=failed)
+
+
+def test_collect_function_imports_enabled(pytester: Pytester) -> None:
+    pytester.makeini("""
+        [pytest]
+        testpaths = "tests"
+        collect_imported_tests = true
+    """)
+
+    run_import_functions_test(pytester, passed=1, errors=0, failed=0)
+
+
+def test_collect_function_imports_disabled(pytester: Pytester) -> None:
+    pytester.makeini("""
+        [pytest]
+        testpaths = "tests"
+        collect_imported_tests = false
+    """)
+
+    run_import_functions_test(pytester, passed=2, errors=0, failed=1)