Cleanup internal hacks

Author: nicoddemus

src/_pytest/reports.py

@@ -251,7 +251,6 @@ def _report_unserialization_failure(
     raise RuntimeError(stream.getvalue())
 
 
-@final
 class TestReport(BaseReport):
     """Basic test report object (also used for setup and teardown calls if
     they fail).

src/_pytest/subtests.py

@@ -9,11 +9,9 @@
 from contextlib import ExitStack
 from contextlib import nullcontext
 import dataclasses
-import sys
 import time
 from typing import Any
 from typing import TYPE_CHECKING
-from unittest import TestCase
 
 import pluggy
 
@@ -31,8 +29,6 @@
 from _pytest.reports import TestReport
 from _pytest.runner import CallInfo
 from _pytest.runner import check_interactive_exception
-from _pytest.unittest import TestCaseFunction
-from _pytest.warning_types import PytestDeprecationWarning
 
 
 if TYPE_CHECKING:
@@ -60,12 +56,14 @@ def pytest_addoption(parser: Parser) -> None:
 
 @dataclasses.dataclass
 class SubTestContext:
+    """The values passed to SubTests.test() that are included in the test report."""
+
     msg: str | None
     kwargs: dict[str, Any]
 
 
 @dataclasses.dataclass(init=False)
-class SubTestReport(TestReport):  # type: ignore[misc]
+class SubTestReport(TestReport):
     context: SubTestContext
 
     @property
@@ -105,122 +103,6 @@ def _from_test_report(cls, test_report: TestReport) -> SubTestReport:
         return super()._from_json(test_report._to_json())
 
 
-def _addSkip(self: TestCaseFunction, testcase: TestCase, reason: str) -> None:
-    from unittest.case import _SubTest  # type: ignore[attr-defined]
-
-    if isinstance(testcase, _SubTest):
-        self._originaladdSkip(testcase, reason)  # type: ignore[attr-defined]
-        if self._excinfo is not None:
-            exc_info = self._excinfo[-1]
-            self.addSubTest(testcase.test_case, testcase, exc_info)  # type: ignore[attr-defined]
-    else:
-        # For python < 3.11: the non-subtest skips have to be added by `_originaladdSkip` only after all subtest
-        # failures are processed by `_addSubTest`. (`self.instance._outcome` has no attribute `skipped/errors` anymore.)
-        # For python < 3.11, we also need to check if `self.instance._outcome` is `None` (this happens if the test
-        # class/method is decorated with `unittest.skip`, see #173).
-        if sys.version_info < (3, 11) and self.instance._outcome is not None:
-            subtest_errors = [
-                x
-                for x, y in self.instance._outcome.errors
-                if isinstance(x, _SubTest) and y is not None
-            ]
-            if len(subtest_errors) == 0:
-                self._originaladdSkip(testcase, reason)  # type: ignore[attr-defined]
-        else:
-            self._originaladdSkip(testcase, reason)  # type: ignore[attr-defined]
-
-
-def _addSubTest(
-    self: TestCaseFunction,
-    test_case: Any,
-    test: TestCase,
-    exc_info: tuple[type[BaseException], BaseException, TracebackType] | None,
-) -> None:
-    msg = test._message if isinstance(test._message, str) else None  # type: ignore[attr-defined]
-    call_info = make_call_info(
-        ExceptionInfo(exc_info, _ispytest=True) if exc_info else None,
-        start=0,
-        stop=0,
-        duration=0,
-        when="call",
-    )
-    report = self.ihook.pytest_runtest_makereport(item=self, call=call_info)
-    sub_report = SubTestReport._from_test_report(report)
-    sub_report.context = SubTestContext(msg, dict(test.params))  # type: ignore[attr-defined]
-    self.ihook.pytest_runtest_logreport(report=sub_report)
-    if check_interactive_exception(call_info, sub_report):
-        self.ihook.pytest_exception_interact(
-            node=self, call=call_info, report=sub_report
-        )
-
-    # For python < 3.11: add non-subtest skips once all subtest failures are processed by # `_addSubTest`.
-    if sys.version_info < (3, 11):
-        from unittest.case import _SubTest  # type: ignore[attr-defined]
-
-        non_subtest_skip = [
-            (x, y)
-            for x, y in self.instance._outcome.skipped
-            if not isinstance(x, _SubTest)
-        ]
-        subtest_errors = [
-            (x, y)
-            for x, y in self.instance._outcome.errors
-            if isinstance(x, _SubTest) and y is not None
-        ]
-        # Check if we have non-subtest skips: if there are also sub failures, non-subtest skips are not treated in
-        # `_addSubTest` and have to be added using `_originaladdSkip` after all subtest failures are processed.
-        if len(non_subtest_skip) > 0 and len(subtest_errors) > 0:
-            # Make sure we have processed the last subtest failure
-            last_subset_error = subtest_errors[-1]
-            if exc_info is last_subset_error[-1]:
-                # Add non-subtest skips (as they could not be treated in `_addSkip`)
-                for testcase, reason in non_subtest_skip:
-                    self._originaladdSkip(testcase, reason)  # type: ignore[attr-defined]
-
-
-def pytest_configure(config: Config) -> None:
-    TestCaseFunction.addSubTest = _addSubTest  # type: ignore[attr-defined]
-    TestCaseFunction.failfast = False  # type: ignore[attr-defined]
-    # This condition is to prevent `TestCaseFunction._originaladdSkip` being assigned again in a subprocess from a
-    # parent python process where `addSkip` is already `_addSkip`. A such case is when running tests in
-    # `test_subtests.py` where `pytester.runpytest` is used. Without this guard condition, `_originaladdSkip` is
-    # assigned to `_addSkip` which is wrong as well as causing an infinite recursion in some cases.
-    if not hasattr(TestCaseFunction, "_originaladdSkip"):
-        TestCaseFunction._originaladdSkip = TestCaseFunction.addSkip  # type: ignore[attr-defined]
-    TestCaseFunction.addSkip = _addSkip  # type: ignore[method-assign]
-
-    # Hack (#86): the terminal does not know about the "subtests"
-    # status, so it will by default turn the output to yellow.
-    # This forcibly adds the new 'subtests' status.
-    import _pytest.terminal
-
-    new_types = tuple(
-        f"subtests {outcome}" for outcome in ("passed", "failed", "skipped")
-    )
-    # We need to check if we are not re-adding because we run our own tests
-    # with pytester in-process mode, so this will be called multiple times.
-    if new_types[0] not in _pytest.terminal.KNOWN_TYPES:
-        _pytest.terminal.KNOWN_TYPES = _pytest.terminal.KNOWN_TYPES + new_types  # type: ignore[assignment]
-
-    _pytest.terminal._color_for_type.update(
-        {
-            f"subtests {outcome}": _pytest.terminal._color_for_type[outcome]
-            for outcome in ("passed", "failed", "skipped")
-            if outcome in _pytest.terminal._color_for_type
-        }
-    )
-
-
-def pytest_unconfigure() -> None:
-    if hasattr(TestCaseFunction, "addSubTest"):
-        del TestCaseFunction.addSubTest
-    if hasattr(TestCaseFunction, "failfast"):
-        del TestCaseFunction.failfast
-    if hasattr(TestCaseFunction, "_originaladdSkip"):
-        TestCaseFunction.addSkip = TestCaseFunction._originaladdSkip  # type: ignore[method-assign]
-        del TestCaseFunction._originaladdSkip
-
-
 @fixture
 def subtests(request: SubRequest) -> Generator[SubTests, None, None]:
     """Provides subtests functionality."""
@@ -293,7 +175,7 @@ class _SubTestContextManager:
 
     Note: initially this logic was implemented directly in SubTests.test() as a @contextmanager, however
     it is not possible to control the output fully when exiting from it due to an exception when
-    in --exitfirst mode, so this was refactored into an explicit context manager class (#134).
+    in --exitfirst mode, so this was refactored into an explicit context manager class (pytest-dev/pytest-subtests#134).
     """
 
     ihook: pluggy.HookRelay
@@ -390,11 +272,9 @@ def capturing_output(request: SubRequest) -> Iterator[Captured]:
     capture_fixture_active = getattr(capman, "_capture_fixture", None)
 
     if option == "sys" and not capture_fixture_active:
-        with ignore_pytest_private_warning():
-            fixture = CaptureFixture(SysCapture, request)
+        fixture = CaptureFixture(SysCapture, request, _ispytest=True)
     elif option == "fd" and not capture_fixture_active:
-        with ignore_pytest_private_warning():
-            fixture = CaptureFixture(FDCapture, request)
+        fixture = CaptureFixture(FDCapture, request, _ispytest=True)
     else:
         fixture = None
 
@@ -428,20 +308,7 @@ def capturing_logs(
             yield captured_logs
 
 
-@contextmanager
-def ignore_pytest_private_warning() -> Generator[None, None, None]:
-    import warnings
-
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            "A private pytest class or function was used.",
-            category=PytestDeprecationWarning,
-        )
-        yield
-
-
-@dataclasses.dataclass()
+@dataclasses.dataclass
 class Captured:
     out: str = ""
     err: str = ""
@@ -453,12 +320,12 @@ def update_report(self, report: TestReport) -> None:
             report.sections.append(("Captured stderr call", self.err))
 
 
+@dataclasses.dataclass
 class CapturedLogs:
-    def __init__(self, handler: LogCaptureHandler) -> None:
-        self._handler = handler
+    handler: LogCaptureHandler
 
     def update_report(self, report: TestReport) -> None:
-        report.sections.append(("Captured log call", self._handler.stream.getvalue()))
+        report.sections.append(("Captured log call", self.handler.stream.getvalue()))
 
 
 class NullCapturedLogs:

src/_pytest/terminal.py

@@ -69,6 +69,9 @@
     "xpassed",
     "warnings",
     "error",
+    "subtests passed",
+    "subtests failed",
+    "subtests skipped",
 )
 
 _REPORTCHARS_DEFAULT = "fE"
