fix #13537: Add support for ExceptionGroup with only Skipped exceptions in teardown

Author: gomri15

changelog/13537.bugfix.rst

@@ -0,0 +1 @@
+Fix bug in which ExceptionGroup with only Skipped exceptions in teardown was not handled correctly and showed as error.

src/_pytest/compat.py

@@ -12,13 +12,18 @@
 import os
 from pathlib import Path
 import sys
+import types
+from types import TracebackType
 from typing import Any
 from typing import Final
 from typing import NoReturn
 
 import py
 
 
+if sys.version_info < (3, 11):
+    from exceptiongroup import BaseExceptionGroup
+
 if sys.version_info >= (3, 14):
     from annotationlib import Format
 
@@ -311,3 +316,74 @@ def running_on_ci() -> bool:
     # Only enable CI mode if one of these env variables is defined and non-empty.
     env_vars = ["CI", "BUILD_NUMBER"]
     return any(os.environ.get(var) for var in env_vars)
+
+
+# https://peps.python.org/pep-0785/
+# Copied Implementation of PEP 785 for flattening BaseExceptionGroups.
+# Commented-out code is disabled for now as it is unused.
+def leaf_exceptions(
+    exception_group: BaseExceptionGroup,
+    # *,
+    # fix_traceback: bool = True
+) -> list[BaseException]:
+    """
+    Return a flat list of all 'leaf' exceptions.
+
+    If fix_tracebacks is True, each leaf will have the traceback replaced
+    with a composite so that frames attached to intermediate groups are
+    still visible when debugging. Pass fix_tracebacks=False to disable
+    this modification, e.g. if you expect to raise the group unchanged.
+    """
+
+    def _flatten(
+        group: BaseExceptionGroup,
+        # fix_tracebacks: bool,
+        parent_tb: TracebackType | None = None,
+    ) -> list[BaseException]:
+        group_tb = group.__traceback__
+        combined_tb = _combine_tracebacks(parent_tb, group_tb)
+        result = []
+        for exc in group.exceptions:
+            if isinstance(exc, BaseExceptionGroup):
+                result.extend(_flatten(exc, combined_tb))
+            # elif fix_tracebacks:
+            #     tb = _combine_tracebacks(combined_tb, exc.__traceback__)
+            #     result.append(exc.with_traceback(tb))
+            else:
+                result.append(exc)
+        return result
+
+    return _flatten(exception_group)
+
+
+def _combine_tracebacks(
+    tb1: TracebackType | None,
+    tb2: TracebackType | None,
+) -> TracebackType | None:
+    """
+    Combine two tracebacks, putting tb1 frames before tb2 frames.
+
+    If either is None, return the other.
+    """
+    if tb1 is None:
+        return tb2
+    if tb2 is None:
+        return tb1
+
+    # Convert tb1 to a list of frames.
+    frames = []
+    current: TracebackType | None = tb1
+    while current is not None:
+        frames.append((current.tb_frame, current.tb_lasti, current.tb_lineno))
+        current = current.tb_next
+
+    # Create a new traceback starting with tb2.
+    new_tb = tb2
+
+    # Add frames from tb1 to the beginning (in reverse order).
+    for frame, lasti, lineno in reversed(frames):
+        new_tb = types.TracebackType(
+            tb_next=new_tb, tb_frame=frame, tb_lasti=lasti, tb_lineno=lineno
+        )
+
+    return new_tb

src/_pytest/reports.py

@@ -9,6 +9,7 @@
 from io import StringIO
 import os
 from pprint import pprint
+import sys
 from typing import Any
 from typing import cast
 from typing import final
@@ -28,13 +29,18 @@
 from _pytest._code.code import ReprTraceback
 from _pytest._code.code import TerminalRepr
 from _pytest._io import TerminalWriter
