Add empty connexion middleware

connexion/apps/abstract.py

@@ -55,6 +55,7 @@ def __init__(self, import_name, api_cls, port=None, specification_dir='',
         self.server = server
         self.server_args = dict() if server_args is None else server_args
         self.app = self.create_app()
+        self._apply_middleware()
 
         # we get our application root path to avoid duplicating logic
         self.root_path = self.get_root_path()
@@ -78,6 +79,12 @@ def create_app(self):
         Creates the user framework application
         """
 
+    @abc.abstractmethod
+    def _apply_middleware(self):
+        """
+        Apply middleware to application
+        """
+
     @abc.abstractmethod
     def get_root_path(self):
         """
@@ -243,12 +250,3 @@ def run(self, port=None, server=None, debug=None, host=None, **options):  # prag
         :type debug: bool
         :param options: options to be forwarded to the underlying server
         """
-
-    def __call__(self, environ, start_response):  # pragma: no cover
-        """
-        Makes the class callable to be WSGI-compliant. As Flask is used to handle requests,
-        this is a passthrough-call to the Flask callable class.
-        This is an abstraction to avoid directly referencing the app attribute from outside the
-        class and protect it from unwanted modification.
-        """
-        return self.app(environ, start_response)

connexion/apps/flask_app.py

@@ -8,12 +8,14 @@
 from decimal import Decimal
 from types import FunctionType  # NOQA
 
+import a2wsgi
 import flask
 import werkzeug.exceptions
 from flask import json, signals
 
 from ..apis.flask_api import FlaskApi
 from ..exceptions import ProblemException
+from ..middleware import ConnexionMiddleware
 from ..problem import problem
 from .abstract import AbstractApp
 
@@ -28,8 +30,10 @@ def __init__(self, import_name, server='flask', extra_files=None, **kwargs):
 
         See :class:`~connexion.AbstractApp` for additional parameters.
         """
-        super().__init__(import_name, FlaskApi, server=server, **kwargs)
         self.extra_files = extra_files or []
+        self.middleware = None
+
+        super().__init__(import_name, FlaskApi, server=server, **kwargs)
 
     def create_app(self):
         app = flask.Flask(self.import_name, **self.server_args)
@@ -38,6 +42,14 @@ def create_app(self):
         app.url_map.converters['int'] = IntegerConverter
         return app
 
+    def _apply_middleware(self):
+        middlewares = [*ConnexionMiddleware.default_middlewares,
+                       a2wsgi.WSGIMiddleware]
+        self.middleware = ConnexionMiddleware(self.app.wsgi_app, middlewares=middlewares)
+
+        # Wrap with ASGI to WSGI middleware for usage with development server and test client
+        self.app.wsgi_app = a2wsgi.ASGIMiddleware(self.middleware)
+
     def get_root_path(self):
         return pathlib.Path(self.app.root_path)
 
@@ -147,6 +159,12 @@ def run(self,
         else:
             raise Exception(f'Server {self.server} not recognized')
 
+    def __call__(self, scope, receive, send):  # pragma: no cover
+        """
+        ASGI interface. Calls the middleware wrapped around the wsgi app.
+        """
+        return self.middleware(scope, receive, send)
+
 
 class FlaskJSONEncoder(json.JSONEncoder):
     def default(self, o):

connexion/middleware/__init__.py

@@ -0,0 +1 @@
+from .main import ConnexionMiddleware  # NOQA

connexion/middleware/main.py

@@ -0,0 +1,61 @@
+import pathlib
+import typing as t
+
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+
+class ConnexionMiddleware:
+
+    default_middlewares = [
+    ]
+
+    def __init__(
+            self,
+            app: ASGIApp,
+            middlewares: t.Optional[t.List[t.Type[ASGIApp]]] = None
+    ):
+        """High level Connexion middleware that manages a list o middlewares wrapped around an
+        application.
+
+        :param app: App to wrap middleware around.
+        :param middlewares: List of middlewares to wrap around app. The list should be ordered
+                            from outer to inner middleware.
+        """
+        if middlewares is None:
+            middlewares = self.default_middlewares
+        self.app, self.apps = self._apply_middlewares(app, middlewares)
+
+        self._routing_middleware = None
+
+    @staticmethod
+    def _apply_middlewares(app: ASGIApp, middlewares: t.List[t.Type[ASGIApp]]) \
+            -> t.Tuple[ASGIApp, t.Iterable[ASGIApp]]:
+        """Apply all middlewares to the provided app.
+
+        :param app: App to wrap in middlewares.
+        :param middlewares: List of middlewares to wrap around app. The list should be ordered
+                            from outer to inner middleware.
+
+        :return: App with all middlewares applied.
+        """
+        apps = []
+        for middleware in reversed(middlewares):
+            app = middleware(app)
+            apps.append(app)
+        return app, reversed(apps)
+
+    def add_api(
+            self,
+            specification: t.Union[pathlib.Path, str, dict],
+            base_path: t.Optional[str] = None,
+            arguments: t.Optional[dict] = None,
+    ) -> None:
+        """Add an API to the underlying routing middleware based on a OpenAPI spec.
+
+        :param specification: OpenAPI spec as dict or path to file.
+        :param base_path: Base path where to add this API.
+        :param arguments: Jinja arguments to replace in the spec.
+        """
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        await self.app(scope, receive, send)

setup.py

@@ -23,18 +23,19 @@ def read_version(package):
     'clickclick>=1.2,<21',
     'jsonschema>=2.5.1,<5',
     'PyYAML>=5.1,<7',
-    'requests>=2.19.1,<3',
+    'requests>=2.27,<3',
     'inflection>=0.3.1,<0.6',
-    'werkzeug>=1.0,<3',
+    'werkzeug>=2,<3',
     'importlib-metadata>=1 ; python_version<"3.8"',
     'packaging>=20',
+    'starlette>=0.15,<1',
 ]
 
 swagger_ui_require = 'swagger-ui-bundle>=0.0.2,<0.1'
 
 flask_require = [
-    'flask>=1.0.4,<3',
-    'itsdangerous>=0.24',
+    'flask>=2,<3',
+    'a2wsgi>=1.1,<2',
 ]
 
 tests_require = [

tests/api/test_errors.py

@@ -44,23 +44,23 @@ def test_errors(problem_app):
 
     get_problem = app_client.get('/v1.0/problem')  # type: flask.Response
     assert get_problem.content_type == 'application/problem+json'
-    assert get_problem.status_code == 418
+    assert get_problem.status_code == 402
     assert get_problem.headers['x-Test-Header'] == 'In Test'
     error_problem = json.loads(get_problem.data.decode('utf-8', 'replace'))
     assert error_problem['type'] == 'http://www.example.com/error'
     assert error_problem['title'] == 'Some Error'
     assert error_problem['detail'] == 'Something went wrong somewhere'
-    assert error_problem['status'] == 418
+    assert error_problem['status'] == 402
     assert error_problem['instance'] == 'instance1'
 
     get_problem2 = app_client.get('/v1.0/other_problem')  # type: flask.Response
     assert get_problem2.content_type == 'application/problem+json'
-    assert get_problem2.status_code == 418
+    assert get_problem2.status_code == 402
     error_problem2 = json.loads(get_problem2.data.decode('utf-8', 'replace'))
     assert error_problem2['type'] == 'about:blank'
     assert error_problem2['title'] == 'Some Error'
     assert error_problem2['detail'] == 'Something went wrong somewhere'
-    assert error_problem2['status'] == 418
+    assert error_problem2['status'] == 402
     assert error_problem2['instance'] == 'instance1'
 
     problematic_json = app_client.get(

tests/api/test_headers.py

@@ -6,15 +6,17 @@ def test_headers_jsonifier(simple_app):
 
     response = app_client.post('/v1.0/goodday/dan', data={})  # type: flask.Response
     assert response.status_code == 201
-    assert response.headers["Location"] == "http://localhost/my/uri"
+    # Default Werkzeug behavior was changed in 2.1 (https://github.com/pallets/werkzeug/issues/2352)
+    assert response.headers["Location"] in ["http://localhost/my/uri", "/my/uri"]
 
 
 def test_headers_produces(simple_app):
     app_client = simple_app.app.test_client()
 
     response = app_client.post('/v1.0/goodevening/dan', data={})  # type: flask.Response
     assert response.status_code == 201
-    assert response.headers["Location"] == "http://localhost/my/uri"
+    # Default Werkzeug behavior was changed in 2.1 (https://github.com/pallets/werkzeug/issues/2352)
+    assert response.headers["Location"] in ["http://localhost/my/uri", "/my/uri"]
 
 
 def test_header_not_returned(simple_openapi_app):

tests/conftest.py

@@ -6,6 +6,7 @@
 import pytest
 from connexion import App
 from connexion.security import FlaskSecurityHandlerFactory
+from werkzeug.test import Client, EnvironBuilder
 
 logging.basicConfig(level=logging.DEBUG)
 
@@ -31,6 +32,38 @@ def json(self):
         return json.loads(self.text)
 
 
+def fixed_get_environ():
+    """See https://github.com/pallets/werkzeug/issues/2347"""
+
+    original_get_environ = EnvironBuilder.get_environ
+
+    def f(self):
+        result = original_get_environ(self)
+        result.pop("HTTP_CONTENT_TYPE", None)
+        result.pop("HTTP_CONTENT_LENGTH", None)
+        return result
+
+    return f
+
+
+EnvironBuilder.get_environ = fixed_get_environ()
+
+
+def buffered_open():
+    """For use with ASGI middleware"""
+
+    original_open = Client.open
+
+    def f(*args, **kwargs):
+        kwargs["buffered"] = True
+        return original_open(*args, **kwargs)
+
+    return f
+
+
+Client.open = buffered_open()
+
+
 # Helper fixtures functions
 # =========================
 

tests/fakeapi/hello/__init__.py

@@ -96,15 +96,15 @@ def with_problem():
     raise ProblemException(type='http://www.example.com/error',
                            title='Some Error',
                            detail='Something went wrong somewhere',
-                           status=418,
+                           status=402,
                            instance='instance1',
                            headers={'x-Test-Header': 'In Test'})
 
 
 def with_problem_txt():
     raise ProblemException(title='Some Error',
                            detail='Something went wrong somewhere',
-                           status=418,
+                           status=402,
                            instance='instance1')