Add support to testing.RaisesGroup for catching unwrapped exceptions

newsfragments/xxx.feature.rst

@@ -0,0 +1 @@
+:ref:`testing.RaisesGroup` can now catch unwrapped exceptions with ``strict=False``, similar to ``except*``.

src/trio/_tests/test_testing_raisesgroup.py

@@ -100,9 +100,33 @@ def test_raises_group() -> None:
     ):
         RaisesGroup(RaisesGroup(ValueError), strict=False)
 
-    # currently not fully identical in behaviour to expect*, which would also catch an unwrapped exception
-    with pytest.raises(ValueError, match="^value error text$"):
-        with RaisesGroup(ValueError, strict=False):
+
+def test_catch_unwrapped_exceptions() -> None:
+    # Catches lone exceptions with strict=False
+    # just as expect* would
+    with RaisesGroup(ValueError, strict=False):
+        raise ValueError
+
+    with pytest.raises(ValueError, match="foo"):
+        # This not being caught is perhaps confusing for users used to pytest.raises
+        with RaisesGroup(SyntaxError, ValueError, strict=False):
+            raise ValueError("foo")
+    with pytest.raises(ExceptionGroup, match="foo"):
+        # but if we made that work, then it would be unexpected that wrapping the exception
+        # does not get caught
+        with RaisesGroup(SyntaxError, ValueError, strict=False):
+            raise ExceptionGroup("foo", (ValueError(),))
+    # and changing *that* is not really an option, as the entire point of RaisesGroup is
+    # to verify *all* exceptions specified are there and *no others*.
+    # Users are required to instead do
+    with RaisesGroup(
+        Matcher(check=lambda x: isinstance(x, (SyntaxError, ValueError))), strict=False
+    ):
+        raise ValueError("foo")
+
+    # with strict=True (default) it will not be caught
+    with pytest.raises(ValueError, match="value error text"):
+        with RaisesGroup(ValueError):
             raise ValueError("value error text")
 
 

src/trio/_tests/type_tests/raisesgroup.py

@@ -84,9 +84,9 @@ def check_filenotfound(exc: FileNotFoundError) -> bool:
     Matcher(exception_type=ValueError)
     Matcher(match="regex")
     Matcher(check=check_exc)
-    Matcher(check=check_filenotfound)  # type: ignore
     Matcher(ValueError, match="regex")
     Matcher(FileNotFoundError, check=check_filenotfound)
+    Matcher(check=check_filenotfound)  # type: ignore # not narrowed
     Matcher(match="regex", check=check_exc)
     Matcher(FileNotFoundError, match="regex", check=check_filenotfound)
 
@@ -134,3 +134,26 @@ def check_nested_raisesgroups_matches() -> None:
     # has the same problems as check_nested_raisesgroups_contextmanager
     if RaisesGroup(RaisesGroup(ValueError)).matches(exc):
         assert_type(exc, BaseExceptionGroup[RaisesGroup[ValueError]])
+
+
+def check_multiple_exceptions_1() -> None:
+    a = RaisesGroup(ValueError, ValueError)
+    b = RaisesGroup(Matcher(ValueError), Matcher(ValueError))
+    c = RaisesGroup(ValueError, Matcher(ValueError))
+
+    d: BaseExceptionGroup[ValueError]
+    d = a
+    d = b
+    d = c
+    assert d
+
+
+def check_multiple_exceptions_2() -> None:
+    # "Cannot infer argument 1 of RaisesGroup"
+    # if removing overloads from Matcher then pyright stops warning, but mypy still
+    # complains
+    RaisesGroup(Matcher(ValueError), Matcher(TypeError))  # type: ignore
+    RaisesGroup(Matcher(ValueError), TypeError)  # type: ignore
+    # so it requires explicit type
+    RaisesGroup[Exception](Matcher(ValueError), Matcher(TypeError))
+    RaisesGroup[Exception](Matcher(ValueError), TypeError)

src/trio/testing/_raises_group.py

@@ -263,8 +263,9 @@ class RaisesGroup(ContextManager[ExceptionInfo[BaseExceptionGroup[E]]], SuperCla
     This works similar to ``pytest.raises``, and a version of it will hopefully be added upstream, after which this can be deprecated and removed. See https://github.com/pytest-dev/pytest/issues/11538
 
 
-    This differs from :ref:`except* <except_star>` in that all specified exceptions must be present, *and no others*. It will similarly not catch exceptions *not* wrapped in an exceptiongroup.
-    If you don't care for the nesting level of the exceptions you can pass ``strict=False``.
+    This differs from :ref:`except* <except_star>` in that all specified exceptions must be present, *and no others*. It will by default not catch exceptions *not* wrapped in an exceptiongroup.
+    To match :ref:`except* <except_star>` you can pass ``strict=False``. This will make it ignore the nesting level, and also catch an exception not wrapped in an ExceptionGroup.
+    If you want to catch unwrapped exceptions and expect one of several different exceptions you need to use a :ref:`Matcher` object.
     It currently does not care about the order of the exceptions, so ``RaisesGroups(ValueError, TypeError)`` is equivalent to ``RaisesGroups(TypeError, ValueError)``.
 
     This class is not as polished as ``pytest.raises``, and is currently not as helpful in e.g. printing diffs when strings don't match, suggesting you use ``re.escape``, etc.
@@ -383,6 +384,15 @@ def matches(
         # maybe have a list of strings logging failed matches, that __exit__ can
         # recursively step through and print on a failing match.
         if not isinstance(exc_val, BaseExceptionGroup):
+            if not self.strict and len(self.expected_exceptions) == 1:
+                exp_exc = self.expected_exceptions[0]
+                if isinstance(exp_exc, Matcher) and exp_exc.matches(exc_val):
+                    return True
+                if isinstance(exp_exc, type) and isinstance(exc_val, exp_exc):
+                    return True
+            # Consider printing a helpful message on unwrapped exception, strict=False and
+            # `len(self.expected_exceptions) > 1`; since they might expect the exceptions
+            # to be 'or'd like with `pytest.raises`.
             return False
         if len(exc_val.exceptions) != len(self.expected_exceptions):
             return False