Add decorator support for assert_on_exception

The @responses.activate decorator now accepts an assert_on_exception
parameter, providing a convenient way to enable assertion checking
even when exceptions occur:

    @responses.activate(
        assert_all_requests_are_fired=True,
        assert_on_exception=True
    )
    def test_my_api():
        ...

This is consistent with the existing decorator support for
assert_all_requests_are_fired and registry parameters.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: RJPercival

responses/__init__.py

@@ -179,6 +179,7 @@ def get_wrapped(
     *,
     registry: Optional[Any] = None,
     assert_all_requests_are_fired: Optional[bool] = None,
+    assert_on_exception: Optional[bool] = None,
 ) -> Callable[..., Any]:
     """Wrap provided function inside ``responses`` context manager.
 
@@ -195,6 +196,8 @@ def get_wrapped(
         Custom registry that should be applied. See ``responses.registries``
     assert_all_requests_are_fired : bool
         Raise an error if not all registered responses were executed.
+    assert_on_exception : bool
+        Raise assertion errors even when an exception occurs in the context manager.
 
     Returns
     -------
@@ -208,14 +211,20 @@ def get_wrapped(
         new=assert_all_requests_are_fired,
     )
 
+    assert_on_exception_mock = std_mock.patch.object(
+        target=responses,
+        attribute="assert_on_exception",
+        new=assert_on_exception,
+    )
+
     if inspect.iscoroutinefunction(func):
         # set asynchronous wrapper if requestor function is asynchronous
         @wraps(func)
         async def wrapper(*args: Any, **kwargs: Any) -> Any:  # type: ignore[misc]
             if registry is not None:
                 responses._set_registry(registry)
 
-            with assert_mock, responses:
+            with assert_mock, assert_on_exception_mock, responses:
                 return await func(*args, **kwargs)
 
     else:
@@ -225,8 +234,8 @@ def wrapper(*args: Any, **kwargs: Any) -> Any:  # type: ignore[misc]
             if registry is not None:
                 responses._set_registry(registry)
 
-            with assert_mock, responses:
-                # set 'assert_all_requests_are_fired' temporarily for a single run.
+            with assert_mock, assert_on_exception_mock, responses:
+                # set 'assert_all_requests_are_fired' and 'assert_on_exception' temporarily for a single run.
                 # Mock automatically unsets to avoid leakage to another decorated
                 # function since we still apply the value on 'responses.mock' object
                 return func(*args, **kwargs)
@@ -1009,9 +1018,9 @@ def activate(
         *,
         registry: Type[Any] = ...,
         assert_all_requests_are_fired: bool = ...,
+        assert_on_exception: bool = ...,
     ) -> Callable[["_F"], "_F"]:
-        """Overload for scenario when
-        'responses.activate(registry=, assert_all_requests_are_fired=True)' is used.
+        """Overload for scenario when 'responses.activate(...)' is used.
         See https://github.com/getsentry/responses/pull/469 for more details
         """
 
@@ -1021,6 +1030,7 @@ def activate(
         *,
         registry: Optional[Type[Any]] = None,
         assert_all_requests_are_fired: bool = False,
+        assert_on_exception: bool = False,
     ) -> Union[Callable[["_F"], "_F"], "_F"]:
         if func is not None:
             return get_wrapped(func, self)
@@ -1031,6 +1041,7 @@ def deco_activate(function: "_F") -> Callable[..., Any]:
                 self,
                 registry=registry,
                 assert_all_requests_are_fired=assert_all_requests_are_fired,
+                assert_on_exception=assert_on_exception,
             )
 
         return deco_activate

responses/tests/test_responses.py

@@ -1268,6 +1268,48 @@ def run():
     assert_reset()
 
 
+def test_assert_on_exception_with_decorator():
+    """Test that assert_on_exception works with the @responses.activate decorator."""
+
+    # Default behavior with decorator: assertion should NOT be raised when an exception occurs
+    with pytest.raises(ValueError) as value_exc_info:
+
+        @responses.activate(assert_all_requests_are_fired=True)
+        def test_default():
+            responses.add(responses.GET, "http://example.com", body=b"test")
+            responses.add(responses.GET, "http://not-called.com", body=b"test")
+            requests.get("http://example.com")
+            raise ValueError("Main error")
+
+        test_default()
+
+    # Should only see the ValueError, not the AssertionError about unfired requests
+    assert "Main error" in str(value_exc_info.value)
+    assert "not-called.com" not in str(value_exc_info.value)
+
+    # With assert_on_exception=True in decorator: assertion WILL be raised even with an exception
+    with pytest.raises(AssertionError) as assert_exc_info:
+
+        @responses.activate(
+            assert_all_requests_are_fired=True, assert_on_exception=True
+        )
+        def test_with_assert_on_exception():
+            responses.add(responses.GET, "http://example.com", body=b"test")
+            responses.add(responses.GET, "http://not-called.com", body=b"test")
+            requests.get("http://example.com")
+            raise ValueError("Main error")
+
+        test_with_assert_on_exception()
+
+    # The AssertionError should mention the unfired request
+    assert "not-called.com" in str(assert_exc_info.value)
+    # Python automatically chains exceptions, so we should see both in the traceback
+    assert isinstance(assert_exc_info.value.__context__, ValueError)
+    assert "Main error" in str(assert_exc_info.value.__context__)
+
+    assert_reset()
+
+
 def test_allow_redirects_samehost():
     redirecting_url = "http://example.com"
     final_url_path = "/1"