test: Replace synthetic cycle test with realistic Starlette reproduction

Replace test_cyclic_exception_group_context with test_exceptiongroup_starlette_collapse
that simulates the actual collapse_excgroups() pattern from Starlette. This provides
a more realistic regression test for the cycle detection in exceptions_from_error()
by reproducing the exact __context__ cycle that occurs in production with FastAPI
and multiple BaseHTTPMiddleware instances.

Remove the now-redundant synthetic __context__ cycle test since the new test
covers the same code path with a more representative scenario.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ericapisani

tests/test_exceptiongroup.py

@@ -309,36 +309,58 @@ def test_simple_exception():
 
 
 @minimum_python_311
-def test_cyclic_exception_group_cause():
+def test_exceptiongroup_starlette_collapse():
     """
-    Regression test for https://github.com/getsentry/sentry-python/issues/5025
+    Simulates the Starlette collapse_excgroups() pattern where a single-exception
+    ExceptionGroup is caught and the inner exception is unwrapped and re-raised.
 
-    When using FastAPI with multiple BaseHTTPMiddleware instances, anyio wraps
-    exceptions in ExceptionGroups.
+    See: https://github.com/Kludex/starlette/blob/0e88e92b592bfa11fd92e331869a8d49ba34b541/starlette/_utils.py#L79-L87
 
-    When a single exception is unpacked from the ExceptionGroup by Starlette and reraised in the `collapse_excgroups()` method
-    (see https://github.com/Kludex/starlette/blob/0e88e92b592bfa11fd92e331869a8d49ba34b541/starlette/_utils.py#L79-L87)
-    it causes the following situation to happen:
+    When using FastAPI with multiple BaseHTTPMiddleware instances, anyio wraps
+    exceptions in ExceptionGroups. Starlette's collapse_excgroups() then unwraps
+    single-exception groups and re-raises the inner exception.
 
-        ExceptionGroup -> .exceptions[0] -> ValueError -> __cause__ -> ExceptionGroup
+    When re-raising the unwrapped exception, Python implicitly sets __context__
+    on it pointing back to the ExceptionGroup (because the re-raise happens
+    inside the except block that caught the ExceptionGroup), creating a cycle:
 
-    when the Sentry SDK attempts to walk through the chain of exceptions via the exceptions_from_error().
+        ExceptionGroup -> .exceptions[0] -> ValueError -> __context__ -> ExceptionGroup
 
-    This is because `exceptions_from_error` walks both __cause__/__context__ and
-    ExceptionGroup.exceptions recursively without cycle detection, causing
-    infinite recursion and a silent RecursionError that drops the event.
+    Without cycle detection in exceptions_from_error(), this causes infinite
+    recursion and a silent RecursionError that drops the event.
     """
-    # Construct the exact cyclic structure that anyio/Starlette creates when
-    # an exception propagates through multiple BaseHTTPMiddleware layers.
-    original = ValueError("original error")
-    group = ExceptionGroup("unhandled errors in a TaskGroup", [original])
-    original.__cause__ = group
-    original.__suppress_context__ = True
+    exception_group = None
+
+    try:
+        try:
+            raise RuntimeError("something")
+        except RuntimeError:
+            raise ExceptionGroup(
+                "nested",
+                [
+                    ValueError(654),
+                ],
+            )
+    except ExceptionGroup as exc:
+        exception_group = exc
+
+        # Simulate Starlette's collapse_excgroups() as seen here:
+        # https://github.com/Kludex/starlette/blob/0e88e92b592bfa11fd92e331869a8d49ba34b541/starlette/_utils.py#L79-L87
+        #
+        # When an ExceptionGroup contains a single exception, collapse_excgroups
+        # unwraps it and re-raises the inner exception. This causes Python to
+        # implicitly set unwrapped.__context__ = ExceptionGroup (because the
+        # re-raise happens inside the except block handling the ExceptionGroup),
+        # creating a cycle:
+        #   exception_group -> .exceptions[0] -> ValueError -> __context__ -> exception_group
+        unwrapped = exc.exceptions[0]
+        try:
+            raise unwrapped
+        except Exception:
+            pass
 
