Improve the default handler when raise_error_for_unhandled_request is…

… true (#885)

slack_bolt/app/app.py

@@ -511,15 +511,18 @@ def middleware_next():
                         # This should not be an intentional handling in usual use cases.
                         resp = BoltResponse(status=404, body={"error": "no next() calls in middleware"})
                         if self._raise_error_for_unhandled_request is True:
-                            self._listener_runner.listener_error_handler.handle(
-                                error=BoltUnhandledRequestError(
+                            try:
+                                raise BoltUnhandledRequestError(
                                     request=req,
                                     current_response=resp,
                                     last_global_middleware_name=middleware.name,
-                                ),
-                                request=req,
-                                response=resp,
-                            )
+                                )
+                            except BoltUnhandledRequestError as e:
+                                self._listener_runner.listener_error_handler.handle(
+                                    error=e,
+                                    request=req,
+                                    response=resp,
+                                )
                             return resp
                         self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                         return resp
@@ -562,14 +565,17 @@ def middleware_next():
             if resp is None:
                 resp = BoltResponse(status=404, body={"error": "unhandled request"})
             if self._raise_error_for_unhandled_request is True:
-                self._listener_runner.listener_error_handler.handle(
-                    error=BoltUnhandledRequestError(
+                try:
+                    raise BoltUnhandledRequestError(
                         request=req,
                         current_response=resp,
-                    ),
-                    request=req,
-                    response=resp,
-                )
+                    )
+                except BoltUnhandledRequestError as e:
+                    self._listener_runner.listener_error_handler.handle(
+                        error=e,
+                        request=req,
+                        response=resp,
+                    )
                 return resp
             return self._handle_unmatched_requests(req, resp)
         except Exception as error:

slack_bolt/app/async_app.py

@@ -535,15 +535,18 @@ async def async_middleware_next():
                         # This should not be an intentional handling in usual use cases.
                         resp = BoltResponse(status=404, body={"error": "no next() calls in middleware"})
                         if self._raise_error_for_unhandled_request is True:
-                            await self._async_listener_runner.listener_error_handler.handle(
-                                error=BoltUnhandledRequestError(
+                            try:
+                                raise BoltUnhandledRequestError(
                                     request=req,
                                     current_response=resp,
                                     last_global_middleware_name=middleware.name,
-                                ),
-                                request=req,
-                                response=resp,
-                            )
+                                )
+                            except BoltUnhandledRequestError as e:
+                                await self._async_listener_runner.listener_error_handler.handle(
+                                    error=e,
+                                    request=req,
+                                    response=resp,
+                                )
                             return resp
                         self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                         return resp
@@ -589,14 +592,17 @@ async def async_middleware_next():
             if resp is None:
                 resp = BoltResponse(status=404, body={"error": "unhandled request"})
             if self._raise_error_for_unhandled_request is True:
-                await self._async_listener_runner.listener_error_handler.handle(
-                    error=BoltUnhandledRequestError(
+                try:
+                    raise BoltUnhandledRequestError(
                         request=req,
                         current_response=resp,
-                    ),
-                    request=req,
-                    response=resp,
-                )
+                    )
+                except BoltUnhandledRequestError as e:
+                    await self._async_listener_runner.listener_error_handler.handle(
+                        error=e,
+                        request=req,
+                        response=resp,
+                    )
                 return resp
             return self._handle_unmatched_requests(req, resp)
 

slack_bolt/error/__init__.py

@@ -23,3 +23,6 @@ def __init__(  # type: ignore
         self.body = request.body if request is not None else {}
         self.current_response = current_response
         self.last_global_middleware_name = last_global_middleware_name
+
+    def __str__(self) -> str:
+        return "unhandled request error"

tests/slack_bolt/error/test_errors.py

@@ -0,0 +1,19 @@
+from slack_bolt import BoltRequest
+from slack_bolt.error import BoltUnhandledRequestError
+
+
+class TestErrors:
+    def setup_method(self):
+        pass
+
+    def teardown_method(self):
+        pass
+
+    def test_say(self):
+        request = BoltRequest(body="foo=bar")
+        exception = BoltUnhandledRequestError(
+            request=request,
+            current_response={},
+            last_global_middleware_name="last_middleware",
+        )
+        assert str(exception) == "unhandled request error"