Reworked and Added tests. Fixed TornadoRouter and changed status code for response with error 422 -> 500

Author: mr-fatalyst

examples/sanic/run.py

@@ -1,4 +1,3 @@
-import uvicorn
 from app.api.routes import api_router
 from sanic import Sanic
 
@@ -18,4 +17,4 @@
 
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="127.0.0.1", port=8000)
+    app.run(host="0.0.0.0", port=8000)

fastopenapi/base_router.py

@@ -132,9 +132,8 @@ def generate_openapi(self) -> dict:
         info = {
             "title": self.title,
             "version": self.version,
+            "description": self.description,
         }
-        if self.description:
-            info["description"] = self.description
 
         schema = {
             "openapi": self.openapi_version,
@@ -183,9 +182,6 @@ def _build_parameters_and_body(
         path_params = {match.group(1) for match in re.finditer(r"{(\w+)}", route_path)}
 
         for param_name, param in sig.parameters.items():
-            if param.annotation is inspect.Parameter.empty:
-                continue
-
             if isinstance(param.annotation, type) and issubclass(
                 param.annotation, BaseModel
             ):
@@ -243,6 +239,8 @@ def _build_responses(self, meta: dict, definitions: dict, status_code: str) -> d
                 responses[status_code]["content"] = {
                     "application/json": {"schema": resp_model_schema}
                 }
+            else:
+                raise Exception("Incorrect response_model")
         return responses
 
     def _register_docs_endpoints(self):

fastopenapi/routers/falcon.py

@@ -76,7 +76,7 @@ async def _handle_request(self, endpoint, req, resp, **path_params):
         try:
             kwargs = self.resolve_endpoint_params(endpoint, all_params, body)
         except Exception as e:
-            return self._handle_error(resp, str(e))
+            return self._handle_request_error(resp, str(e))
         try:
             if inspect.iscoroutinefunction(endpoint):
                 result = await endpoint(**kwargs)
@@ -85,7 +85,7 @@ async def _handle_request(self, endpoint, req, resp, **path_params):
         except Exception as e:
             if isinstance(e, falcon.HTTPError):
                 raise
-            return self._handle_error(resp, str(e))
+            return self._handle_response_error(resp, str(e))
         resp.status = get_falcon_status(status_code)
         result = self._serialize_response(result)
         resp.media = result
@@ -99,10 +99,14 @@ async def _read_body(self, req):
             pass
         return {}
 
-    def _handle_error(self, resp, error_message: str):
+    def _handle_request_error(self, resp, error_message: str):
         resp.status = falcon.HTTP_422
         resp.media = {"detail": error_message}
 
+    def _handle_response_error(self, resp, error_message: str):
+        resp.status = falcon.HTTP_500
+        resp.media = {"detail": error_message}
+
     def _register_docs_endpoints(self):
         outer = self
 

fastopenapi/routers/flask.py

@@ -36,7 +36,7 @@ def view_func(**path_params):
                 except Exception as e:
                     if isinstance(e, HTTPException):
                         return self.handle_http_exception(e)
-                    return jsonify({"detail": str(e)}), 422
+                    return jsonify({"detail": str(e)}), 500
 
                 meta = getattr(endpoint, "__route_meta__", {})
                 status_code = meta.get("status_code", 200)

fastopenapi/routers/quart.py

@@ -1,4 +1,3 @@
-import inspect
 import re
 from collections.abc import Callable
 
@@ -33,14 +32,11 @@ async def view_func(**path_params):
                 except Exception as e:
                     return jsonify({"detail": str(e)}), 422
                 try:
-                    if inspect.iscoroutinefunction(endpoint):
-                        result = await endpoint(**kwargs)
-                    else:
-                        result = endpoint(**kwargs)
+                    result = await endpoint(**kwargs)
                 except Exception as e:
                     if isinstance(e, HTTPException):
                         return await self.handle_http_exception(e)
-                    return jsonify({"detail": str(e)}), 422
+                    return jsonify({"detail": str(e)}), 500
 
                 meta = getattr(endpoint, "__route_meta__", {})
                 status_code = meta.get("status_code", 200)

fastopenapi/routers/sanic.py

@@ -48,7 +48,7 @@ async def view_func(request, **path_params):
             except Exception as e:
                 if isinstance(e, HTTPException):
                     return await self.handle_exceptions(request, e)
-                return response.json({"detail": str(e)}, status=422)
+                return response.json({"detail": str(e)}, status=500)
 
             meta = getattr(endpoint, "__route_meta__", {})
             status_code = meta.get("status_code", 200)

fastopenapi/routers/starlette.py

@@ -50,7 +50,7 @@ async def _starlette_view(cls, request, router, endpoint):
         except Exception as e:
             if isinstance(e, HTTPException):
                 return await cls.handle_exceptions(request, e)
-            return JSONResponse({"detail": str(e)}, status_code=422)
+            return JSONResponse({"detail": str(e)}, status_code=500)
 
         meta = getattr(endpoint, "__route_meta__", {})
         status_code = meta.get("status_code", 200)

fastopenapi/routers/tornado.py

@@ -20,7 +20,7 @@ class TornadoDynamicHandler(RequestHandler):
     """
 
     def initialize(self, **kwargs):
-        self.endpoint = kwargs.get("endpoint")
+        self.endpoints = kwargs.get("endpoints", {})
         self.router = kwargs.get("router")
 
     async def prepare(self):
@@ -31,18 +31,23 @@ async def prepare(self):
                 self.json_body = {}
         else:
             self.json_body = {}
+        self.endpoint = self.endpoints.get(self.request.method.upper())
 
     async def handle_http_exception(self, e):
         self.set_status(e.status_code)
         await self.finish(json_encode({"detail": str(e.log_message)}))
 
     async def handle_request(self):
+        if not hasattr(self, "endpoint") or not self.endpoint:
+            self.send_error(405)
+            return
+
         query_params = {
             k: self.get_query_argument(k) for k in self.request.query_arguments
         }
 
         all_params = {**self.path_kwargs, **query_params}
-        body = self.json_body
+        body = getattr(self, "json_body", {})
         try:
             resolved_kwargs = self.router.resolve_endpoint_params(
                 self.endpoint, all_params, body
@@ -60,15 +65,18 @@ async def handle_request(self):
             if isinstance(e, HTTPError):
                 await self.handle_http_exception(e)
                 return
-            self.set_status(422)
+            self.set_status(500)
             await self.finish(json_encode({"detail": str(e)}))
             return
         meta = getattr(self.endpoint, "__route_meta__", {})
         status_code = meta.get("status_code", 200)
         result = self.router._serialize_response(result)
         self.set_status(status_code)
         self.set_header("Content-Type", "application/json")
-        await self.finish(json_encode(result))
+        if status_code == 204:
+            await self.finish()
+        else:
+            await self.finish(json_encode(result))
 
     async def get(self, *args, **kwargs):
         await self.handle_request()
@@ -89,6 +97,8 @@ async def delete(self, *args, **kwargs):
 class TornadoRouter(BaseRouter):
     def __init__(self, app: Application = None, **kwargs):
         self.routes = []
+        self._endpoint_map: dict[str, dict[str, Callable]] = {}
+        self._registered_paths: set[str] = set()
         super().__init__(app, **kwargs)
         if self.app is not None and (self.add_docs_route or self.add_openapi_route):
             self._register_docs_endpoints()
@@ -98,57 +108,57 @@ def add_route(self, path: str, method: str, endpoint: Callable):
 
         tornado_path = re.sub(r"{(\w+)}", r"(?P<\1>[^/]+)", path)
 
-        spec = url(
-            tornado_path,
-            TornadoDynamicHandler,
-            name=endpoint.__name__,
-            kwargs={"endpoint": endpoint, "router": self},
-        )
-        self.routes.append(spec)
-        if self.app is not None:
-            self.app.add_handlers(r".*", [spec])
+        if tornado_path not in self._endpoint_map:
+            self._endpoint_map[tornado_path] = {}
+        self._endpoint_map[tornado_path][method.upper()] = endpoint
+
+        if tornado_path not in self._registered_paths:
+            self._registered_paths.add(tornado_path)
+            spec = url(
+                tornado_path,
+                TornadoDynamicHandler,
+                name=f"route_{len(self._registered_paths)}",
+                kwargs={"endpoints": self._endpoint_map[tornado_path], "router": self},
+            )
+            self.routes.append(spec)
+            if self.app is not None:
+                self.app.add_handlers(r".*", [spec])
+        else:
+            for rule in self.routes:
+                if rule.matcher.regex.pattern == f"{tornado_path}$":
+                    rule.target_kwargs["endpoints"] = self._endpoint_map[tornado_path]
+                    break
 
     def _register_docs_endpoints(self):
         router = self
 
-        class OpenAPIHandler(TornadoDynamicHandler):
+        class OpenAPIHandler(RequestHandler):
             async def get(self):
                 self.set_header("Content-Type", "application/json")
-                self.write(self.router.openapi)
+                self.write(json_encode(router.openapi))
                 await self.finish()
 
-        class SwaggerUIHandler(TornadoDynamicHandler):
+        class SwaggerUIHandler(RequestHandler):
             async def get(self):
-                html = self.router.render_swagger_ui(self.router.openapi_url)
+                html = router.render_swagger_ui(router.openapi_url)
                 self.set_header("Content-Type", "text/html")
                 self.write(html)
                 await self.finish()
 
-        class RedocUIHandler(TornadoDynamicHandler):
+        class RedocUIHandler(RequestHandler):
             async def get(self):
-                html = self.router.render_redoc_ui(self.router.openapi_url)
+                html = router.render_redoc_ui(router.openapi_url)
                 self.set_header("Content-Type", "text/html")
                 self.write(html)
                 await self.finish()
 
         spec_openapi = url(
-            self.openapi_url,
-            OpenAPIHandler,
-            name="openapi-schema",
-            kwargs={"router": router},
+            self.openapi_url, OpenAPIHandler, name="openapi-schema", kwargs={}
         )
         spec_swagger = url(
-            self.docs_url,
-            SwaggerUIHandler,
-            name="swagger-ui",
-            kwargs={"router": router},
-        )
-        spec_redoc = url(
-            self.redoc_url,
-            RedocUIHandler,
-            name="redoc-ui",
-            kwargs={"router": router},
+            self.docs_url, SwaggerUIHandler, name="swagger-ui", kwargs={}
         )
+        spec_redoc = url(self.redoc_url, RedocUIHandler, name="redoc-ui", kwargs={})
         self.routes.extend([spec_openapi, spec_swagger, spec_redoc])
         if self.app is not None:
             self.app.add_handlers(r".*", [spec_openapi, spec_swagger, spec_redoc])