@@ -1559,6 +1562,8 @@ def _folded_skips(
     "error": "red",
     "warnings": "yellow",
     "passed": "green",
+    "subtests passed": "green",
+    "subtests failed": "red",
 }
 _color_for_type_default = "yellow"
 

src/_pytest/unittest.py

@@ -13,9 +13,13 @@
 import sys
 import traceback
 import types
+from typing import Any
 from typing import TYPE_CHECKING
+from unittest import TestCase
 
 import _pytest._code
+from _pytest._code import ExceptionInfo
+from _pytest.compat import assert_never
 from _pytest.compat import is_async_function
 from _pytest.config import hookimpl
 from _pytest.fixtures import FixtureRequest
@@ -30,12 +34,17 @@
 from _pytest.python import Function
 from _pytest.python import Module
 from _pytest.runner import CallInfo
+from _pytest.runner import check_interactive_exception
+from _pytest.subtests import make_call_info
+from _pytest.subtests import SubTestContext
+from _pytest.subtests import SubTestReport
 
 
 if sys.version_info[:2] < (3, 11):
     from exceptiongroup import ExceptionGroup
 
 if TYPE_CHECKING:
+    from types import TracebackType
     import unittest
 
     import twisted.trial.unittest
@@ -200,6 +209,7 @@ def unittest_setup_method_fixture(
 
 class TestCaseFunction(Function):
     nofuncargs = True
+    failfast = False
     _excinfo: list[_pytest._code.ExceptionInfo[BaseException]] | None = None
 
     def _getinstance(self):
@@ -278,10 +288,35 @@ def addFailure(
         self._addexcinfo(rawexcinfo)
 
     def addSkip(self, testcase: unittest.TestCase, reason: str) -> None:
-        try:
-            raise skip.Exception(reason, _use_item_location=True)
-        except skip.Exception:
-            self._addexcinfo(sys.exc_info())
+        from unittest.case import _SubTest  # type: ignore[attr-defined]
+
+        def add_skip() -> None:
+            try:
+                raise skip.Exception(reason, _use_item_location=True)
+            except skip.Exception:
+                self._addexcinfo(sys.exc_info())
+
+        if isinstance(testcase, _SubTest):
+            add_skip()
+            if self._excinfo is not None:
+                exc_info = self._excinfo[-1]
+                self.addSubTest(testcase.test_case, testcase, exc_info)
+        else:
+            # For python < 3.11: the non-subtest skips have to be added by `_originaladdSkip` only after all subtest
+            # failures are processed by `_addSubTest`: `self.instance._outcome` has no attribute
+            # `skipped/errors` anymore.
+            # We also need to check if `self.instance._outcome` is `None` (this happens if the test
+            # class/method is decorated with `unittest.skip`, see pytest-dev/pytest-subtests#173).
+            if sys.version_info < (3, 11) and self.instance._outcome is not None:
+                subtest_errors = [
+                    x
+                    for x, y in self.instance._outcome.errors
+                    if isinstance(x, _SubTest) and y is not None
+                ]
+                if len(subtest_errors) == 0:
+                    add_skip()
+            else:
+                add_skip()
 
     def addExpectedFailure(
         self,
@@ -361,6 +396,64 @@ def _traceback_filter(
             ntraceback = traceback
         return ntraceback
 
+    def addSubTest(
+        self,
+        test_case: Any,
+        test: TestCase,
+        exc_info: ExceptionInfo[BaseException]
+        | tuple[type[BaseException], BaseException, TracebackType]
+        | None,
+    ) -> None:
+        exception_info: ExceptionInfo[BaseException] | None
+        match exc_info:
+            case tuple():
+                exception_info = ExceptionInfo(exc_info, _ispytest=True)
+            case ExceptionInfo() | None:
+                exception_info = exc_info
+            case unreachable:
+                assert_never(unreachable)
+
+        call_info = make_call_info(
+            exception_info,
+            start=0,
+            stop=0,
+            duration=0,
+            when="call",
+        )
+        msg = test._message if isinstance(test._message, str) else None  # type: ignore[attr-defined]
+        report = self.ihook.pytest_runtest_makereport(item=self, call=call_info)
+        sub_report = SubTestReport._from_test_report(report)
+        sub_report.context = SubTestContext(msg, dict(test.params))  # type: ignore[attr-defined]
+        self.ihook.pytest_runtest_logreport(report=sub_report)
+        if check_interactive_exception(call_info, sub_report):
+            self.ihook.pytest_exception_interact(
+                node=self, call=call_info, report=sub_report
+            )
+
+        # For python < 3.11: add non-subtest skips once all subtest failures are processed by # `_addSubTest`.
+        if sys.version_info < (3, 11):
+            from unittest.case import _SubTest  # type: ignore[attr-defined]
+
+            non_subtest_skip = [
+                (x, y)
+                for x, y in self.instance._outcome.skipped
+                if not isinstance(x, _SubTest)
+            ]
+            subtest_errors = [
+                (x, y)
+                for x, y in self.instance._outcome.errors
+                if isinstance(x, _SubTest) and y is not None
+            ]
+            # Check if we have non-subtest skips: if there are also sub failures, non-subtest skips are not treated in
+            # `_addSubTest` and have to be added using `_originaladdSkip` after all subtest failures are processed.
+            if len(non_subtest_skip) > 0 and len(subtest_errors) > 0:
+                # Make sure we have processed the last subtest failure
+                last_subset_error = subtest_errors[-1]
+                if exc_info is last_subset_error[-1]:
+                    # Add non-subtest skips (as they could not be treated in `_addSkip`)
+                    for testcase, reason in non_subtest_skip:
+                        self._originaladdSkip(testcase, reason)  # type: ignore[attr-defined]
+
 
 @hookimpl(tryfirst=True)
 def pytest_runtest_makereport(item: Item, call: CallInfo[None]) -> None: