make pytest.raises use RaisesExc... which made me notice about a million small things differing between raises and RaisesExc, and some random other stuff...

Author: jakkdl

src/_pytest/_code/code.py

@@ -763,7 +763,7 @@ def match(self, regexp: str | re.Pattern[str]) -> Literal[True]:
         """
         __tracebackhide__ = True
         value = self._stringify_exception(self.value)
-        msg = f"Regex pattern did not match.\n Regex: {regexp!r}\n Input: {value!r}"
+        msg = f"Raised exception did not match: Regex pattern did not match.\n Regex: {regexp!r}\n Input: {value!r}"
         if regexp == value:
             msg += "\n Did you mean to `re.escape()` the regex?"
         assert re.search(regexp, value), msg

src/_pytest/python_api.py

@@ -6,30 +6,25 @@
 from collections.abc import Mapping
 from collections.abc import Sequence
 from collections.abc import Sized
-from contextlib import AbstractContextManager
 from decimal import Decimal
 import math
 from numbers import Complex
 import pprint
 import re
 import sys
-from types import TracebackType
 from typing import Any
-from typing import cast
-from typing import final
-from typing import get_args
-from typing import get_origin
 from typing import overload
 from typing import TYPE_CHECKING
 from typing import TypeVar
 
 import _pytest._code
 from _pytest.outcomes import fail
+from _pytest.raises_group import BaseExcT_co_default
+from _pytest.raises_group import RaisesExc
 
 
 if sys.version_info < (3, 11):
-    from exceptiongroup import BaseExceptionGroup
-    from exceptiongroup import ExceptionGroup
+    pass
 
 if TYPE_CHECKING:
     from numpy import ndarray
@@ -791,15 +786,29 @@ def _as_numpy_array(obj: object) -> ndarray | None:
 
 # builtin pytest.raises helper
 
-E = TypeVar("E", bound=BaseException)
+E = TypeVar("E", bound=BaseException, default=BaseException)
 
 
 @overload
 def raises(
     expected_exception: type[E] | tuple[type[E], ...],
     *,
     match: str | re.Pattern[str] | None = ...,
-) -> RaisesContext[E]: ...
+    check: Callable[[BaseExcT_co_default], bool] = ...,
+) -> RaisesExc[E]: ...
+
+
+@overload
+def raises(
+    *,
+    match: str | re.Pattern[str],
+    # If exception_type is not provided, check() must do any typechecks itself.
+    check: Callable[[BaseException], bool] = ...,
+) -> RaisesExc[BaseException]: ...
+
+
+@overload
+def raises(*, check: Callable[[BaseException], bool]) -> RaisesExc[BaseException]: ...
 
 
 @overload
@@ -812,8 +821,10 @@ def raises(
 
 
 def raises(
-    expected_exception: type[E] | tuple[type[E], ...], *args: Any, **kwargs: Any
-) -> RaisesContext[E] | _pytest._code.ExceptionInfo[E]:
+    expected_exception: type[E] | tuple[type[E], ...] | None = None,
+    *args: Any,
+    **kwargs: Any,
+) -> RaisesExc[BaseException] | _pytest._code.ExceptionInfo[E]:
     r"""Assert that a code block/function call raises an exception type, or one of its subclasses.
 
     :param expected_exception:
@@ -960,117 +971,38 @@ def raises(
     """
     __tracebackhide__ = True
 
+    if not args:
+        if set(kwargs) - {"match", "check", "expected_exception"}:
+            msg = "Unexpected keyword arguments passed to pytest.raises: "
+            msg += ", ".join(sorted(kwargs))
+            msg += "\nUse context-manager form instead?"
+            raise TypeError(msg)
+
+        if expected_exception is None:
+            return RaisesExc(**kwargs)
+        return RaisesExc(expected_exception, **kwargs)
+
     if not expected_exception:
         raise ValueError(
             f"Expected an exception type or a tuple of exception types, but got `{expected_exception!r}`. "
             f"Raising exceptions is already understood as failing the test, so you don't need "
             f"any special code to say 'this should never raise an exception'."
         )
-
-    expected_exceptions: tuple[type[E], ...]
-    origin_exc: type[E] | None = get_origin(expected_exception)
-    if isinstance(expected_exception, type):
-        expected_exceptions = (expected_exception,)
-    elif origin_exc and issubclass(origin_exc, BaseExceptionGroup):
-        expected_exceptions = (cast(type[E], expected_exception),)
-    else:
-        expected_exceptions = expected_exception
-
-    def validate_exc(exc: type[E]) -> type[E]:
-        __tracebackhide__ = True
-        origin_exc: type[E] | None = get_origin(exc)
-        if origin_exc and issubclass(origin_exc, BaseExceptionGroup):
-            exc_type = get_args(exc)[0]
-            if (
-                issubclass(origin_exc, ExceptionGroup) and exc_type in (Exception, Any)
-            ) or (
-                issubclass(origin_exc, BaseExceptionGroup)
-                and exc_type in (BaseException, Any)
-            ):
-                return cast(type[E], origin_exc)
-            else:
-                raise ValueError(
-                    f"Only `ExceptionGroup[Exception]` or `BaseExceptionGroup[BaseExeption]` "
-                    f"are accepted as generic types but got `{exc}`. "
-                    f"As `raises` will catch all instances of the specified group regardless of the "
-                    f"generic argument specific nested exceptions has to be checked "
-                    f"with `ExceptionInfo.group_contains()`"
-                )
-
-        elif not isinstance(exc, type) or not issubclass(exc, BaseException):
-            msg = "expected exception must be a BaseException type, not {}"  # type: ignore[unreachable]
-            not_a = exc.__name__ if isinstance(exc, type) else type(exc).__name__
-            raise TypeError(msg.format(not_a))
-        else:
-            return exc
-
-    expected_exceptions = tuple(validate_exc(exc) for exc in expected_exceptions)
-
-    message = f"DID NOT RAISE {expected_exception}"
-
-    if not args:
-        match: str | re.Pattern[str] | None = kwargs.pop("match", None)
-        if kwargs:
-            msg = "Unexpected keyword arguments passed to pytest.raises: "
-            msg += ", ".join(sorted(kwargs))
-            msg += "\nUse context-manager form instead?"
-            raise TypeError(msg)
-        return RaisesContext(expected_exceptions, message, match)
-    else:
-        func = args[0]
-        if not callable(func):
-            raise TypeError(f"{func!r} object (type: {type(func)}) must be callable")
-        try:
-            func(*args[1:], **kwargs)
-        except expected_exceptions as e:
-            return _pytest._code.ExceptionInfo.from_exception(e)
-    fail(message)
-
-
-# This doesn't work with mypy for now. Use fail.Exception instead.
-raises.Exception = fail.Exception  # type: ignore
-
-
-@final
-class RaisesContext(AbstractContextManager[_pytest._code.ExceptionInfo[E]]):
-    def __init__(
-        self,
-        expected_exception: type[E] | tuple[type[E], ...],
-        message: str,
-        match_expr: str | re.Pattern[str] | None = None,
-    ) -> None:
-        self.expected_exception = expected_exception
-        self.message = message
-        self.match_expr = match_expr
-        self.excinfo: _pytest._code.ExceptionInfo[E] | None = None
-        if self.match_expr is not None:
-            re_error = None
-            try:
-                re.compile(self.match_expr)
-            except re.error as e:
-                re_error = e
-            if re_error is not None:
-                fail(f"Invalid regex pattern provided to 'match': {re_error}")
-
-    def __enter__(self) -> _pytest._code.ExceptionInfo[E]:
-        self.excinfo = _pytest._code.ExceptionInfo.for_later()
-        return self.excinfo
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> bool:
-        __tracebackhide__ = True
-        if exc_type is None:
-            fail(self.message)
-        assert self.excinfo is not None
-        if not issubclass(exc_type, self.expected_exception):
-            return False
-        # Cast to narrow the exception type now that it's verified.
-        exc_info = cast(tuple[type[E], E, TracebackType], (exc_type, exc_val, exc_tb))
-        self.excinfo.fill_unfilled(exc_info)
-        if self.match_expr is not None:
-            self.excinfo.match(self.match_expr)
-        return True
+    func = args[0]
+    if not callable(func):
+        raise TypeError(f"{func!r} object (type: {type(func)}) must be callable")
+    with RaisesExc(expected_exception) as excinfo:
+        func(*args[1:], **kwargs)
+    try:
+        return excinfo
+    finally:
+        del excinfo
+
+
+# note: RaisesExc/RaisesGroup uses fail() internally, so this alias
+# indicates (to [internal] plugins?) that `pytest.raises` will
+# raise `_pytest.outcomes.Failed`, where
+# `outcomes.Failed is outcomes.fail.Exception is raises.Exception`
+# note: this is *not* the same as `_pytest.main.Failed`
+# note: mypy does not recognize this attribute
+raises.Exception = fail.Exception  # type: ignore[attr-defined]