jpsoron commited on
Commit
05ab07e
·
unverified ·
2 Parent(s): c9902ab01e0bb5

Merge pull request #16 from MateFerreyra/jps-auth-fix

Browse files
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 dos puntos nada
7
- más: (a) el canje del ticket SSO (`exchange_sso_ticket`, una vez por login),
8
- y (b) la cuenta de servicio para las llamadas salientes de M6 a M1/M2/M7.
9
- No hay verificación de JWT del Core por-request ni lookup de roles — el rol
10
- se resuelve una sola vez, en el canje, a partir de `user.roles[]` (ver
 
 
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
- # El rol del usuario se obtiene una única vez, en el canje SSO
159
- # (`user.roles[].name` de la respuesta de `/auth/sso-exchange` —
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[]`. El JWT del Core (`token`) queda embebido como claim opaco
 
 
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` lo traduce con esta tabla:
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 lookup aparte (`GET /roles`, `GET /users/{id}`) ni verificación de JWT del Core por-request: todo se resuelve **una sola vez**, en el canje. 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,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 ni lookup aparte de roles — el Core se toca una sola vez, en el canje. Detalle técnico completo en `M6_DISEÑO.md §11`; resumen:
114
 
115
- - La respuesta del canje (`models.AuthResponse` del Core) trae `user.roles[]` — cada rol con su `name`. De ahí sale el rol del usuario, **sin** `GET /roles` ni `GET /users/{id}`.
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 y el lookup de roles (`GET /roles`)
6
- se eliminaron: la sesión de M6 es siempre un JWT HS256 propio, y el rol se
7
- resuelve una única vez en el canje SSO (ver `tests/test_sso.py`), a partir
8
- de `user.roles[]`. Este módulo cubre exclusivamente lo que sigue vigente:
9
- la traducción de nombres de rol de Core a rol interno de M6.
 
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