Spaces:
Runtime error
Runtime error
SSO and auth fix
Browse files- app/integrations/core_auth.py +63 -13
- app/routers/auth.py +19 -1
- documentation/M6_AUTH_SSO.md +1 -1
- documentation/M6_DISEÑO.md +25 -1
- documentation/roles.md +2 -2
- tests/test_core_auth.py +70 -6
- tests/test_sso.py +71 -0
app/integrations/core_auth.py
CHANGED
|
@@ -3,11 +3,13 @@ M10 Core — integración de autenticación real: canje de ticket SSO y cuenta
|
|
| 3 |
de servicio de M6.
|
| 4 |
|
| 5 |
La sesión de M6 es siempre un JWT HS256 propio (`app/dependencies.py`,
|
| 6 |
-
`create_access_token`/`decode_token`). El Core se toca en
|
| 7 |
-
|
| 8 |
-
|
| 9 |
-
|
| 10 |
-
|
|
|
|
|
|
|
| 11 |
`app/routers/auth.py`).
|
| 12 |
"""
|
| 13 |
import logging
|
|
@@ -153,16 +155,64 @@ def _login_service_account() -> str | None:
|
|
| 153 |
return token
|
| 154 |
|
| 155 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 156 |
# ─── Mapeo de rol de Core → rol interno de M6 ──────────────────────────────
|
| 157 |
|
| 158 |
-
#
|
| 159 |
-
#
|
| 160 |
-
# `models.AuthResponse` → `models.User` → `models.Role`, ver
|
| 161 |
-
# `documentation/M10_openapi.yaml`). No hay lookup aparte (`GET /roles`) ni
|
| 162 |
-
# verificación de JWT del Core por-request: la sesión de M6 es siempre el
|
| 163 |
-
# JWT HS256 propio emitido en `app/routers/auth.py`. Este mapeo es la única
|
| 164 |
-
# fuente de la verdad de qué rol de Core habilita qué rol interno de M6;
|
| 165 |
-
# ajustar acá si cambian los nombres en el Core compartido.
|
| 166 |
CORE_ROLE_TO_INTERNAL: dict[str, str] = {
|
| 167 |
"admin_internacion": "ADMINISTRATIVO",
|
| 168 |
"admin": "ADMINISTRATIVO", # super-admin del Core — a confirmar con el equipo M10
|
|
|
|
| 3 |
de servicio de M6.
|
| 4 |
|
| 5 |
La sesión de M6 es siempre un JWT HS256 propio (`app/dependencies.py`,
|
| 6 |
+
`create_access_token`/`decode_token`). El Core se toca en estos puntos:
|
| 7 |
+
(a) el canje del ticket SSO (`exchange_sso_ticket`, una vez por login),
|
| 8 |
+
(b) la cuenta de servicio para las llamadas salientes de M6 a M1/M2/M7, y
|
| 9 |
+
(c) el fallback de roles (`resolve_user_roles`, vía `GET /roles`) cuando el
|
| 10 |
+
canje no trae `user.roles[]` poblado — el Core desplegado no siempre lo
|
| 11 |
+
puebla, pese a que el schema lo permite. No hay verificación de JWT del Core
|
| 12 |
+
por-request: el rol se resuelve una sola vez, en el canje (ver
|
| 13 |
`app/routers/auth.py`).
|
| 14 |
"""
|
| 15 |
import logging
|
|
|
|
| 155 |
return token
|
| 156 |
|
| 157 |
|
| 158 |
+
# ─── Resolución de rol (fallback: lookup de GET /roles) ────────────────────
|
| 159 |
+
|
| 160 |
+
# El rol del usuario se intenta primero desde `user.roles[].name` de la
|
| 161 |
+
# respuesta de `/auth/sso-exchange` (`models.AuthResponse` → `models.User` →
|
| 162 |
+
# `models.Role`, ver `documentation/M10_openapi.yaml`). En la práctica el Core
|
| 163 |
+
# desplegado no puebla ese campo en el canje SSO, así que `app/routers/auth.py`
|
| 164 |
+
# cae a `resolve_user_roles` cuando viene vacío. Reintroducido — existió antes
|
| 165 |
+
# y se había retirado asumiendo (incorrectamente, contra el Core real) que
|
| 166 |
+
# `roles[]` siempre venía en el canje.
|
| 167 |
+
#
|
| 168 |
+
# `GET /users/{id}` sería lo obvio para resolver roles por id de usuario, pero
|
| 169 |
+
# exige permiso `users:read` que la cuenta de servicio de M6 no tiene. Tampoco
|
| 170 |
+
# hay un endpoint user-id→roles (`/roles/{id}` toma un **role** id;
|
| 171 |
+
# `/users/{id}/roles` sólo expone POST/DELETE). Lo único legible por la cuenta
|
| 172 |
+
# de servicio es `GET /roles` (permiso `roles:read`), que devuelve cada rol
|
| 173 |
+
# con su `users[]` embebido — de ahí se arma un índice `user_id → [roles]`.
|
| 174 |
+
_roles_index_cache: dict = {"user_id_to_roles": {}, "fetched_at": 0.0}
|
| 175 |
+
|
| 176 |
+
|
| 177 |
+
def _fetch_roles_index() -> dict[int, list[str]]:
|
| 178 |
+
"""Índice `user_id -> [nombres de rol]` armado desde `GET /roles` (paginado
|
| 179 |
+
en una sola página grande), autenticado con la cuenta de servicio de M6."""
|
| 180 |
+
token = get_service_token()
|
| 181 |
+
headers = {"Authorization": f"Bearer {token}"} if token else {}
|
| 182 |
+
url = f"{settings.m10_core_url}/roles"
|
| 183 |
+
r = httpx.get(
|
| 184 |
+
url, headers=headers, params={"pageSize": 200}, timeout=settings.http_timeout_seconds
|
| 185 |
+
)
|
| 186 |
+
r.raise_for_status()
|
| 187 |
+
data = r.json()
|
| 188 |
+
|
| 189 |
+
index: dict[int, list[str]] = {}
|
| 190 |
+
for role in data.get("data", []):
|
| 191 |
+
name = role.get("name")
|
| 192 |
+
for user in role.get("users") or []:
|
| 193 |
+
uid = user.get("id")
|
| 194 |
+
if uid is None or name is None:
|
| 195 |
+
continue
|
| 196 |
+
index.setdefault(uid, []).append(name)
|
| 197 |
+
return index
|
| 198 |
+
|
| 199 |
+
|
| 200 |
+
def resolve_user_roles(user_id: int) -> list[str]:
|
| 201 |
+
"""
|
| 202 |
+
Nombres de rol de Core asignados a `user_id`, vía `GET /roles` (fallback
|
| 203 |
+
cuando el canje SSO no trae `user.roles[]`). Sin cache: se llama sólo
|
| 204 |
+
cuando falta el dato en el canje, que ya de por sí ocurre una vez por
|
| 205 |
+
login — no vale la pena la complejidad de un TTL para esta frecuencia.
|
| 206 |
+
Propaga la excepción de red/HTTP al llamador (`app/routers/auth.py`),
|
| 207 |
+
que la traduce a `502`.
|
| 208 |
+
"""
|
| 209 |
+
return _fetch_roles_index().get(user_id, [])
|
| 210 |
+
|
| 211 |
+
|
| 212 |
# ─── Mapeo de rol de Core → rol interno de M6 ──────────────────────────────
|
| 213 |
|
| 214 |
+
# Este mapeo es la única fuente de la verdad de qué rol de Core habilita qué
|
| 215 |
+
# rol interno de M6; ajustar acá si cambian los nombres en el Core compartido.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 216 |
CORE_ROLE_TO_INTERNAL: dict[str, str] = {
|
| 217 |
"admin_internacion": "ADMINISTRATIVO",
|
| 218 |
"admin": "ADMINISTRATIVO", # super-admin del Core — a confirmar con el equipo M10
|
app/routers/auth.py
CHANGED
|
@@ -5,7 +5,9 @@ SSO del Core (M10): canje de ticket por una sesión propia de M6, en ambos senti
|
|
| 5 |
(`/auth/sso?ticket=…`, responsabilidad del frontend) — este router expone solo el
|
| 6 |
canje server-to-server: recibe el ticket, lo intercambia contra el Core por
|
| 7 |
`{user, token}` y emite su propio JWT HS256 con el rol ya resuelto a partir de
|
| 8 |
-
`user.roles[]`
|
|
|
|
|
|
|
| 9 |
(`core_token`) dentro del JWT de M6 — no se descarta del todo, se guarda solo para
|
| 10 |
poder pedir tickets salientes más adelante (ver abajo). Un JWT es firmado, no
|
| 11 |
cifrado: ese claim es legible por quien tenga el JWT de M6, incluido el frontend —
|
|
@@ -87,6 +89,22 @@ def sso_exchange(data: SSOExchangeRequest):
|
|
| 87 |
user_id, user_email, role_names,
|
| 88 |
)
|
| 89 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 90 |
rol = core_auth.map_core_roles_to_internal(role_names)
|
| 91 |
if rol is None:
|
| 92 |
logger.warning(
|
|
|
|
| 5 |
(`/auth/sso?ticket=…`, responsabilidad del frontend) — este router expone solo el
|
| 6 |
canje server-to-server: recibe el ticket, lo intercambia contra el Core por
|
| 7 |
`{user, token}` y emite su propio JWT HS256 con el rol ya resuelto a partir de
|
| 8 |
+
`user.roles[]` — o, si el Core no lo pobló en la respuesta del canje (pasa en la
|
| 9 |
+
práctica), vía `core_auth.resolve_user_roles` (fallback, `GET /roles` con la cuenta
|
| 10 |
+
de servicio). El JWT del Core (`token`) queda embebido como claim opaco
|
| 11 |
(`core_token`) dentro del JWT de M6 — no se descarta del todo, se guarda solo para
|
| 12 |
poder pedir tickets salientes más adelante (ver abajo). Un JWT es firmado, no
|
| 13 |
cifrado: ese claim es legible por quien tenga el JWT de M6, incluido el frontend —
|
|
|
|
| 89 |
user_id, user_email, role_names,
|
| 90 |
)
|
| 91 |
|
| 92 |
+
if not role_names and user_id is not None:
|
| 93 |
+
# El canje SSO no trajo `user.roles[]` poblado (pasa con el Core real
|
| 94 |
+
# pese a que el schema lo permite) — fallback: resolverlos vía
|
| 95 |
+
# `GET /roles` con la cuenta de servicio (`core_auth.resolve_user_roles`).
|
| 96 |
+
try:
|
| 97 |
+
role_names = core_auth.resolve_user_roles(user_id)
|
| 98 |
+
logger.info(
|
| 99 |
+
"roles_core vacío en el canje — resuelto vía GET /roles — user_id=%s roles=%s",
|
| 100 |
+
user_id, role_names,
|
| 101 |
+
)
|
| 102 |
+
except Exception as e:
|
| 103 |
+
logger.warning(
|
| 104 |
+
"Fallback de roles (GET /roles) falló — user_id=%s error=%s", user_id, e,
|
| 105 |
+
)
|
| 106 |
+
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=_ERROR_502)
|
| 107 |
+
|
| 108 |
rol = core_auth.map_core_roles_to_internal(role_names)
|
| 109 |
if rol is None:
|
| 110 |
logger.warning(
|
documentation/M6_AUTH_SSO.md
CHANGED
|
@@ -120,7 +120,7 @@ El body de error va anidado bajo `detail` (comportamiento por defecto de FastAPI
|
|
| 120 |
|
| 121 |
El JWT del Core **no** trae el nombre del rol — sus claims son `{user_id, permissions[], iat, exp}`, y esos `permissions[]` son de recursos propios del Core, no de M6.
|
| 122 |
|
| 123 |
-
El rol se resuelve **una sola vez, en el canje**, a partir de `user.roles[]` de la respuesta de `/auth/sso-exchange` del Core (cada rol con su `name`). `app/integrations/core_auth.py::map_core_roles_to_internal`
|
| 124 |
|
| 125 |
| Rol en el Core | Rol interno de M6 |
|
| 126 |
|---|---|
|
|
|
|
| 120 |
|
| 121 |
El JWT del Core **no** trae el nombre del rol — sus claims son `{user_id, permissions[], iat, exp}`, y esos `permissions[]` son de recursos propios del Core, no de M6.
|
| 122 |
|
| 123 |
+
El rol se resuelve **una sola vez, en el canje**, a partir de `user.roles[]` de la respuesta de `/auth/sso-exchange` del Core (cada rol con su `name`) — **cuando el Core lo puebla**. En la práctica el Core desplegado no siempre lo trae, así que `app/routers/auth.py::sso_exchange` cae a un fallback: `core_auth.resolve_user_roles(user_id)`, que arma un índice `user_id → roles` desde `GET /roles` del Core, autenticado con la cuenta de servicio de M6 (`get_service_token`). Es el único endpoint de roles que esa cuenta puede leer — `GET /users/{id}` exige el permiso `users:read`, que no tiene. `app/integrations/core_auth.py::map_core_roles_to_internal` traduce el resultado (venga de una vía o de la otra) con esta tabla:
|
| 124 |
|
| 125 |
| Rol en el Core | Rol interno de M6 |
|
| 126 |
|---|---|
|
documentation/M6_DISEÑO.md
CHANGED
|
@@ -430,7 +430,7 @@ Login centralizado en el Core (M10) vía **SSO**, integrado (no mockeado). La se
|
|
| 430 |
| `admin` | `ADMINISTRATIVO` (super-admin del Core) |
|
| 431 |
| cualquier otro / ninguno | sin acceso a M6 → `403` en el canje |
|
| 432 |
|
| 433 |
-
No hay
|
| 434 |
|
| 435 |
**Llamadas salientes:** una cuenta de servicio propia (`core_auth.get_service_token`, login contra `POST /auth/login` del Core) autentica las llamadas de M6 a M1/M2/M7/M10 (adjuntado automático en `app/integrations/_base.py::_headers`), incluidas las disparadas por webhooks entrantes donde no hay usuario humano. Es independiente del flujo SSO — se habilita con `CORE_SERVICE_EMAIL`/`CORE_SERVICE_PASSWORD`.
|
| 436 |
|
|
@@ -568,3 +568,27 @@ encontraron 3 desvíos reales del contrato, corregidos en `app/integrations/fact
|
|
| 568 |
del listado de campos que confirmó M7 ni del que documenta el changelog #39 de esta misma
|
| 569 |
sección — `camasUtilizadas` existía solo para alimentar una reconstrucción de tramos vía
|
| 570 |
`auditoria` (`_reconstruir_tramos`/`_tramo_desde_cama`, eliminadas) que M7 nunca pidió.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 430 |
| `admin` | `ADMINISTRATIVO` (super-admin del Core) |
|
| 431 |
| cualquier otro / ninguno | sin acceso a M6 → `403` en el canje |
|
| 432 |
|
| 433 |
+
No hay verificación de JWT del Core por-request: todo se resuelve **una sola vez**, en el canje — a partir de `user.roles[]` si el Core lo puebla, o si no vía el fallback `GET /roles` (ver §14.11). M6 emite entonces su propio JWT HS256 (`create_access_token(sub=str(user_id), rol=rol)`) y lo devuelve junto con el rol y los datos básicos del usuario. `get_current_user` (`app/dependencies.py`) valida ese token localmente en cada request — misma forma `{"sub", "rol"}` de siempre; `require_roles`, la auditoría y los routers no cambiaron.
|
| 434 |
|
| 435 |
**Llamadas salientes:** una cuenta de servicio propia (`core_auth.get_service_token`, login contra `POST /auth/login` del Core) autentica las llamadas de M6 a M1/M2/M7/M10 (adjuntado automático en `app/integrations/_base.py::_headers`), incluidas las disparadas por webhooks entrantes donde no hay usuario humano. Es independiente del flujo SSO — se habilita con `CORE_SERVICE_EMAIL`/`CORE_SERVICE_PASSWORD`.
|
| 436 |
|
|
|
|
| 568 |
del listado de campos que confirmó M7 ni del que documenta el changelog #39 de esta misma
|
| 569 |
sección — `camasUtilizadas` existía solo para alimentar una reconstrucción de tramos vía
|
| 570 |
`auditoria` (`_reconstruir_tramos`/`_tramo_desde_cama`, eliminadas) que M7 nunca pidió.
|
| 571 |
+
|
| 572 |
+
### 14.11 Reintroducción del lookup de roles (2026-07)
|
| 573 |
+
|
| 574 |
+
Una prueba end-to-end contra el Core real (login → ticket → `sso-exchange`) reveló que
|
| 575 |
+
`user.roles[]` viene **vacío** en la respuesta del canje SSO, pese a que el schema del Core lo
|
| 576 |
+
declara (`models.User.roles[]`) — contradiciendo el supuesto del changelog #27, que asumió que
|
| 577 |
+
siempre venía poblado y en base a eso eliminó el lookup aparte. Resultado antes del fix: **todo**
|
| 578 |
+
usuario recibía `403` en `sso-exchange`.
|
| 579 |
+
|
| 580 |
+
48. **`core_auth.resolve_user_roles`/`_fetch_roles_index` reintroducidos** (habían sido
|
| 581 |
+
retirados en #27), como **fallback**: `app/routers/auth.py::sso_exchange` solo los invoca
|
| 582 |
+
cuando `user.roles[]` viene vacío en el canje, no en reemplazo del camino feliz. Si el Core
|
| 583 |
+
algún día puebla `roles[]` en el canje, el fallback deja de dispararse sin más cambios.
|
| 584 |
+
49. **Fuente del fallback: `GET /roles`, no `GET /users/{id}`.** `GET /users/{id}` sería la
|
| 585 |
+
opción obvia por id de usuario, pero exige el permiso `users:read`, que la cuenta de
|
| 586 |
+
servicio de M6 no tiene. Tampoco existe un endpoint directo user-id→roles en el Core
|
| 587 |
+
(`/roles/{id}` toma un **role** id, no un user id; `/users/{id}/roles` solo expone
|
| 588 |
+
POST/DELETE). Lo único legible por la cuenta de servicio es `GET /roles` (permiso
|
| 589 |
+
`roles:read`), que devuelve cada rol con su `users[]` embebido — de ahí se arma un índice
|
| 590 |
+
`user_id → [roles]` en memoria, sin cache (se llama sólo en el fallback, ya de por sí poco
|
| 591 |
+
frecuente).
|
| 592 |
+
50. **No se reintroducen** `verify_core_token`/`get_signing_key` ni sus caches
|
| 593 |
+
(`jwks_cache_ttl_seconds`) — esa parte de #27 seguía siendo correcta: no hay verificación de
|
| 594 |
+
JWT del Core por-request, la sesión de M6 sigue siendo siempre HS256 propia.
|
documentation/roles.md
CHANGED
|
@@ -110,9 +110,9 @@ Los tests de autorización por rol viven junto a los tests de cada router (`test
|
|
| 110 |
|
| 111 |
## 6. Integración con el Core (M10): SSO
|
| 112 |
|
| 113 |
-
La sesión de M6 es **siempre** un JWT HS256 propio (`app/dependencies.py::create_access_token`/`decode_token`). Lo que agrega la integración con el Core es una forma de *adquirirlo*: `POST /api/v1/auth/sso-exchange` (`app/routers/auth.py`, activo con `SSO_ENABLED=true`) canjea un ticket de un solo uso emitido por el Core (`POST /auth/sso-ticket` en el Core) contra `POST /auth/sso-exchange` del Core, y devuelve un JWT de M6 con el rol ya resuelto. No hay verificación de JWT del Core por-request
|
| 114 |
|
| 115 |
-
- La respuesta del canje (`models.AuthResponse` del Core)
|
| 116 |
- Mapeo Core → M6 (`CORE_ROLE_TO_INTERNAL` en `core_auth.py::map_core_roles_to_internal`): roles de Core `admin_internacion` → `ADMINISTRATIVO`, `Medico` → `MEDICO`, `limpieza` → `LIMPIEZA`, `admin` → `ADMINISTRATIVO`. Si ninguno de los roles del usuario mapea, el canje devuelve `403` (no entra a M6).
|
| 117 |
- `require_roles`, la capa de servicio y la auditoría no cambiaron — siguen leyendo `payload["rol"]` del JWT de M6, sin distinguir si la sesión se originó por SSO o por el endpoint de desarrollo (`/api/v1/auth/token`).
|
| 118 |
- El callback del browser (`/auth/sso?ticket=…&redirect=…`) y la validación anti-open-redirect del `redirect` son responsabilidad del **frontend**, no de este backend.
|
|
|
|
| 110 |
|
| 111 |
## 6. Integración con el Core (M10): SSO
|
| 112 |
|
| 113 |
+
La sesión de M6 es **siempre** un JWT HS256 propio (`app/dependencies.py::create_access_token`/`decode_token`). Lo que agrega la integración con el Core es una forma de *adquirirlo*: `POST /api/v1/auth/sso-exchange` (`app/routers/auth.py`, activo con `SSO_ENABLED=true`) canjea un ticket de un solo uso emitido por el Core (`POST /auth/sso-ticket` en el Core) contra `POST /auth/sso-exchange` del Core, y devuelve un JWT de M6 con el rol ya resuelto. No hay verificación de JWT del Core por-request — el Core se toca en el canje y, si hace falta, en el fallback de roles. Detalle técnico completo en `M6_DISEÑO.md §11`; resumen:
|
| 114 |
|
| 115 |
+
- La respuesta del canje (`models.AuthResponse` del Core) debería traer `user.roles[]` — cada rol con su `name` — y de ahí sale el rol del usuario. En la práctica el Core desplegado no siempre lo puebla; cuando viene vacío, `app/routers/auth.py::sso_exchange` cae a `core_auth.resolve_user_roles(user_id)`, que arma un índice `user_id → roles` desde `GET /roles` (autenticado con la cuenta de servicio de M6 — es lo único que esa cuenta puede leer; `GET /users/{id}` exige `users:read`, que no tiene).
|
| 116 |
- Mapeo Core → M6 (`CORE_ROLE_TO_INTERNAL` en `core_auth.py::map_core_roles_to_internal`): roles de Core `admin_internacion` → `ADMINISTRATIVO`, `Medico` → `MEDICO`, `limpieza` → `LIMPIEZA`, `admin` → `ADMINISTRATIVO`. Si ninguno de los roles del usuario mapea, el canje devuelve `403` (no entra a M6).
|
| 117 |
- `require_roles`, la capa de servicio y la auditoría no cambiaron — siguen leyendo `payload["rol"]` del JWT de M6, sin distinguir si la sesión se originó por SSO o por el endpoint de desarrollo (`/api/v1/auth/token`).
|
| 118 |
- El callback del browser (`/auth/sso?ticket=…&redirect=…`) y la validación anti-open-redirect del `redirect` son responsabilidad del **frontend**, no de este backend.
|
tests/test_core_auth.py
CHANGED
|
@@ -1,13 +1,15 @@
|
|
| 1 |
"""
|
| 2 |
Tests de `app/integrations/core_auth.py`: mapeo de roles del Core al rol
|
| 3 |
-
interno de M6.
|
| 4 |
|
| 5 |
-
La verificación de JWT del Core vía JWKS
|
| 6 |
-
|
| 7 |
-
resuelve
|
| 8 |
-
|
| 9 |
-
|
|
|
|
| 10 |
"""
|
|
|
|
| 11 |
import pytest
|
| 12 |
|
| 13 |
from app.integrations import core_auth
|
|
@@ -30,3 +32,65 @@ from app.integrations import core_auth
|
|
| 30 |
)
|
| 31 |
def test_map_core_roles_to_internal(role_names, expected):
|
| 32 |
assert core_auth.map_core_roles_to_internal(role_names) == expected
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
"""
|
| 2 |
Tests de `app/integrations/core_auth.py`: mapeo de roles del Core al rol
|
| 3 |
+
interno de M6, y el fallback de resolución de roles vía `GET /roles`.
|
| 4 |
|
| 5 |
+
La verificación de JWT del Core vía JWKS (`verify_core_token`/`get_signing_key`)
|
| 6 |
+
sigue eliminada: la sesión de M6 es siempre un JWT HS256 propio. El rol se
|
| 7 |
+
resuelve en el canje SSO (ver `tests/test_sso.py`), primero desde
|
| 8 |
+
`user.roles[]` y, si viene vacío, vía `resolve_user_roles`/`_fetch_roles_index`
|
| 9 |
+
— reintroducidos porque el Core real no siempre puebla `user.roles[]` en el
|
| 10 |
+
canje (ver `M6_DISEÑO.md` §14.11).
|
| 11 |
"""
|
| 12 |
+
import httpx
|
| 13 |
import pytest
|
| 14 |
|
| 15 |
from app.integrations import core_auth
|
|
|
|
| 32 |
)
|
| 33 |
def test_map_core_roles_to_internal(role_names, expected):
|
| 34 |
assert core_auth.map_core_roles_to_internal(role_names) == expected
|
| 35 |
+
|
| 36 |
+
|
| 37 |
+
# ─── Fallback de roles: GET /roles con la cuenta de servicio ───────────────
|
| 38 |
+
|
| 39 |
+
|
| 40 |
+
def _roles_list_response(payload: dict) -> httpx.Response:
|
| 41 |
+
return httpx.Response(200, json=payload, request=httpx.Request("GET", "http://core/roles"))
|
| 42 |
+
|
| 43 |
+
|
| 44 |
+
def test_fetch_roles_index_arma_indice_desde_users_embebidos(monkeypatch):
|
| 45 |
+
monkeypatch.setattr(core_auth, "get_service_token", lambda: "service-token")
|
| 46 |
+
|
| 47 |
+
payload = {
|
| 48 |
+
"data": [
|
| 49 |
+
{"id": 1, "name": "admin_internacion", "users": [{"id": 42}, {"id": 43}]},
|
| 50 |
+
{"id": 2, "name": "Medico", "users": [{"id": 43}]},
|
| 51 |
+
{"id": 3, "name": "sin_usuarios", "users": []},
|
| 52 |
+
]
|
| 53 |
+
}
|
| 54 |
+
monkeypatch.setattr(httpx, "get", lambda *a, **k: _roles_list_response(payload))
|
| 55 |
+
|
| 56 |
+
index = core_auth._fetch_roles_index()
|
| 57 |
+
|
| 58 |
+
assert index == {42: ["admin_internacion"], 43: ["admin_internacion", "Medico"]}
|
| 59 |
+
|
| 60 |
+
|
| 61 |
+
def test_fetch_roles_index_usa_el_token_de_servicio(monkeypatch):
|
| 62 |
+
monkeypatch.setattr(core_auth, "get_service_token", lambda: "mi-token")
|
| 63 |
+
received = {}
|
| 64 |
+
|
| 65 |
+
def _fake_get(url, headers=None, params=None, timeout=None):
|
| 66 |
+
received["url"] = url
|
| 67 |
+
received["headers"] = headers
|
| 68 |
+
received["params"] = params
|
| 69 |
+
return _roles_list_response({"data": []})
|
| 70 |
+
|
| 71 |
+
monkeypatch.setattr(httpx, "get", _fake_get)
|
| 72 |
+
|
| 73 |
+
core_auth._fetch_roles_index()
|
| 74 |
+
|
| 75 |
+
assert received["headers"] == {"Authorization": "Bearer mi-token"}
|
| 76 |
+
assert received["url"].endswith("/roles")
|
| 77 |
+
assert received["params"] == {"pageSize": 200}
|
| 78 |
+
|
| 79 |
+
|
| 80 |
+
def test_resolve_user_roles_devuelve_vacio_si_no_esta_en_el_indice(monkeypatch):
|
| 81 |
+
monkeypatch.setattr(core_auth, "_fetch_roles_index", lambda: {42: ["Medico"]})
|
| 82 |
+
|
| 83 |
+
assert core_auth.resolve_user_roles(999) == []
|
| 84 |
+
assert core_auth.resolve_user_roles(42) == ["Medico"]
|
| 85 |
+
|
| 86 |
+
|
| 87 |
+
def test_fetch_roles_index_propaga_error_http(monkeypatch):
|
| 88 |
+
monkeypatch.setattr(core_auth, "get_service_token", lambda: "service-token")
|
| 89 |
+
|
| 90 |
+
def _fake_get(*a, **k):
|
| 91 |
+
return httpx.Response(500, request=httpx.Request("GET", "http://core/roles"))
|
| 92 |
+
|
| 93 |
+
monkeypatch.setattr(httpx, "get", _fake_get)
|
| 94 |
+
|
| 95 |
+
with pytest.raises(httpx.HTTPStatusError):
|
| 96 |
+
core_auth._fetch_roles_index()
|
tests/test_sso.py
CHANGED
|
@@ -101,6 +101,77 @@ def test_sso_exchange_rol_no_mapeado_403(client, monkeypatch, sso_enabled):
|
|
| 101 |
assert resp.json()["detail"]["codigo"] == "NO_AUTORIZADO"
|
| 102 |
|
| 103 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 104 |
def test_sso_exchange_ticket_vacio_422(client, sso_enabled):
|
| 105 |
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": ""})
|
| 106 |
|
|
|
|
| 101 |
assert resp.json()["detail"]["codigo"] == "NO_AUTORIZADO"
|
| 102 |
|
| 103 |
|
| 104 |
+
# ─── Fallback de roles (GET /roles) cuando `user.roles[]` viene vacío ──────
|
| 105 |
+
# El Core real no siempre puebla `user.roles[]` en la respuesta del canje SSO
|
| 106 |
+
# (ver changelog #48 en M6_DISEÑO.md §14.11) — `sso_exchange` cae entonces a
|
| 107 |
+
# `core_auth.resolve_user_roles`, que resuelve vía `GET /roles`.
|
| 108 |
+
|
| 109 |
+
|
| 110 |
+
def test_sso_exchange_roles_vacio_usa_fallback(client, monkeypatch, sso_enabled):
|
| 111 |
+
monkeypatch.setattr(
|
| 112 |
+
core_auth,
|
| 113 |
+
"exchange_sso_ticket",
|
| 114 |
+
lambda ticket: {"user": _core_user([], user_id=7), "token": "core-jwt"},
|
| 115 |
+
)
|
| 116 |
+
monkeypatch.setattr(core_auth, "resolve_user_roles", lambda user_id: ["Medico"])
|
| 117 |
+
|
| 118 |
+
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "un-ticket"})
|
| 119 |
+
|
| 120 |
+
assert resp.status_code == 200
|
| 121 |
+
assert resp.json()["rol"] == "MEDICO"
|
| 122 |
+
|
| 123 |
+
|
| 124 |
+
def test_sso_exchange_roles_vacio_fallback_tambien_vacio_403(client, monkeypatch, sso_enabled):
|
| 125 |
+
monkeypatch.setattr(
|
| 126 |
+
core_auth,
|
| 127 |
+
"exchange_sso_ticket",
|
| 128 |
+
lambda ticket: {"user": _core_user([], user_id=8), "token": "core-jwt"},
|
| 129 |
+
)
|
| 130 |
+
monkeypatch.setattr(core_auth, "resolve_user_roles", lambda user_id: [])
|
| 131 |
+
|
| 132 |
+
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "un-ticket"})
|
| 133 |
+
|
| 134 |
+
assert resp.status_code == 403
|
| 135 |
+
assert resp.json()["detail"]["codigo"] == "NO_AUTORIZADO"
|
| 136 |
+
|
| 137 |
+
|
| 138 |
+
def test_sso_exchange_roles_no_vacio_no_usa_fallback(client, monkeypatch, sso_enabled):
|
| 139 |
+
"""Si el canje ya trae roles, no se llama al fallback (camino feliz sin tocar el Core de nuevo)."""
|
| 140 |
+
monkeypatch.setattr(
|
| 141 |
+
core_auth,
|
| 142 |
+
"exchange_sso_ticket",
|
| 143 |
+
lambda ticket: {"user": _core_user(["admin_internacion"]), "token": "core-jwt"},
|
| 144 |
+
)
|
| 145 |
+
|
| 146 |
+
def _fail(user_id):
|
| 147 |
+
raise AssertionError("no debería llamarse: user.roles[] ya vino poblado")
|
| 148 |
+
|
| 149 |
+
monkeypatch.setattr(core_auth, "resolve_user_roles", _fail)
|
| 150 |
+
|
| 151 |
+
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "un-ticket"})
|
| 152 |
+
|
| 153 |
+
assert resp.status_code == 200
|
| 154 |
+
assert resp.json()["rol"] == "ADMINISTRATIVO"
|
| 155 |
+
|
| 156 |
+
|
| 157 |
+
def test_sso_exchange_fallback_de_roles_falla_502(client, monkeypatch, sso_enabled):
|
| 158 |
+
monkeypatch.setattr(
|
| 159 |
+
core_auth,
|
| 160 |
+
"exchange_sso_ticket",
|
| 161 |
+
lambda ticket: {"user": _core_user([], user_id=11), "token": "core-jwt"},
|
| 162 |
+
)
|
| 163 |
+
|
| 164 |
+
def _raise(user_id):
|
| 165 |
+
raise core_auth.SSOExchangeError("timeout en GET /roles")
|
| 166 |
+
|
| 167 |
+
monkeypatch.setattr(core_auth, "resolve_user_roles", _raise)
|
| 168 |
+
|
| 169 |
+
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": "un-ticket"})
|
| 170 |
+
|
| 171 |
+
assert resp.status_code == 502
|
| 172 |
+
assert resp.json()["detail"]["codigo"] == "SERVICIO_EXTERNO_NO_DISPONIBLE"
|
| 173 |
+
|
| 174 |
+
|
| 175 |
def test_sso_exchange_ticket_vacio_422(client, sso_enabled):
|
| 176 |
resp = client.post("/api/v1/auth/sso-exchange", json={"ticket": ""})
|
| 177 |
|