| | import pytest |
| | from werkzeug.exceptions import Forbidden |
| | from werkzeug.exceptions import HTTPException |
| | from werkzeug.exceptions import InternalServerError |
| | from werkzeug.exceptions import NotFound |
| |
|
| | import flask |
| |
|
| |
|
| | def test_error_handler_no_match(app, client): |
| | class CustomException(Exception): |
| | pass |
| |
|
| | class UnacceptableCustomException(BaseException): |
| | pass |
| |
|
| | @app.errorhandler(CustomException) |
| | def custom_exception_handler(e): |
| | assert isinstance(e, CustomException) |
| | return "custom" |
| |
|
| | with pytest.raises( |
| | AssertionError, match="Custom exceptions must be subclasses of Exception." |
| | ): |
| | app.register_error_handler(UnacceptableCustomException, None) |
| |
|
| | @app.errorhandler(500) |
| | def handle_500(e): |
| | assert isinstance(e, InternalServerError) |
| | original = getattr(e, "original_exception", None) |
| |
|
| | if original is not None: |
| | return f"wrapped {type(original).__name__}" |
| |
|
| | return "direct" |
| |
|
| | @app.route("/custom") |
| | def custom_test(): |
| | raise CustomException() |
| |
|
| | @app.route("/keyerror") |
| | def key_error(): |
| | raise KeyError() |
| |
|
| | @app.route("/abort") |
| | def do_abort(): |
| | flask.abort(500) |
| |
|
| | app.testing = False |
| | assert client.get("/custom").data == b"custom" |
| | assert client.get("/keyerror").data == b"wrapped KeyError" |
| | assert client.get("/abort").data == b"direct" |
| |
|
| |
|
| | def test_error_handler_subclass(app): |
| | class ParentException(Exception): |
| | pass |
| |
|
| | class ChildExceptionUnregistered(ParentException): |
| | pass |
| |
|
| | class ChildExceptionRegistered(ParentException): |
| | pass |
| |
|
| | @app.errorhandler(ParentException) |
| | def parent_exception_handler(e): |
| | assert isinstance(e, ParentException) |
| | return "parent" |
| |
|
| | @app.errorhandler(ChildExceptionRegistered) |
| | def child_exception_handler(e): |
| | assert isinstance(e, ChildExceptionRegistered) |
| | return "child-registered" |
| |
|
| | @app.route("/parent") |
| | def parent_test(): |
| | raise ParentException() |
| |
|
| | @app.route("/child-unregistered") |
| | def unregistered_test(): |
| | raise ChildExceptionUnregistered() |
| |
|
| | @app.route("/child-registered") |
| | def registered_test(): |
| | raise ChildExceptionRegistered() |
| |
|
| | c = app.test_client() |
| |
|
| | assert c.get("/parent").data == b"parent" |
| | assert c.get("/child-unregistered").data == b"parent" |
| | assert c.get("/child-registered").data == b"child-registered" |
| |
|
| |
|
| | def test_error_handler_http_subclass(app): |
| | class ForbiddenSubclassRegistered(Forbidden): |
| | pass |
| |
|
| | class ForbiddenSubclassUnregistered(Forbidden): |
| | pass |
| |
|
| | @app.errorhandler(403) |
| | def code_exception_handler(e): |
| | assert isinstance(e, Forbidden) |
| | return "forbidden" |
| |
|
| | @app.errorhandler(ForbiddenSubclassRegistered) |
| | def subclass_exception_handler(e): |
| | assert isinstance(e, ForbiddenSubclassRegistered) |
| | return "forbidden-registered" |
| |
|
| | @app.route("/forbidden") |
| | def forbidden_test(): |
| | raise Forbidden() |
| |
|
| | @app.route("/forbidden-registered") |
| | def registered_test(): |
| | raise ForbiddenSubclassRegistered() |
| |
|
| | @app.route("/forbidden-unregistered") |
| | def unregistered_test(): |
| | raise ForbiddenSubclassUnregistered() |
| |
|
| | c = app.test_client() |
| |
|
| | assert c.get("/forbidden").data == b"forbidden" |
| | assert c.get("/forbidden-unregistered").data == b"forbidden" |
| | assert c.get("/forbidden-registered").data == b"forbidden-registered" |
| |
|
| |
|
| | def test_error_handler_blueprint(app): |
| | bp = flask.Blueprint("bp", __name__) |
| |
|
| | @bp.errorhandler(500) |
| | def bp_exception_handler(e): |
| | return "bp-error" |
| |
|
| | @bp.route("/error") |
| | def bp_test(): |
| | raise InternalServerError() |
| |
|
| | @app.errorhandler(500) |
| | def app_exception_handler(e): |
| | return "app-error" |
| |
|
| | @app.route("/error") |
| | def app_test(): |
| | raise InternalServerError() |
| |
|
| | app.register_blueprint(bp, url_prefix="/bp") |
| |
|
| | c = app.test_client() |
| |
|
| | assert c.get("/error").data == b"app-error" |
| | assert c.get("/bp/error").data == b"bp-error" |
| |
|
| |
|
| | def test_default_error_handler(): |
| | bp = flask.Blueprint("bp", __name__) |
| |
|
| | @bp.errorhandler(HTTPException) |
| | def bp_exception_handler(e): |
| | assert isinstance(e, HTTPException) |
| | assert isinstance(e, NotFound) |
| | return "bp-default" |
| |
|
| | @bp.errorhandler(Forbidden) |
| | def bp_forbidden_handler(e): |
| | assert isinstance(e, Forbidden) |
| | return "bp-forbidden" |
| |
|
| | @bp.route("/undefined") |
| | def bp_registered_test(): |
| | raise NotFound() |
| |
|
| | @bp.route("/forbidden") |
| | def bp_forbidden_test(): |
| | raise Forbidden() |
| |
|
| | app = flask.Flask(__name__) |
| |
|
| | @app.errorhandler(HTTPException) |
| | def catchall_exception_handler(e): |
| | assert isinstance(e, HTTPException) |
| | assert isinstance(e, NotFound) |
| | return "default" |
| |
|
| | @app.errorhandler(Forbidden) |
| | def catchall_forbidden_handler(e): |
| | assert isinstance(e, Forbidden) |
| | return "forbidden" |
| |
|
| | @app.route("/forbidden") |
| | def forbidden(): |
| | raise Forbidden() |
| |
|
| | @app.route("/slash/") |
| | def slash(): |
| | return "slash" |
| |
|
| | app.register_blueprint(bp, url_prefix="/bp") |
| |
|
| | c = app.test_client() |
| | assert c.get("/bp/undefined").data == b"bp-default" |
| | assert c.get("/bp/forbidden").data == b"bp-forbidden" |
| | assert c.get("/undefined").data == b"default" |
| | assert c.get("/forbidden").data == b"forbidden" |
| | |
| | assert c.get("/slash", follow_redirects=True).data == b"slash" |
| |
|
| |
|
| | class TestGenericHandlers: |
| | """Test how very generic handlers are dispatched to.""" |
| |
|
| | class Custom(Exception): |
| | pass |
| |
|
| | @pytest.fixture() |
| | def app(self, app): |
| | @app.route("/custom") |
| | def do_custom(): |
| | raise self.Custom() |
| |
|
| | @app.route("/error") |
| | def do_error(): |
| | raise KeyError() |
| |
|
| | @app.route("/abort") |
| | def do_abort(): |
| | flask.abort(500) |
| |
|
| | @app.route("/raise") |
| | def do_raise(): |
| | raise InternalServerError() |
| |
|
| | app.config["PROPAGATE_EXCEPTIONS"] = False |
| | return app |
| |
|
| | def report_error(self, e): |
| | original = getattr(e, "original_exception", None) |
| |
|
| | if original is not None: |
| | return f"wrapped {type(original).__name__}" |
| |
|
| | return f"direct {type(e).__name__}" |
| |
|
| | @pytest.mark.parametrize("to_handle", (InternalServerError, 500)) |
| | def test_handle_class_or_code(self, app, client, to_handle): |
| | """``InternalServerError`` and ``500`` are aliases, they should |
| | have the same behavior. Both should only receive |
| | ``InternalServerError``, which might wrap another error. |
| | """ |
| |
|
| | @app.errorhandler(to_handle) |
| | def handle_500(e): |
| | assert isinstance(e, InternalServerError) |
| | return self.report_error(e) |
| |
|
| | assert client.get("/custom").data == b"wrapped Custom" |
| | assert client.get("/error").data == b"wrapped KeyError" |
| | assert client.get("/abort").data == b"direct InternalServerError" |
| | assert client.get("/raise").data == b"direct InternalServerError" |
| |
|
| | def test_handle_generic_http(self, app, client): |
| | """``HTTPException`` should only receive ``HTTPException`` |
| | subclasses. It will receive ``404`` routing exceptions. |
| | """ |
| |
|
| | @app.errorhandler(HTTPException) |
| | def handle_http(e): |
| | assert isinstance(e, HTTPException) |
| | return str(e.code) |
| |
|
| | assert client.get("/error").data == b"500" |
| | assert client.get("/abort").data == b"500" |
| | assert client.get("/not-found").data == b"404" |
| |
|
| | def test_handle_generic(self, app, client): |
| | """Generic ``Exception`` will handle all exceptions directly, |
| | including ``HTTPExceptions``. |
| | """ |
| |
|
| | @app.errorhandler(Exception) |
| | def handle_exception(e): |
| | return self.report_error(e) |
| |
|
| | assert client.get("/custom").data == b"direct Custom" |
| | assert client.get("/error").data == b"direct KeyError" |
| | assert client.get("/abort").data == b"direct InternalServerError" |
| | assert client.get("/not-found").data == b"direct NotFound" |
| |
|