+from _pytest.compat import leaf_exceptions
 from _pytest.config import Config
 from _pytest.nodes import Collector
 from _pytest.nodes import Item
 from _pytest.outcomes import fail
 from _pytest.outcomes import skip
 
 
+if sys.version_info < (3, 11):
+    from exceptiongroup import BaseExceptionGroup
+
+
 if TYPE_CHECKING:
     from typing_extensions import Self
 
@@ -251,6 +257,53 @@ def _report_unserialization_failure(
     raise RuntimeError(stream.getvalue())
 
 
+def _format_failed_longrepr(
+    item: Item, call: CallInfo[None], excinfo: ExceptionInfo[BaseException]
+):
+    if call.when == "call":
+        longrepr = item.repr_failure(excinfo)
+    else:
+        # Exception in setup or teardown.
+        longrepr = item._repr_failure_py(
+            excinfo, style=item.config.getoption("tbstyle", "auto")
+        )
+    return longrepr
+
+
+def _format_exception_group_all_skipped_longrepr(
+    item: Item,
+    excinfo: ExceptionInfo[BaseExceptionGroup[BaseException | BaseExceptionGroup]],
+) -> tuple[str, int, str]:
+    r = excinfo._getreprcrash()
+    assert r is not None, (
+        "There should always be a traceback entry for skipping a test."
+    )
+    if all(
+        getattr(skip, "_use_item_location", False) for skip in excinfo.value.exceptions
+    ):
+        path, line = item.reportinfo()[:2]
+        assert line is not None
+        loc = (os.fspath(path), line + 1)
+        default_msg = "skipped"
+    else:
+        loc = (str(r.path), r.lineno)
+        default_msg = r.message
+
+    # Get all unique skip messages.
+    msgs: list[str] = []
+    flatten_exceptions = leaf_exceptions(excinfo.value)
+    for exception in flatten_exceptions:
+        m = getattr(exception, "msg", None) or (
+            exception.args[0] if exception.args else None
+        )
+        if m and m not in msgs:
+            msgs.append(m)
+
+    reason = "; ".join(msgs) if msgs else default_msg
+    longrepr = (*loc, reason)
+    return longrepr
+
+
 @final
 class TestReport(BaseReport):
     """Basic test report object (also used for setup and teardown calls if
@@ -368,17 +421,24 @@ def from_item_and_call(cls, item: Item, call: CallInfo[None]) -> TestReport:
                 if excinfo.value._use_item_location:
                     path, line = item.reportinfo()[:2]
                     assert line is not None
-                    longrepr = os.fspath(path), line + 1, r.message
+                    longrepr = (os.fspath(path), line + 1, r.message)
                 else:
                     longrepr = (str(r.path), r.lineno, r.message)
+            elif isinstance(excinfo.value, BaseExceptionGroup) and (
+                excinfo.value.split(skip.Exception)[1] is None
+            ):
+                # All exceptions in the group are skip exceptions.
+                outcome = "skipped"
+                excinfo = cast(
+                    ExceptionInfo[
+                        BaseExceptionGroup[BaseException | BaseExceptionGroup]
+                    ],
+                    excinfo,
+                )
+                longrepr = _format_exception_group_all_skipped_longrepr(item, excinfo)
             else:
                 outcome = "failed"
-                if call.when == "call":
-                    longrepr = item.repr_failure(excinfo)
-                else:  # exception in setup or teardown
-                    longrepr = item._repr_failure_py(
-                        excinfo, style=item.config.getoption("tbstyle", "auto")
-                    )
+                longrepr = _format_failed_longrepr(item, call, excinfo)
         for rwhen, key, content in item._report_sections:
             sections.append((f"Captured {key} {rwhen}", content))
         return cls(

testing/test_reports.py

@@ -434,6 +434,118 @@ def test_1(fixture_): timing.sleep(10)
             loaded_report = TestReport._from_json(data)
             assert loaded_report.stop - loaded_report.start == approx(report.duration)
 
+    @pytest.mark.parametrize(
+        "first_skip_reason, second_skip_reason, skip_reason_output",
+        [("A", "B", "(A; B)"), ("A", "A", "(A)")],
+    )
+    def test_exception_group_with_only_skips(
+        self,
+        pytester: Pytester,
+        first_skip_reason: str,
+        second_skip_reason: str,
+        skip_reason_output: str,
+    ):
+        """
+        Test that when an ExceptionGroup with only Skipped exceptions is raised in teardown,
+        it is reported as a single skipped test, not as an error.
+        This is a regression test for issue #13537.
+        """
+        pytester.makepyfile(
+            test_it=f"""
+            import pytest
+            @pytest.fixture
+            def fixA():
+                yield
+                pytest.skip(reason="{first_skip_reason}")
+            @pytest.fixture
+            def fixB():
+                yield
+                pytest.skip(reason="{second_skip_reason}")
+            def test_skip(fixA, fixB):
+                assert True
+            """
+        )
+        result = pytester.runpytest("-v")
+        result.assert_outcomes(passed=1, skipped=1)
+        out = result.stdout.str()
+        assert skip_reason_output in out
+        assert "ERROR at teardown" not in out
+
+    @pytest.mark.parametrize(
+        "use_item_location, skip_file_location",
+        [(True, "test_it.py"), (False, "runner.py")],
+    )
+    def test_exception_group_skips_use_item_location(
+        self, pytester: Pytester, use_item_location: bool, skip_file_location: str
+    ):
+        """
+        Regression for #13537:
+        If any skip inside an ExceptionGroup has _use_item_location=True,
+        the report location should point to the test item, not the fixture teardown.
+        """
+        pytester.makepyfile(
+            test_it=f"""
+            import pytest
+            @pytest.fixture
+            def fix_item1():
+                yield
+                exc = pytest.skip.Exception("A")
+                exc._use_item_location = True
+                raise exc
+            @pytest.fixture
+            def fix_item2():
+                yield
+                exc = pytest.skip.Exception("B")
+                exc._use_item_location = {use_item_location}
+                raise exc
+            def test_both(fix_item1, fix_item2):
+                assert True
+            """
+        )
+        result = pytester.runpytest("-rs")
+        result.assert_outcomes(passed=1, skipped=1)
+
+        out = result.stdout.str()
+        # Both reasons should appear
+        assert "A" and "B" in out
+        # Crucially, the skip should be attributed to the test item, not teardown
+        assert skip_file_location in out
+
+    def test_nested_exception_groups_with_skips(
+        self,
+        pytester: Pytester,
+    ):
+        """
+        Test that when nested ExceptionGroups with Skipped exceptions are raised in teardown,
+        they are reported as a single skipped test, not as an error.
+        This is a regression test for issue #13537.
+        """
+        pytester.makepyfile(
+            test_it="""
+            import pytest
+            @pytest.fixture
+            def fix_item1():
+                yield
+                exc1 = pytest.skip.Exception("A1")
+                exc2 = pytest.skip.Exception("A2")
+                exc3 = pytest.skip.Exception("B1")
+                exc4 = pytest.skip.Exception("B2")
+                eg = BaseExceptionGroup("Group B", [exc3, exc4])
+                raise BaseExceptionGroup("Group A", [exc1, exc2, eg])
+            def test_skip(fix_item1):
+                assert True
+            """
+        )
+        result = pytester.runpytest("-v")
+        result.assert_outcomes(passed=1, skipped=1)
+        out = result.stdout.str()
+        # All skip reasons should appear
+        expected_reasons = ["A1", "A2", "B1", "B2"]
+        assert all(reason in out for reason in expected_reasons)
+        assert "ERROR at teardown" not in out
+
+    # TODO: add test multiple level nested ExceptionGroups with skips
+
 
 class TestHooks:
     """Test that the hooks are working correctly for plugins"""