Decorators: Now using error handlers only if registered for validate_params

Author: Seluj78

flask_utils/__init__.py

@@ -1,5 +1,5 @@
 # Increment versions here according to SemVer
-__version__ = "0.6.1"
+__version__ = "0.7.0"
 
 from flask_utils.utils import is_it_true
 from flask_utils.errors import GoneError

flask_utils/decorators.py

@@ -8,15 +8,15 @@
 from typing import get_origin
 from functools import wraps
 
+from flask import jsonify
 from flask import request
+from flask import current_app
+from flask import make_response
 from werkzeug.exceptions import BadRequest
 from werkzeug.exceptions import UnsupportedMediaType
 
 from flask_utils.errors import BadRequestError
 
-# TODO: Change validate_params to either use BadRequestError or just return a 400 depending
-#  on if the error handler is registered or not in the FlaskUtils class
-
 VALIDATE_PARAMS_MAX_DEPTH = 4
 
 
@@ -236,41 +236,125 @@ def example():
             * Optional
             * Union
 
+    .. versionchanged:: 0.7.0
+        The decorator will now use the custom error handlers if ``register_error_handlers`` has been set to ``True``
+        when initializing the :class:`~flask_utils.extension.FlaskUtils` extension.
+
     .. versionadded:: 0.2.0
     """
 
     def decorator(fn):  # type: ignore
         @wraps(fn)
         def wrapper(*args, **kwargs):  # type: ignore
+            use_error_handlers = False
+            if current_app.extensions.get("flask_utils") is not None:
+                if current_app.extensions["flask_utils"].has_error_handlers_registered:
+                    use_error_handlers = True
+
             try:
                 data = request.get_json()
             except BadRequest as e:
-                raise BadRequestError("The Json Body is malformed.") from e
+                if use_error_handlers:
+                    raise BadRequestError("The Json Body is malformed.") from e
+                else:
+                    return make_response(
+                        jsonify(
+                            {
+                                "error": "The Json Body is malformed.",
+                            }
+                        ),
+                        400,
+                    )
             except UnsupportedMediaType as e:
-                raise BadRequestError(
-                    "The Content-Type header is missing or is not set to application/json, or the JSON body is missing."
-                ) from e
+                if use_error_handlers:
+                    raise BadRequestError(
+                        "The Content-Type header is missing or is not set to application/json, "
+                        "or the JSON body is missing."
+                    ) from e
+                else:
+                    return make_response(
+                        jsonify(
+                            {
+                                "error": "The Content-Type header is missing or is not set to application/json, "
+                                "or the JSON body is missing.",
+                            }
+                        ),
+                        400,
+                    )
 
             if not data:
-                raise BadRequestError("Missing json body.")
+                if use_error_handlers:
+                    raise BadRequestError("Missing json body.")
+                else:
+                    return make_response(
+                        jsonify(
+                            {
+                                "error": "Missing json body.",
+                            }
+                        ),
+                        400,
+                    )
 
             if not isinstance(data, dict):
-                raise BadRequestError("JSON body must be a dict")
+                if use_error_handlers:
+                    raise BadRequestError("JSON body must be a dict")
+                else:
+                    return make_response(
+                        jsonify(
+                            {
+                                "error": "JSON body must be a dict",
+                            }
+                        ),
+                        400,
+                    )
 
             for key, type_hint in parameters.items():
                 if not _is_optional(type_hint) and key not in data:
-                    raise BadRequestError(f"Missing key: {key}", f"Expected keys are: {parameters.keys()}")
+                    if use_error_handlers:
+                        raise BadRequestError(f"Missing key: {key}", f"Expected keys are: {parameters.keys()}")
+                    else:
+                        return make_response(
+                            jsonify(
+                                {
+                                    "error": f"Missing key: {key}",
+                                    "expected_keys": parameters.keys(),
+                                }
+                            ),
+                            400,
+                        )
 
             for key in data:
                 if key not in parameters:
-                    raise BadRequestError(
-                        f"Unexpected key: {key}.",
-                        f"Expected keys are: {parameters.keys()}",
-                    )
+                    if use_error_handlers:
+                        raise BadRequestError(
+                            f"Unexpected key: {key}.",
+                            f"Expected keys are: {parameters.keys()}",
+                        )
+                    else:
+                        return make_response(
+                            jsonify(
+                                {
+                                    "error": f"Unexpected key: {key}.",
+                                    "expected_keys": parameters.keys(),
+                                }
+                            ),
+                            400,
+                        )
 
             for key in data:
                 if key in parameters and not _check_type(data[key], parameters[key], allow_empty):
-                    raise BadRequestError(f"Wrong type for key {key}.", f"It should be {parameters[key]}")
+                    if use_error_handlers:
+                        raise BadRequestError(f"Wrong type for key {key}.", f"It should be {parameters[key]}")
+                    else:
+                        return make_response(
+                            jsonify(
+                                {
+                                    "error": f"Wrong type for key {key}.",
+                                    "expected_type": parameters[key],
+                                }
+                            ),
+                            400,
+                        )
 
             return fn(*args, **kwargs)
 

flask_utils/errors/__init__.py

@@ -24,7 +24,7 @@ def _register_error_handlers(application: Flask) -> None:
 
     .. versionchanged:: 0.5.0
         Made the function private. If you want to register the custom error handlers, you need to
-            pass `register_error_handlers=True` to the :class:`~flask_utils.extension.FlaskUtils` class
+            pass ``register_error_handlers=True`` to the :class:`~flask_utils.extension.FlaskUtils` class
             or to :meth:`~flask_utils.extension.FlaskUtils.init_app`
 
         .. code-block:: python

flask_utils/extension.py

@@ -34,21 +34,30 @@ class FlaskUtils(object):
     """
 
     def __init__(self, app: Optional[Flask] = None, register_error_handlers: bool = True):
