vincbeck commented on code in PR #70707:
URL: https://github.com/apache/airflow/pull/70707#discussion_r4591129656


##########
providers/keycloak/src/airflow/providers/keycloak/auth_manager/keycloak_auth_manager.py:
##########
@@ -447,10 +455,20 @@ def get_fastapi_app(self) -> FastAPI | None:
 
         return app
 
-    def get_fastapi_middlewares(self):
+    def get_jwt_refresh_middleware(self) -> 
list[tuple[_MiddlewareFactory[[Any]], dict[str, Any]]]:
+        from airflow.api_fastapi.core_api.app import _STATIC_URL_PATH
         from airflow.providers.keycloak.auth_manager.middleware import 
KeycloakJWTMiddleware
 
-        return [(KeycloakJWTMiddleware, {})]
+        return [(KeycloakJWTMiddleware, {"skip_path_prefixes": 
(f"{_STATIC_URL_PATH}/",)})]
+
+    def get_fastapi_middlewares(self) -> list[tuple[_MiddlewareFactory, 
dict[str, Any]]]:
+        if not AIRFLOW_V_3_5_PLUS:

Review Comment:
   `get_jwt_refresh_middleware()` was backported to `v3-4-test` (#75868), so it 
ships in 3.4.1. On 3.4.1 core registers `KeycloakJWTMiddleware` through 
`get_jwt_refresh_middleware()` and a second time through 
`get_fastapi_middlewares()` because of this check. Every request is then 
refreshed twice, and Keycloak gets two refresh calls with the same refresh 
token. With refresh token rotation on, the second call can fail and log the 
user out. Fix: check whether core has the hook (e.g. `hasattr(BaseAuthManager, 
"get_jwt_refresh_middleware")`) instead of checking the version, and do the 
same for the other `AIRFLOW_V_3_5_PLUS` checks tied to it.



##########
providers/keycloak/src/airflow/providers/keycloak/auth_manager/middleware.py:
##########
@@ -68,99 +103,113 @@ class KeycloakJWTMiddleware(BaseHTTPMiddleware):
     attempt to refresh it using the refresh token.
     """
 
-    async def dispatch(self, request: Request, call_next):
-        user = None
-        new_token = None
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> 
None:
+        if AIRFLOW_V_3_5_PLUS:
+            return await super().__call__(scope, receive, send)
+
+        # For Airflow v3.4.0- we mirror the implementation from 
JWTRefreshMiddleware.__call__()
+        if scope["type"] != "http" or self._is_skipped(scope):
+            await self.app(scope, receive, send)
+            return
+
+        request = Request(scope)
+        current_token = request.cookies.get(COOKIE_NAME_JWT_TOKEN)
+        if current_token is None:
+            await self.app(scope, receive, send)
+            return
+
         new_user = None
         session_invalidated = False
         try:
-            try:
-                new_user, current_user = await self._refresh_user(request)
-                user = new_user or current_user
-            except (
-                AuthManagerRefreshTokenExpiredException,
-                HTTPException,
-            ):
-                new_token = ""
-
-            if user is not None:
+            new_user, current_user = await self.refresh_user(request)
+            if user := (new_user or current_user):
+                # Stamp the trust sentinel alongside the user so `get_user()`
+                # can distinguish this trusted assignment from a stray write
+                # by unrelated middleware.
                 request.state.user = user
-
-                user_injected = getattr(
+                request.state.user_authenticated_via = getattr(
                     core_api_security,
                     "USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
                     None,
                 )
-                if user_injected is not None:
-                    request.state.user_authenticated_via = user_injected
-
-            response = await call_next(request)
-
-            if new_token == "" and getattr(request.state, "jwt_token_issued", 
False):
-                new_token = None
-
-            if new_user and not await self._is_jwt_still_valid(request):
-                # The Airflow JWT sent with the request was invalidated while 
the request was
-                # handled (e.g. by the logout route). Do not replace it with a 
freshly signed
-                # one -- that would keep the session alive -- and clear the 
session cookies.
-                new_user = None
-                session_invalidated = True
-
-            if new_user or new_token is not None or session_invalidated:
-                secure = request.base_url.scheme == "https" or 
bool(conf.get("api", "ssl_cert", fallback=""))
-                cookie_path = get_cookie_path()
-                if new_token == "":
-                    response.set_cookie(
-                        COOKIE_NAME_JWT_TOKEN,
-                        new_token,
-                        path=cookie_path,
-                        httponly=True,
-                        secure=secure,
-                        samesite="lax",
-                        max_age=0,
-                    )
-                    if cookie_path != "/":
-                        response.set_cookie(
-                            COOKIE_NAME_JWT_TOKEN,
-                            "",
-                            path="/",
-                            httponly=True,
-                            secure=secure,
-                            samesite="lax",
-                            max_age=0,
-                        )
-                else:
-                    response = await self._set_new_token(new_user, secure, 
response, cookie_path)
+        except (HTTPException, AuthManagerRefreshTokenExpiredException) as e:
+            # Receive a HTTPException when the Airflow token is expired
+            # Receive a AuthManagerRefreshTokenExpiredException when the 
potential underlying refresh
+            # token used by the auth manager is expired
+            log.error("Session Invalidated: %s", e)
+            session_invalidated = True
+
+        if session_invalidated or new_user is not None:
+            extra_cookies = self.get_extra_cookies(request, new_user)
+            token_cookie, cleanup_cookies = self.build_cookie_headers(
+                request, await self.generate_new_user_token(request, 
new_user), extra_cookies
+            )
+        else:
+            token_cookie, cleanup_cookies = (None, [])
+        response_started = False
+
+        async def send_with_cookies(message: Message) -> None:
+            nonlocal response_started
+            if message["type"] == "http.response.start":
+                response_started = True
+                headers = MutableHeaders(scope=message)
+                route_cookies = headers.getlist("set-cookie")
+                route_set_token = any(
+                    value.startswith(f"{COOKIE_NAME_JWT_TOKEN}=") for value in 
route_cookies
+                )
+                del headers["set-cookie"]
+                # The route owns the token it sets: never send ours, so a 
refreshed token can't outlive a logout.
+                cookie_values = (
+                    cleanup_cookies
+                    if route_set_token or not token_cookie
+                    else [token_cookie, *cleanup_cookies]
+                )
+                # Ours go first: for the same cookie name and path the later 
Set-Cookie wins, so the
+                # cookies set by the route itself take precedence.
+                for value in [*cookie_values, *route_cookies]:
+                    headers.append("set-cookie", value)
+            await send(message)
 
+        try:
+            await self.app(scope, receive, send_with_cookies)
         except HTTPException as exc:
-            # If any HTTPException is raised during user resolution or 
refresh, return it as response
-            return JSONResponse(status_code=exc.status_code, 
content={"detail": exc.detail})
-
-        return response
-
-    @classmethod
-    async def _set_new_token(
-        cls,
-        new_user: KeycloakAuthManagerUser | None,
-        secure: bool,
-        response: Response,
-        cookie_path: str | None = None,
-    ) -> Response:
-        """
-        Set Cookies in the response based on a new JWT token and a new user 
model.
+            if response_started:
+                raise
+            # An HTTPException escaping the inner middlewares is returned as a 
response
+            response = JSONResponse(status_code=exc.status_code, 
content={"detail": exc.detail})
+            await response(scope, receive, send)
 
-        :param new_user: User model for the JWT token
-        :param secure: HTTP secure property for cookies
-        :param response: FastAPI response object to set the cookies on
-        :param cookie_path: Path for cookies in the response
-        """
-        if cookie_path is None:
-            cookie_path = get_cookie_path()
+    def _is_skipped(self, scope: Scope) -> bool:
+        path = scope["path"].removeprefix(scope.get("root_path", ""))
+        return path in UNAUTHENTICATED_PATHS or 
path.startswith(self.skip_path_prefixes)
+
+    @staticmethod
+    def get_extra_cookies(request: Request, new_user: BaseUser | None) -> 
dict[str, str]:
         if new_user:
-            # If we created a new user, serialize it and set it as a cookie
-            new_token = get_auth_manager().generate_jwt(new_user)
-        else:
-            new_token = ""
+            user = cast("KeycloakAuthManagerUser", new_user)
+            return {
+                COOKIE_NAME_ACCESS_TOKEN: user.access_token,
+                COOKIE_NAME_REFRESH_TOKEN: user.refresh_token or "",
+            }
+        return {}
+
+    @staticmethod
+    async def generate_new_user_token(request: Request, new_user: BaseUser | 
None) -> str:
+        """If the Keycloak JWT is still valid, invalidate the Airflow JWT, 
otherwise generate a new JWT."""
+        if new_user:
+            if not await KeycloakJWTMiddleware._is_jwt_still_valid(request):

Review Comment:
   This now runs before the route (it is called while building the cookies, 
before `self.app(...)`), so it can no longer catch a token revoked during the 
request, which is what `_is_jwt_still_valid` was for. It only re-validates the 
token `refresh_user` just validated, which costs one more JWT decode and 
revocation DB lookup on every refresh. Is it still needed? Also, the docstring 
is inverted: it returns `""` when the JWT is no longer valid.



##########
providers/keycloak/src/airflow/providers/keycloak/auth_manager/keycloak_auth_manager.py:
##########
@@ -205,7 +207,13 @@ async def get_user_from_token(
         :param refresh_token: Keycloak refresh JWT
         """
         user = cast("KeycloakAuthManagerUser", await 
super().get_user_from_token(token))
-        if not AIRFLOW_V_3_3_PLUS:
+        if AIRFLOW_V_3_5_PLUS or not AIRFLOW_V_3_3_PLUS:

Review Comment:
   On 3.5+ this skips the `return user if user.access_token else None` check 
below, so a browser JWT without Keycloak tokens now returns a user with an 
empty access token instead of `None`. Example: `refresh_user` fails in the 
middleware because `_access_token` is missing, core `get_user` falls back to 
the cookie, and the user gets a 403 on every check instead of a 401 and a 
redirect to login. Is that intended?



##########
providers/keycloak/src/airflow/providers/keycloak/auth_manager/middleware.py:
##########
@@ -68,99 +103,113 @@ class KeycloakJWTMiddleware(BaseHTTPMiddleware):
     attempt to refresh it using the refresh token.
     """
 
-    async def dispatch(self, request: Request, call_next):
-        user = None
-        new_token = None
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> 
None:
+        if AIRFLOW_V_3_5_PLUS:
+            return await super().__call__(scope, receive, send)

Review Comment:
   This copies the whole `JWTRefreshMiddleware.__call__` from core. Can you put 
the copy in the backport `JWTRefreshMiddleware` class above instead? Then 
`KeycloakJWTMiddleware` only overrides `refresh_user`, `get_extra_cookies` and 
`generate_new_user_token`, and `_is_skipped` and `build_cookie_headers` no 
longer need to be redefined here.



##########
providers/keycloak/src/airflow/providers/keycloak/auth_manager/middleware.py:
##########
@@ -68,99 +103,113 @@ class KeycloakJWTMiddleware(BaseHTTPMiddleware):
     attempt to refresh it using the refresh token.
     """
 
-    async def dispatch(self, request: Request, call_next):
-        user = None
-        new_token = None
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> 
None:
+        if AIRFLOW_V_3_5_PLUS:
+            return await super().__call__(scope, receive, send)
+
+        # For Airflow v3.4.0- we mirror the implementation from 
JWTRefreshMiddleware.__call__()
+        if scope["type"] != "http" or self._is_skipped(scope):
+            await self.app(scope, receive, send)
+            return
+
+        request = Request(scope)
+        current_token = request.cookies.get(COOKIE_NAME_JWT_TOKEN)
+        if current_token is None:
+            await self.app(scope, receive, send)
+            return
+
         new_user = None
         session_invalidated = False
         try:
-            try:
-                new_user, current_user = await self._refresh_user(request)
-                user = new_user or current_user
-            except (
-                AuthManagerRefreshTokenExpiredException,
-                HTTPException,
-            ):
-                new_token = ""
-
-            if user is not None:
+            new_user, current_user = await self.refresh_user(request)
+            if user := (new_user or current_user):
+                # Stamp the trust sentinel alongside the user so `get_user()`
+                # can distinguish this trusted assignment from a stray write
+                # by unrelated middleware.
                 request.state.user = user
-
-                user_injected = getattr(
+                request.state.user_authenticated_via = getattr(
                     core_api_security,
                     "USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
                     None,
                 )
-                if user_injected is not None:
-                    request.state.user_authenticated_via = user_injected
-
-            response = await call_next(request)
-
-            if new_token == "" and getattr(request.state, "jwt_token_issued", 
False):
-                new_token = None
-
-            if new_user and not await self._is_jwt_still_valid(request):
-                # The Airflow JWT sent with the request was invalidated while 
the request was
-                # handled (e.g. by the logout route). Do not replace it with a 
freshly signed
-                # one -- that would keep the session alive -- and clear the 
session cookies.
-                new_user = None
-                session_invalidated = True
-
-            if new_user or new_token is not None or session_invalidated:
-                secure = request.base_url.scheme == "https" or 
bool(conf.get("api", "ssl_cert", fallback=""))
-                cookie_path = get_cookie_path()
-                if new_token == "":
-                    response.set_cookie(
-                        COOKIE_NAME_JWT_TOKEN,
-                        new_token,
-                        path=cookie_path,
-                        httponly=True,
-                        secure=secure,
-                        samesite="lax",
-                        max_age=0,
-                    )
-                    if cookie_path != "/":
-                        response.set_cookie(
-                            COOKIE_NAME_JWT_TOKEN,
-                            "",
-                            path="/",
-                            httponly=True,
-                            secure=secure,
-                            samesite="lax",
-                            max_age=0,
-                        )
-                else:
-                    response = await self._set_new_token(new_user, secure, 
response, cookie_path)
+        except (HTTPException, AuthManagerRefreshTokenExpiredException) as e:
+            # Receive a HTTPException when the Airflow token is expired
+            # Receive a AuthManagerRefreshTokenExpiredException when the 
potential underlying refresh
+            # token used by the auth manager is expired
+            log.error("Session Invalidated: %s", e)
+            session_invalidated = True
+
+        if session_invalidated or new_user is not None:
+            extra_cookies = self.get_extra_cookies(request, new_user)
+            token_cookie, cleanup_cookies = self.build_cookie_headers(
+                request, await self.generate_new_user_token(request, 
new_user), extra_cookies
+            )
+        else:
+            token_cookie, cleanup_cookies = (None, [])
+        response_started = False
+
+        async def send_with_cookies(message: Message) -> None:
+            nonlocal response_started
+            if message["type"] == "http.response.start":
+                response_started = True
+                headers = MutableHeaders(scope=message)
+                route_cookies = headers.getlist("set-cookie")
+                route_set_token = any(
+                    value.startswith(f"{COOKIE_NAME_JWT_TOKEN}=") for value in 
route_cookies
+                )
+                del headers["set-cookie"]
+                # The route owns the token it sets: never send ours, so a 
refreshed token can't outlive a logout.
+                cookie_values = (
+                    cleanup_cookies
+                    if route_set_token or not token_cookie
+                    else [token_cookie, *cleanup_cookies]
+                )
+                # Ours go first: for the same cookie name and path the later 
Set-Cookie wins, so the
+                # cookies set by the route itself take precedence.
+                for value in [*cookie_values, *route_cookies]:
+                    headers.append("set-cookie", value)
+            await send(message)
 
+        try:
+            await self.app(scope, receive, send_with_cookies)
         except HTTPException as exc:
-            # If any HTTPException is raised during user resolution or 
refresh, return it as response
-            return JSONResponse(status_code=exc.status_code, 
content={"detail": exc.detail})
-
-        return response
-
-    @classmethod
-    async def _set_new_token(
-        cls,
-        new_user: KeycloakAuthManagerUser | None,
-        secure: bool,
-        response: Response,
-        cookie_path: str | None = None,
-    ) -> Response:
-        """
-        Set Cookies in the response based on a new JWT token and a new user 
model.
+            if response_started:
+                raise
+            # An HTTPException escaping the inner middlewares is returned as a 
response
+            response = JSONResponse(status_code=exc.status_code, 
content={"detail": exc.detail})
+            await response(scope, receive, send)
 
-        :param new_user: User model for the JWT token
-        :param secure: HTTP secure property for cookies
-        :param response: FastAPI response object to set the cookies on
-        :param cookie_path: Path for cookies in the response
-        """
-        if cookie_path is None:
-            cookie_path = get_cookie_path()
+    def _is_skipped(self, scope: Scope) -> bool:
+        path = scope["path"].removeprefix(scope.get("root_path", ""))
+        return path in UNAUTHENTICATED_PATHS or 
path.startswith(self.skip_path_prefixes)
+
+    @staticmethod
+    def get_extra_cookies(request: Request, new_user: BaseUser | None) -> 
dict[str, str]:
         if new_user:
-            # If we created a new user, serialize it and set it as a cookie
-            new_token = get_auth_manager().generate_jwt(new_user)
-        else:
-            new_token = ""
+            user = cast("KeycloakAuthManagerUser", new_user)
+            return {
+                COOKIE_NAME_ACCESS_TOKEN: user.access_token,
+                COOKIE_NAME_REFRESH_TOKEN: user.refresh_token or "",
+            }
+        return {}

Review Comment:
   The old code cleared `_access_token` and `_refresh_token` when the session 
was invalidated. Now this returns `{}` in that case, so only `_token` is 
cleared and the Keycloak tokens stay in the browser. Should it clear both?
   
   ```suggestion
           return {COOKIE_NAME_ACCESS_TOKEN: "", COOKIE_NAME_REFRESH_TOKEN: ""}
   ```



##########
providers/keycloak/src/airflow/providers/keycloak/auth_manager/middleware.py:
##########
@@ -68,99 +103,113 @@ class KeycloakJWTMiddleware(BaseHTTPMiddleware):
     attempt to refresh it using the refresh token.
     """
 
-    async def dispatch(self, request: Request, call_next):
-        user = None
-        new_token = None
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> 
None:
+        if AIRFLOW_V_3_5_PLUS:
+            return await super().__call__(scope, receive, send)
+
+        # For Airflow v3.4.0- we mirror the implementation from 
JWTRefreshMiddleware.__call__()
+        if scope["type"] != "http" or self._is_skipped(scope):
+            await self.app(scope, receive, send)
+            return
+
+        request = Request(scope)
+        current_token = request.cookies.get(COOKIE_NAME_JWT_TOKEN)
+        if current_token is None:
+            await self.app(scope, receive, send)
+            return
+
         new_user = None
         session_invalidated = False
         try:
-            try:
-                new_user, current_user = await self._refresh_user(request)
-                user = new_user or current_user
-            except (
-                AuthManagerRefreshTokenExpiredException,
-                HTTPException,
-            ):
-                new_token = ""
-
-            if user is not None:
+            new_user, current_user = await self.refresh_user(request)
+            if user := (new_user or current_user):
+                # Stamp the trust sentinel alongside the user so `get_user()`
+                # can distinguish this trusted assignment from a stray write
+                # by unrelated middleware.
                 request.state.user = user
-
-                user_injected = getattr(
+                request.state.user_authenticated_via = getattr(
                     core_api_security,
                     "USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
                     None,
                 )
-                if user_injected is not None:
-                    request.state.user_authenticated_via = user_injected
-
-            response = await call_next(request)
-
-            if new_token == "" and getattr(request.state, "jwt_token_issued", 
False):
-                new_token = None
-
-            if new_user and not await self._is_jwt_still_valid(request):
-                # The Airflow JWT sent with the request was invalidated while 
the request was
-                # handled (e.g. by the logout route). Do not replace it with a 
freshly signed
-                # one -- that would keep the session alive -- and clear the 
session cookies.
-                new_user = None
-                session_invalidated = True
-
-            if new_user or new_token is not None or session_invalidated:
-                secure = request.base_url.scheme == "https" or 
bool(conf.get("api", "ssl_cert", fallback=""))
-                cookie_path = get_cookie_path()
-                if new_token == "":
-                    response.set_cookie(
-                        COOKIE_NAME_JWT_TOKEN,
-                        new_token,
-                        path=cookie_path,
-                        httponly=True,
-                        secure=secure,
-                        samesite="lax",
-                        max_age=0,
-                    )
-                    if cookie_path != "/":
-                        response.set_cookie(
-                            COOKIE_NAME_JWT_TOKEN,
-                            "",
-                            path="/",
-                            httponly=True,
-                            secure=secure,
-                            samesite="lax",
-                            max_age=0,
-                        )
-                else:
-                    response = await self._set_new_token(new_user, secure, 
response, cookie_path)
+        except (HTTPException, AuthManagerRefreshTokenExpiredException) as e:
+            # Receive a HTTPException when the Airflow token is expired
+            # Receive a AuthManagerRefreshTokenExpiredException when the 
potential underlying refresh
+            # token used by the auth manager is expired
+            log.error("Session Invalidated: %s", e)

Review Comment:
   nit: an expired session is normal, so logging it at `error` level will flood 
the logs. Core does not log here. I would use `debug` or drop it.



##########
providers/keycloak/tests/unit/keycloak/auth_manager/test_middleware.py:
##########
@@ -16,483 +16,765 @@
 # under the License.
 from __future__ import annotations
 
-from unittest.mock import AsyncMock, MagicMock, Mock, call, patch
+import threading
+from unittest.mock import AsyncMock, MagicMock, Mock, patch
 
 import pytest
-from fastapi import Request
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import PlainTextResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.testclient import TestClient
 from jwt import ExpiredSignatureError, InvalidTokenError
 
 from airflow.api_fastapi.auth.managers.base_auth_manager import 
COOKIE_NAME_JWT_TOKEN
 from airflow.api_fastapi.core_api import security as core_api_security
+from airflow.providers.keycloak.auth_manager import middleware
 from airflow.providers.keycloak.auth_manager.constants import (
     COOKIE_NAME_ACCESS_TOKEN,
     COOKIE_NAME_REFRESH_TOKEN,
 )
+from airflow.providers.keycloak.auth_manager.keycloak_auth_manager import 
KeycloakAuthManager
 from airflow.providers.keycloak.auth_manager.middleware import 
KeycloakJWTMiddleware
 from airflow.providers.keycloak.auth_manager.user import 
KeycloakAuthManagerUser
 
-from tests_common.test_utils.version_compat import AIRFLOW_V_3_1_7_PLUS
+from tests_common.test_utils.config import conf_vars
+from tests_common.test_utils.version_compat import (
+    AIRFLOW_V_3_1_7_PLUS,
+    AIRFLOW_V_3_3_PLUS,
+    AIRFLOW_V_3_5_PLUS,
+)
 
 if AIRFLOW_V_3_1_7_PLUS:
     from airflow.api_fastapi.auth.managers.exceptions import 
AuthManagerRefreshTokenExpiredException
 else:
     AuthManagerRefreshTokenExpiredException = None  # type: 
ignore[assignment,misc]
 
+from unit.keycloak.test_utils import keycloak_token, token_with_payload
 
-def pytest_generate_tests(metafunc):
-    if "secure" in metafunc.fixturenames:
-        metafunc.parametrize("secure", [True, False], indirect=True)
-
-
[email protected]
-class TestKeycloakJWTMiddleware:
-    @pytest.fixture
-    def middleware(self):
-        return KeycloakJWTMiddleware(app=Mock(name="app"))
-
-    @pytest.fixture
-    def mock_request(self, secure):
-        request = MagicMock(spec=Request, name="request")
-        request.base_url.scheme = "https" if secure else "http"
-        request.cookies = {}
-        request.headers = {}
-        request.state = MagicMock(name="state", spec=[])
-        request.state.user = None
-        del request.state.user_authenticated_via
-        return request
-
-    @pytest.fixture
-    def mock_user(self):
-        user = Mock(name="user", spec=KeycloakAuthManagerUser)
-        user.user_id = "user_id"
-        user.name = "name"
-        user.access_token = "access_token"
-        user.refresh_token = "refresh_token"
-        return user
-
-    @pytest.fixture
-    def call_next(self):
-        return AsyncMock(return_value=Mock(name="response"), name="call_next")
-
-    @pytest.fixture
-    def auth_manager(self):
-        return Mock(name="auth_manager")
-
-    @pytest.fixture
-    def secure(self, request):
-        return request.param
-
-    
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
-    async def test_get_keycloak_tokens_from_cookies(
-        self, mock_get_auth_manager, auth_manager, call_next, mock_request, 
middleware, mock_user
-    ):
-        auth_manager.get_user_from_token = AsyncMock(return_value=mock_user)
-        auth_manager.refresh_user.return_value = None
-        mock_get_auth_manager.return_value = auth_manager
-
-        mock_request.cookies = {
-            COOKIE_NAME_JWT_TOKEN: "token",
-            COOKIE_NAME_ACCESS_TOKEN: "access_token",
-            COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
-        }
-
-        await middleware.dispatch(mock_request, call_next)
-
-        assert mock_request.state.user is mock_user
-        assert mock_request.state.user.access_token == "access_token"
-        assert mock_request.state.user.refresh_token == "refresh_token"
-
-        trusted_marker = getattr(
-            core_api_security,
-            "USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
-            None,
-        )
+MODULE = "airflow.providers.keycloak.auth_manager.middleware"
 
-        if trusted_marker is not None:
-            assert mock_request.state.user_authenticated_via is trusted_marker
-        else:
-            assert not hasattr(mock_request.state, "user_authenticated_via")
+_default_cookies = [
+    "_token=issued_token; HttpOnly; Path=/; SameSite=lax",
+    "_access_token=issued_access_token; HttpOnly; Path=/; SameSite=lax",
+    "_refresh_token=issued_refresh_token; HttpOnly; Path=/; SameSite=lax",
+]
 
-        auth_manager.get_user_from_token.assert_called_once_with("token", 
"access_token", "refresh_token")
-        auth_manager.refresh_user.assert_called_once_with(user=mock_user)
-        call_next.assert_awaited_once_with(mock_request)
 
-    
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
-    async def test_refresh_keycloak_token(
-        self,
-        mock_get_auth_manager,
-        auth_manager,
-        call_next,
-        mock_request,
-        middleware,
-        mock_user,
-        secure,
-    ):
-        new_user = Mock(name="user", spec=KeycloakAuthManagerUser)
-        new_user.access_token = "new_access_token"
-        new_user.refresh_token = "new_refresh_token"
-        auth_manager.get_user_from_token = AsyncMock(return_value=mock_user)
-        auth_manager.refresh_user = Mock(return_value=new_user)
-        auth_manager.generate_jwt.return_value = "new_token"
-        mock_get_auth_manager.return_value = auth_manager
+def _build_app(static_dir=None, root_path: str = "") -> tuple[FastAPI, dict]:
+    """Return an app wrapped by the middleware and a dict capturing what the 
endpoint saw."""
+    seen: dict = {}
+    app = FastAPI(root_path=root_path)
 
-        mock_request.cookies = {
-            COOKIE_NAME_JWT_TOKEN: "token",
-            COOKIE_NAME_ACCESS_TOKEN: "access_token",
-            COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
-        }
+    @app.get("/api/v2/dags")
+    def dags(request: Request):
+        seen["user"] = getattr(request.state, "user", None)
+        seen["authenticated_via"] = getattr(request.state, 
"user_authenticated_via", None)
+        return PlainTextResponse("ok")
 
-        response = await middleware.dispatch(mock_request, call_next)
+    @app.get("/api/v2/monitor/health")
+    def health():
+        return PlainTextResponse("healthy")
 
-        assert mock_request.state.user is new_user
-        assert mock_request.state.user.access_token == "new_access_token"
-        assert mock_request.state.user.refresh_token == "new_refresh_token"
+    @app.get("/api/v2/version")
+    def version():
+        return PlainTextResponse("3.x")
 
-        response.set_cookie.assert_any_call(
-            COOKIE_NAME_JWT_TOKEN,
-            "new_token",
-            path="/",
-            secure=secure,
-            samesite="lax",
-            httponly=True,
-            max_age=None,
+    @app.get("/auth/login_callback")
+    def login_callback():
+        response = PlainTextResponse("logged in")
+        response.set_cookie(
+            COOKIE_NAME_JWT_TOKEN, "issued_token", 
path=middleware.get_cookie_path(), httponly=True
         )
-        response.set_cookie.assert_any_call(
+        response.set_cookie(
             COOKIE_NAME_ACCESS_TOKEN,
-            "new_access_token",
-            path="/",
-            samesite="lax",
-            secure=secure,
+            "issued_access_token",
+            path=middleware.get_cookie_path(),
             httponly=True,
         )
-        response.set_cookie.assert_any_call(
+        response.set_cookie(
             COOKIE_NAME_REFRESH_TOKEN,
-            "new_refresh_token",
-            path="/",
-            samesite="lax",
-            secure=secure,
+            "issued_refresh_token",
+            path=middleware.get_cookie_path(),
             httponly=True,
         )
-
-        trusted_marker = getattr(
-            core_api_security,
-            "USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
-            None,
+        return response
+
+    @app.get("/api/v2/auth/logout")
+    def logout():
+        response = PlainTextResponse("logged out")
+        response.delete_cookie(COOKIE_NAME_JWT_TOKEN, 
path=middleware.get_cookie_path(), httponly=True)
+        return response
+
+    @app.get("/api/v2/stream")
+    def stream():
+        return StreamingResponse(iter([b"chunk1-", b"chunk2-", b"chunk3"]), 
media_type="text/plain")
+
+    if static_dir is not None:
+        app.mount("/static", StaticFiles(directory=static_dir), 
name="webapp_static_folder")
+
+    app.add_middleware(KeycloakJWTMiddleware, skip_path_prefixes=("/static/",))
+    return app, seen
+
+
+def _build_user(user_id: str, name: str, access_token: str, refresh_token: 
str):
+    user = KeycloakAuthManagerUser(user_id=user_id, name=name, 
access_token="", refresh_token=None)
+    if not AIRFLOW_V_3_5_PLUS:
+        user.access_token = access_token
+        user.refresh_token = refresh_token
+    return user
+
+
[email protected]
+def mock_auth_manager():
+    with patch(f"{MODULE}.get_auth_manager", autospec=True) as 
mock_get_auth_manager:
+        mock_auth_manager = MagicMock(spec=KeycloakAuthManager)
+        mock_auth_manager.refresh_user.return_value = None
+        mock_user = _build_user(
+            user_id="user_id",
+            name="name",
+            access_token=keycloak_token("user_id"),
+            refresh_token="refresh_token",
         )
+        mock_auth_manager.get_user_from_token = 
AsyncMock(return_value=mock_user)
+        mock_auth_manager.generate_jwt.return_value = "new_token"
+        mock_auth_manager._token_subject = KeycloakAuthManager._token_subject
+        mock_get_auth_manager.return_value = mock_auth_manager
+        yield mock_auth_manager
 
-        if trusted_marker is not None:
-            assert mock_request.state.user_authenticated_via is trusted_marker
-        else:
-            assert not hasattr(mock_request.state, "user_authenticated_via")
-
-        # Once to resolve the user, once more after the endpoint ran to 
confirm the
-        # token is still accepted before a replacement is issued.
-        assert auth_manager.get_user_from_token.await_args_list == [
-            call("token", "access_token", "refresh_token"),
-            call("token", "access_token", "refresh_token"),
-        ]
-        auth_manager.refresh_user.assert_called_once_with(user=mock_user)
-        auth_manager.generate_jwt.assert_called_once_with(new_user)
-        call_next.assert_awaited_once_with(mock_request)
-
-    
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
-    async def test_no_new_token_when_jwt_revoked_during_request(
-        self,
-        mock_get_auth_manager,
-        auth_manager,
-        call_next,
-        mock_request,
-        middleware,
-        mock_user,
-        secure,
-    ):
-        """
-        When the endpoint revokes the token the request came with (the logout 
route does),
-        a refreshed session must not be turned into a new JWT; the session 
cookies are cleared.
-        """
-        new_user = Mock(name="user", spec=KeycloakAuthManagerUser)
-        new_user.access_token = "new_access_token"
-        new_user.refresh_token = "new_refresh_token"
-        auth_manager.get_user_from_token = AsyncMock(return_value=mock_user)
-        auth_manager.refresh_user = Mock(return_value=new_user)
-        auth_manager.generate_jwt.return_value = "new_token"
-        mock_get_auth_manager.return_value = auth_manager
 
-        mock_request.cookies = {
-            COOKIE_NAME_JWT_TOKEN: "token",
-            COOKIE_NAME_ACCESS_TOKEN: "access_token",
-            COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
-        }
-
-        async def logout_endpoint(request):
-            # The endpoint revokes the presented token, so it is rejected from 
now on.
-            auth_manager.get_user_from_token.side_effect = 
InvalidTokenError("Token has been revoked")
-            return Mock(name="response")
[email protected]
+def mock_generate_jwt(mock_auth_manager):
+    return mock_auth_manager.generate_jwt
 
-        call_next.side_effect = logout_endpoint
 
-        response = await middleware.dispatch(mock_request, call_next)
[email protected](autouse=True)
+def no_ssl_cert():
+    with conf_vars({("api", "ssl_cert"): ""}):
+        yield
 
-        auth_manager.generate_jwt.assert_not_called()
-        for cookie_name in (COOKIE_NAME_JWT_TOKEN, COOKIE_NAME_ACCESS_TOKEN, 
COOKIE_NAME_REFRESH_TOKEN):
-            assert any(
-                c.args[0] == cookie_name and c.args[1] == "" and 
c.kwargs.get("max_age") == 0
-                for c in response.set_cookie.call_args_list
-            ), f"{cookie_name} cookie was not cleared"
-        issued_values = {c.args[1] for c in response.set_cookie.call_args_list 
if len(c.args) > 1}
-        assert issued_values.isdisjoint({"new_token", "new_access_token", 
"new_refresh_token"})
 
-    
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
-    async def test_new_token_when_jwt_expired_during_request(
-        self,
-        mock_get_auth_manager,
-        auth_manager,
-        call_next,
-        mock_request,
-        middleware,
-        mock_user,
-        secure,
-    ):
-        """A token that merely expired while the request was handled is still 
replaced."""
-        new_user = Mock(name="user", spec=KeycloakAuthManagerUser)
-        new_user.access_token = "new_access_token"
-        new_user.refresh_token = "new_refresh_token"
-        auth_manager.get_user_from_token = AsyncMock(side_effect=[mock_user, 
ExpiredSignatureError()])
-        auth_manager.refresh_user = Mock(return_value=new_user)
-        auth_manager.generate_jwt.return_value = "new_token"
-        mock_get_auth_manager.return_value = auth_manager
[email protected](
+    not AIRFLOW_V_3_3_PLUS, reason="KeycloakJWTMiddleware relies on custom 
middleware interface."
+)
[email protected]
+class TestKeycloakJWTMiddleware:
+    def test_no_token(self, mock_auth_manager):
+        app, _ = _build_app()
 
-        mock_request.cookies = {
-            COOKIE_NAME_JWT_TOKEN: "token",
-            COOKIE_NAME_ACCESS_TOKEN: "access_token",
-            COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
-        }
+        response = TestClient(app, cookies={}).get("/api/v2/dags")
 
-        response = await middleware.dispatch(mock_request, call_next)
+        assert response.status_code == 200
+        assert "set-cookie" not in response.headers
+        mock_auth_manager.get_user_from_token.assert_not_called()
 
-        auth_manager.generate_jwt.assert_called_once_with(new_user)
-        response.set_cookie.assert_any_call(
-            COOKIE_NAME_JWT_TOKEN,
-            "new_token",
-            path="/",
-            secure=secure,
-            samesite="lax",
-            httponly=True,
-            max_age=None,
+    def test_invalid_token_clears_cookie(self, mock_auth_manager):
+        mock_auth_manager.get_user_from_token.side_effect = HTTPException(
+            status_code=403, detail="Invalid JWT token"
         )
+        app, seen = _build_app()
 
-    
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
-    async def test_no_keycloak_token(
-        self, mock_get_auth_manager, auth_manager, call_next, middleware, 
mock_request, secure
-    ):
-        mock_get_auth_manager.return_value = auth_manager
-
-        mock_request.cookies = {COOKIE_NAME_JWT_TOKEN: "token"}
+        response = TestClient(app, cookies={COOKIE_NAME_JWT_TOKEN: 
"invalid_token"}).get("/api/v2/dags")
 
-        response = await middleware.dispatch(mock_request, call_next)
+        assert response.status_code == 200
+        assert seen["user"] is None
+        assert '_token=""; HttpOnly; Max-Age=0; Path=/; SameSite=lax' in 
response.headers["set-cookie"]
+        mock_auth_manager.refresh_user.assert_not_called()
 
-        auth_manager.get_user_from_token.assert_not_called()
-        auth_manager.refresh_user.assert_not_called()
+    def test_no_refreshed_user(self, mock_auth_manager, mock_generate_jwt):
+        access_token = keycloak_token("user_id")
+        mock_auth_manager.refresh_user.return_value = None
+        app, seen = _build_app()
 
-        assert mock_request.state.user is None
+        response = TestClient(
+            app,
+            cookies={
+                COOKIE_NAME_JWT_TOKEN: "valid_token",
+                COOKIE_NAME_ACCESS_TOKEN: access_token,
+                COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+            },
+        ).get("/api/v2/dags")
 
         trusted_marker = getattr(
             core_api_security,
             "USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
             None,
         )
 
-        if trusted_marker is not None:
-            assert getattr(mock_request.state, "user_authenticated_via", None) 
is not trusted_marker
+        assert "set-cookie" not in response.headers
+        assert seen["user"] is 
mock_auth_manager.get_user_from_token.return_value
+        assert seen["authenticated_via"] is trusted_marker
+        if AIRFLOW_V_3_5_PLUS:
+            
mock_auth_manager.get_user_from_token.assert_called_once_with("valid_token")
         else:
-            assert not hasattr(mock_request.state, "user_authenticated_via")
-
-        call_next.assert_awaited_with(mock_request)
+            mock_auth_manager.get_user_from_token.assert_called_once_with(
+                "valid_token", access_token, "refresh_token"
+            )
+        mock_generate_jwt.assert_not_called()
 
-        response.set_cookie.assert_any_call(
-            COOKIE_NAME_JWT_TOKEN,
-            "",
-            path="/",
-            secure=secure,
-            httponly=True,
-            samesite="lax",
-            max_age=0,
+    def test_refreshed_user(self, mock_auth_manager):
+        access_token = keycloak_token("user_id")
+        current_user = _build_user(
+            user_id="user_id", name="name", access_token=access_token, 
refresh_token="refresh_token"
         )
-
-    
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
-    async def test_no_airflow_jwt_token(
-        self, mock_get_auth_manager, auth_manager, call_next, middleware, 
mock_request
-    ):
-        mock_get_auth_manager.return_value = auth_manager
-
-        mock_request.cookies = {
-            COOKIE_NAME_ACCESS_TOKEN: "access_token",
-            COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
-        }
-
-        response = await middleware.dispatch(mock_request, call_next)
-
-        auth_manager.get_user_from_token.assert_not_called()
-        auth_manager.refresh_user.assert_not_called()
-
-        assert mock_request.state.user is None
+        refreshed_user = KeycloakAuthManagerUser(
+            user_id="user_id", name="name", access_token=access_token, 
refresh_token="new_refresh_token"
+        )
+        mock_auth_manager.refresh_user.return_value = refreshed_user
+        mock_auth_manager.get_user_from_token.side_effect = [current_user, 
ExpiredSignatureError]
+        app, seen = _build_app()
+
+        response = TestClient(
+            app,
+            cookies={
+                COOKIE_NAME_JWT_TOKEN: "valid_token",
+                COOKIE_NAME_ACCESS_TOKEN: access_token,
+                COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+            },
+        ).get("/api/v2/dags")
 
         trusted_marker = getattr(
             core_api_security,
             "USER_INJECTED_BY_TRUSTED_MIDDLEWARE",
             None,
         )
 
-        if trusted_marker is not None:
-            assert getattr(mock_request.state, "user_authenticated_via", None) 
is not trusted_marker
-        else:
-            assert not hasattr(mock_request.state, "user_authenticated_via")
+        assert seen["user"] is refreshed_user
+        assert seen["authenticated_via"] is trusted_marker
+        
mock_auth_manager.refresh_user.assert_called_once_with(user=current_user)
+        mock_auth_manager.generate_jwt.assert_called_once_with(refreshed_user)
+        assert (
+            response.headers["set-cookie"]
+            == f"_token=new_token; HttpOnly; Path=/; SameSite=lax, 
_access_token={access_token}; HttpOnly; Path=/; SameSite=lax, 
_refresh_token=new_refresh_token; HttpOnly; Path=/; SameSite=lax"
+        )
 
-        call_next.assert_awaited_once_with(mock_request)
-        response.set_cookie.assert_not_called()
+    def test_invalid_token_does_not_clear_token_set_by_route(self, 
mock_auth_manager):
+        mock_auth_manager.get_user_from_token.side_effect = HTTPException(
+            status_code=403, detail="Invalid JWT token"
+        )
+        app, _ = _build_app()
 
-    
@patch("airflow.providers.keycloak.auth_manager.middleware.get_auth_manager")
-    @pytest.mark.asyncio
-    async def test_dispatch_expired_token(
-        self,
-        mock_get_auth_manager,
-        auth_manager,
-        call_next,
-        middleware,
-        mock_request,
-        secure,
-    ):
-        mock_get_auth_manager.return_value = auth_manager
-        mock_request.cookies = {
-            COOKIE_NAME_JWT_TOKEN: "invalid_token",
-            COOKIE_NAME_ACCESS_TOKEN: "access_token",
-            COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
-        }
-        auth_manager.get_user_from_token.side_effect = InvalidTokenError()
+        response = TestClient(app, cookies={COOKIE_NAME_JWT_TOKEN: 
"stale_token"}).get("/auth/login_callback")
 
-        response = await middleware.dispatch(mock_request, call_next)
+        assert response.headers.get_list("set-cookie") == _default_cookies
 
-        call_next.assert_called_once_with(mock_request)
-        auth_manager.get_user_from_token.assert_called_once_with(
-            "invalid_token", "access_token", "refresh_token"
+    def test_refreshed_token_does_not_override_logout(self, mock_generate_jwt, 
mock_auth_manager):
+        access_token = keycloak_token("user_id")
+        refreshed_user = KeycloakAuthManagerUser(
+            user_id="user_id", name="name", access_token=access_token, 
refresh_token="new_refresh_token"
         )
-
-        response.set_cookie.assert_any_call(
-            COOKIE_NAME_JWT_TOKEN,
-            "",
-            path="/",
-            secure=secure,
-            httponly=True,
-            samesite="lax",
-            max_age=0,
+        mock_auth_manager.refresh_user.return_value = refreshed_user
+        mock_generate_jwt.return_value = "new_token"
+        app, _ = _build_app()
+
+        response = TestClient(
+            app,
+            cookies={
+                COOKIE_NAME_JWT_TOKEN: "valid_token",
+                COOKIE_NAME_ACCESS_TOKEN: access_token,
+                COOKIE_NAME_REFRESH_TOKEN: "refresh_token",
+            },
+        ).get("/api/v2/auth/logout")
+
+        set_cookie_headers = response.headers.get_list("set-cookie")
+        assert len(set_cookie_headers) == 3
+        print(f"Headers: {set_cookie_headers}")
+        assert "new_token" not in set_cookie_headers[0]
+        assert access_token not in set_cookie_headers[1]
+        assert "new_refresh_token" not in set_cookie_headers[2]

Review Comment:
   The headers here are `[_access_token, _refresh_token, _token]`, so these 
checks look at the wrong cookie and pass even though 
`_refresh_token=new_refresh_token` is sent on logout. Can you assert on the 
cookie names instead of positions? Also, the `print` above should be removed.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to