-    # When the ExceptionGroup is the top-level exception, exceptions_from_error
-    # is called directly (not walk_exception_chain which has cycle detection).
     (event, _) = event_from_exception(
-        group,
+        exception_group,
         client_options={
             "include_local_variables": True,
             "include_source_context": True,
@@ -347,30 +369,68 @@ def test_cyclic_exception_group_cause():
         mechanism={"type": "test_suite", "handled": False},
     )
 
-    exception_values = event["exception"]["values"]
+    values = event["exception"]["values"]
 
-    # Must produce a finite list of exceptions without hitting RecursionError.
-    assert len(exception_values) >= 1
-    exc_types = [v["type"] for v in exception_values]
-    assert "ExceptionGroup" in exc_types
-    assert "ValueError" in exc_types
+    # For this test the stacktrace and the module is not important
+    for x in values:
+        if "stacktrace" in x:
+            del x["stacktrace"]
+        if "module" in x:
+            del x["module"]
+
+    expected_values = [
+        {
+            "mechanism": {
+                "exception_id": 2,
+                "handled": False,
+                "parent_id": 0,
+                "source": "exceptions[0]",
+                "type": "chained",
+            },
+            "type": "ValueError",
+            "value": "654",
+        },
+        {
+            "mechanism": {
+                "exception_id": 1,
+                "handled": False,
+                "parent_id": 0,
+                "source": "__context__",
+                "type": "chained",
+            },
+            "type": "RuntimeError",
+            "value": "something",
+        },
+        {
+            "mechanism": {
+                "exception_id": 0,
+                "handled": False,
+                "is_exception_group": True,
+                "type": "test_suite",
+            },
+            "type": "ExceptionGroup",
+            "value": "nested",
+        },
+    ]
+
+    assert values == expected_values
 
 
 @minimum_python_311
-def test_cyclic_exception_group_context():
+def test_cyclic_exception_group_cause():
     """
-    Same as test_cyclic_exception_group_cause (see above) but the cycle goes through
-    __context__ instead of __cause__ .
-
-    This is the more likely scenario to occur in production because __context__ is set implicitly by
-    Python while __cause__ is set explicitly when "raise X from Y" is written in the code
+    Test case related to `test_exceptiongroup_starlette_collapse` above. We want to make sure that
+    the same cyclic loop cannot happen via the __cause__ as well as the __context__
     """
+    # Construct the exact cyclic structure that anyio/Starlette creates when
+    # an exception propagates through multiple BaseHTTPMiddleware layers.
     original = ValueError("original error")
     group = ExceptionGroup("unhandled errors in a TaskGroup", [original])
-    original.__context__ = group
-    # __suppress_context__ = False so that exceptions_from_error follows __context__
-    original.__suppress_context__ = False
+    original.__cause__ = group
+    original.__suppress_context__ = True
 
+    # When the ExceptionGroup is the top-level exception, exceptions_from_error
+    # is called directly (not walk_exception_chain which has cycle detection).
     (event, _) = event_from_exception(
         group,
         client_options={
@@ -382,6 +442,8 @@ def test_cyclic_exception_group_context():
     )
 
     exception_values = event["exception"]["values"]
+
+    # Must produce a finite list of exceptions without hitting RecursionError.
     assert len(exception_values) >= 1
     exc_types = [v["type"] for v in exception_values]
     assert "ExceptionGroup" in exc_types
@@ -391,7 +453,9 @@ def test_cyclic_exception_group_context():
 @minimum_python_311
 def test_deeply_nested_cyclic_exception_group():
     """
-    A more complex cycle: ExceptionGroup -> ValueError -> __cause__ ->
+    Related to the `test_exceptiongroup_starlette_collapse` test above.
+
+    Testing a more complex cycle: ExceptionGroup -> ValueError -> __cause__ ->
     ExceptionGroup (nested) -> TypeError -> __cause__ -> original ExceptionGroup
     """
     inner_error = TypeError("inner")