+        self.has_error_handlers_registered = False
+
         if app is not None:
             self.init_app(app, register_error_handlers)
 
     def init_app(self, app: Flask, register_error_handlers: bool = True) -> None:
-        """Initialize a Flask application for use with this extension instance. This
+        """
+        :param app: The Flask application to initialize.
+        :param register_error_handlers: Register the custom error handlers. Default is ``True``.
+
+        Initialize a Flask application for use with this extension instance. This
         must be called before any request is handled by the application.
 
         If the app is created with the factory pattern, this should be called after the app
         is created to configure the extension.
 
-        If `register_error_handlers` is True, the custom error handlers will be registered and
-        can then be used in routes to raise errors.
+        If ``register_error_handlers`` is ``True``, the custom error handlers will be registered and
+        can then be used in routes to raise errors. This is enabled by default.
+        The decorator :func:`~flask_utils.decorators.validate_params` will also use the custom error handlers
+        if set to ``True``.
 
-        :param app: The Flask application to initialize.
-        :param register_error_handlers: Register the custom error handlers. Default is True.
+        .. versionchanged:: 0.7.0
+            Setting ``register_error_handlers`` to True will now enable using the custom error handlers
+            in the :func:`~flask_utils.decorators.validate_params`. decorator.
 
         :Example:
 
@@ -65,5 +74,6 @@ def init_app(self, app: Flask, register_error_handlers: bool = True) -> None:
         """
         if register_error_handlers:
             _register_error_handlers(app)
+            self.has_error_handlers_registered = True
 
         app.extensions["flask_utils"] = self

pyproject.toml

@@ -45,6 +45,8 @@ dev-dependencies = [
     "pre-commit>=3.5.0",
     "mypy>=1.11.2",
     "twine>=5.1.1",
+    "sphinx>=7.1.2",
+    "pallets-sphinx-themes>=2.1.3",
 ]
 
 

tests/test_validate_params_with_error_handlers.py

@@ -0,0 +1,26 @@
+from flask import Flask
+
+from flask_utils import validate_params
+
+
+def test_validate_params_without_error_handlers():
+    app = Flask(__name__)
+    app.testing = True
+
+    @app.route("/example")
+    @validate_params({"name": str})
+    def example():
+        return "OK", 200
+
+    response = app.test_client().get("/example")
+    assert response.status_code == 400
+    assert (
+        response.json["error"]
+        == "The Content-Type header is missing or is not set to application/json, or the JSON body is missing."
+    )
+    assert "success" not in response.json
+    assert "code" not in response.json
+    assert not isinstance(response.json["error"], dict)
+
+
+# TODO: Test all possible errors that can be raised by validate_params