Document the new ExceptionInfo.group_contains() method

Author: lanzz

doc/en/getting-started.rst

@@ -97,6 +97,30 @@ Use the :ref:`raises <assertraises>` helper to assert that some code raises an e
         with pytest.raises(SystemExit):
             f()
 
+You can also use the context provided by :ref:`raises <assertraises>` to
+assert that an expected exception is part of a raised ``ExceptionGroup``:
+
+.. code-block:: python
+
+    # content of test_exceptiongroup.py
+    import pytest
+
+
+    def f():
+        raise ExceptionGroup(
+            "Group message",
+            [
+                RuntimeError(),
+            ],
+        )
+
+
+    def test_exception_in_group():
+        with pytest.raises(ExceptionGroup) as excinfo:
+            f()
+        assert excinfo.group_contains(RuntimeError)
+        assert not excinfo.group_contains(TypeError)
+
 Execute the test function with “quiet” reporting mode:
 
 .. code-block:: pytest

doc/en/how-to/assert.rst

@@ -119,6 +119,52 @@ The regexp parameter of the ``match`` method is matched with the ``re.search``
 function, so in the above example ``match='123'`` would have worked as
 well.
 
+You can also use the :func:`excinfo.group_contains() <pytest.ExceptionInfo.group_contains>`
+method to test for exceptions returned as part of an ``ExceptionGroup``:
+
+.. code-block:: python
+
+    def test_exception_in_group():
+        with pytest.raises(RuntimeError) as excinfo:
+            raise ExceptionGroup(
+                "Group message",
+                [
+                    RuntimeError("Exception 123 raised"),
+                ],
+            )
+        assert excinfo.group_contains(RuntimeError, match=r".* 123 .*")
+        assert not excinfo.group_contains(TypeError)
+
+The optional ``match`` keyword parameter works the same way as for
+:func:`pytest.raises`.
+
+By default ``group_contains()`` will recursively search for a matching
+exception at any level of nested ``ExceptionGroup`` instances. You can
+specify a ``depth`` keyword parameter if you only want to match an
+exception at a specific level; exceptions contained directly in the top
+``ExceptionGroup`` would match ``depth=1``.
+
+.. code-block:: python
+
+    def test_exception_in_group_at_given_depth():
+        with pytest.raises(RuntimeError) as excinfo:
+            raise ExceptionGroup(
+                "Group message",
+                [
+                    RuntimeError(),
+                    ExceptionGroup(
+                        "Nested group",
+                        [
+                            TypeError(),
+                        ],
+                    ),
+                ],
+            )
+        assert excinfo.group_contains(RuntimeError, depth=1)
+        assert excinfo.group_contains(TypeError, depth=2)
+        assert not excinfo.group_contains(RuntimeError, depth=2)
+        assert not excinfo.group_contains(TypeError, depth=1)
+
 There's an alternate form of the :func:`pytest.raises` function where you pass
 a function that will be executed with the given ``*args`` and ``**kwargs`` and
 assert that the given exception is raised: