juampisor commited on
Commit
5cd3cff
·
1 Parent(s): 9f05894

Implementacion action para tick de cirugias

Browse files
.env.example CHANGED
@@ -61,3 +61,11 @@ INTERNACION_REQUESTS_QUEUE=internacion.requests
61
  # MONITOREO_ALTA_EVENT_TYPE_ID=
62
  # MONITOREO_BAJA_EVENT_TYPE_ID=
63
  # FACTURACION_CAMA_LISTA_EVENT_TYPE_ID=
 
 
 
 
 
 
 
 
 
61
  # MONITOREO_ALTA_EVENT_TYPE_ID=
62
  # MONITOREO_BAJA_EVENT_TYPE_ID=
63
  # FACTURACION_CAMA_LISTA_EVENT_TYPE_ID=
64
+
65
+ # ─── Endpoint interno: auto-transición de reservas de quirófano ────────────
66
+ # POST /api/v1/internal/reservas/tick avanza RESERVADA→EN_CURSO→COMPLETADA
67
+ # según el horario de cada reserva. Lo llama un cron externo (GitHub
68
+ # Actions/cron-job.org), no un scheduler interno — ver M6_DISEÑO.md §5.4.
69
+ # Generar con: python -c "import secrets; print(secrets.token_hex(32))"
70
+ # Vacío por default: el endpoint rechaza todo (falla cerrado).
71
+ INTERNAL_TICK_SECRET=
.github/workflows/reservas-tick.yml ADDED
@@ -0,0 +1,15 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ name: Reservas Tick
2
+
3
+ on:
4
+ schedule:
5
+ - cron: "*/5 * * * *" # cada 5 min — mínimo práctico de GitHub Actions
6
+ workflow_dispatch: {} # permite disparar el tick a mano desde la pestaña Actions
7
+
8
+ jobs:
9
+ tick:
10
+ runs-on: ubuntu-latest
11
+ steps:
12
+ - name: POST /internal/reservas/tick
13
+ run: |
14
+ curl -sf -X POST "${{ vars.M6_URL }}/api/v1/internal/reservas/tick" \
15
+ -H "X-Internal-Token: ${{ secrets.M6_INTERNAL_TICK_SECRET }}"
app/config.py CHANGED
@@ -80,5 +80,15 @@ class Settings(BaseSettings):
80
  monitoreo_baja_event_type_id: int | None = None
81
  facturacion_cama_lista_event_type_id: int | None = None
82
 
 
 
 
 
 
 
 
 
 
 
83
 
84
  settings = Settings()
 
80
  monitoreo_baja_event_type_id: int | None = None
81
  facturacion_cama_lista_event_type_id: int | None = None
82
 
83
+ # ─── Endpoints internos (sistema, no usuario) ──────────────────────────
84
+ # POST /api/v1/internal/reservas/tick (app/routers/internal.py) avanza
85
+ # automáticamente RESERVADA→EN_CURSO→COMPLETADA según el horario de cada
86
+ # reserva de quirófano. No hay un usuario humano detrás de esa llamada (la
87
+ # dispara un cron externo, ver M6_DISEÑO.md §5.4) — se protege con este
88
+ # secreto compartido en vez de un JWT de sesión. Vacío por default: el
89
+ # endpoint rechaza todo (falla cerrado). Generar con
90
+ # `python -c "import secrets; print(secrets.token_hex(32))"`.
91
+ internal_tick_secret: str = ""
92
+
93
 
94
  settings = Settings()
app/crud/reserva.py CHANGED
@@ -107,6 +107,33 @@ def get_futuras(db: Client, cama_id: int, desde: datetime) -> list[ReservaQuirof
107
  return [ReservaQuirofano.from_dict(row) for row in resp.data]
108
 
109
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
110
  def get_activa_por_turno(db: Client, turno_id: int) -> ReservaQuirofano | None:
111
  resp = (
112
  db.table(_TABLE)
 
107
  return [ReservaQuirofano.from_dict(row) for row in resp.data]
108
 
109
 
110
+ def get_pendientes_de_inicio(db: Client, ahora: datetime) -> list[ReservaQuirofano]:
111
+ """Reservas `RESERVADA` cuyo horario de inicio ya llegó — candidatas a pasar a
112
+ `EN_CURSO` automáticamente. Una reserva `CANCELADA` nunca aparece acá: el filtro por
113
+ estado ya resuelve "si no se canceló, arranca sola" sin lógica adicional."""
114
+ resp = (
115
+ db.table(_TABLE)
116
+ .select("*")
117
+ .eq("estado", "RESERVADA")
118
+ .lte("fecha_hora_inicio", ahora.isoformat())
119
+ .execute()
120
+ )
121
+ return [ReservaQuirofano.from_dict(row) for row in resp.data]
122
+
123
+
124
+ def get_pendientes_de_fin(db: Client, ahora: datetime) -> list[ReservaQuirofano]:
125
+ """Reservas `EN_CURSO` cuyo horario de fin estimado ya llegó — candidatas a pasar a
126
+ `COMPLETADA` automáticamente."""
127
+ resp = (
128
+ db.table(_TABLE)
129
+ .select("*")
130
+ .eq("estado", "EN_CURSO")
131
+ .lte("fecha_hora_fin_estimada", ahora.isoformat())
132
+ .execute()
133
+ )
134
+ return [ReservaQuirofano.from_dict(row) for row in resp.data]
135
+
136
+
137
  def get_activa_por_turno(db: Client, turno_id: int) -> ReservaQuirofano | None:
138
  resp = (
139
  db.table(_TABLE)
app/main.py CHANGED
@@ -15,7 +15,7 @@ from app.config import settings
15
  from app.dependencies import create_access_token
16
  from app.integrations import rabbit_consumer
17
 
18
- from app.routers import auth, camas, quirofanos, solicitudes, webhooks, auditoria
19
  from app.routers.webhooks import router_turnos
20
 
21
  logger = logging.getLogger(__name__)
@@ -72,6 +72,7 @@ PREFIX = "/api/v1"
72
 
73
  app.include_router(auth.router, prefix=PREFIX)
74
  app.include_router(camas.router, prefix=PREFIX)
 
75
  app.include_router(quirofanos.router, prefix=PREFIX)
76
  app.include_router(solicitudes.router, prefix=PREFIX)
77
  app.include_router(webhooks.router, prefix=PREFIX)
 
15
  from app.dependencies import create_access_token
16
  from app.integrations import rabbit_consumer
17
 
18
+ from app.routers import auth, camas, internal, quirofanos, solicitudes, webhooks, auditoria
19
  from app.routers.webhooks import router_turnos
20
 
21
  logger = logging.getLogger(__name__)
 
72
 
73
  app.include_router(auth.router, prefix=PREFIX)
74
  app.include_router(camas.router, prefix=PREFIX)
75
+ app.include_router(internal.router, prefix=PREFIX)
76
  app.include_router(quirofanos.router, prefix=PREFIX)
77
  app.include_router(solicitudes.router, prefix=PREFIX)
78
  app.include_router(webhooks.router, prefix=PREFIX)
app/routers/internal.py ADDED
@@ -0,0 +1,43 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Endpoints internos: no hay un usuario humano detrás de estas llamadas, así que no usan
3
+ `get_current_user`/JWT de sesión — se protegen con un secreto compartido simple
4
+ (`settings.internal_tick_secret`).
5
+
6
+ `POST /internal/reservas/tick` avanza automáticamente el estado de las reservas de
7
+ quirófano según su horario (`RESERVADA → EN_CURSO → COMPLETADA`). Está pensado para que
8
+ lo dispare un cron externo (GitHub Actions, cron-job.org, etc.), no un scheduler en
9
+ memoria: el deploy de M6 (HF Spaces, tier gratuito) duerme el contenedor tras
10
+ inactividad, y un loop interno se congelaría con él. La propia request del cron despierta
11
+ el Space si estaba dormido. Ver `M6_DISEÑO.md` §5.4.
12
+ """
13
+ import secrets
14
+
15
+ from fastapi import APIRouter, Depends, Header, HTTPException, status
16
+ from supabase import Client
17
+
18
+ from app.config import settings
19
+ from app.dependencies import get_db
20
+ from app.services import cama_service
21
+
22
+ router = APIRouter(prefix="/internal", tags=["Internal"])
23
+
24
+ _ERROR_401 = {"codigo": "NO_AUTENTICADO", "mensaje": "Token interno ausente o inválido"}
25
+
26
+
27
+ def _verificar_token_interno(x_internal_token: str = Header(...)) -> None:
28
+ if not settings.internal_tick_secret or not secrets.compare_digest(
29
+ x_internal_token, settings.internal_tick_secret
30
+ ):
31
+ raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=_ERROR_401)
32
+
33
+
34
+ @router.post(
35
+ "/reservas/tick",
36
+ summary="Avanzar automáticamente el estado de reservas de quirófano según su horario",
37
+ responses={401: {"description": "Token interno ausente o inválido"}},
38
+ )
39
+ def tick_reservas(
40
+ db: Client = Depends(get_db),
41
+ _: None = Depends(_verificar_token_interno),
42
+ ):
43
+ return cama_service.procesar_transiciones_automaticas(db)
app/services/cama_service.py CHANGED
@@ -533,6 +533,41 @@ def update_reserva_estado(
533
  return reserva
534
 
535
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
536
  def get_disponibilidad_quirofanos(
537
  db: Client,
538
  desde: datetime,
 
533
  return reserva
534
 
535
 
536
+ def procesar_transiciones_automaticas(db: Client) -> dict:
537
+ """
538
+ Avanza automáticamente el estado de las reservas de quirófano según su horario:
539
+ `RESERVADA → EN_CURSO` al llegar `fecha_hora_inicio`, `EN_CURSO → COMPLETADA` al
540
+ llegar `fecha_hora_fin_estimada`. Pensado para dispararse desde un tick externo
541
+ (`app/routers/internal.py`), no desde un scheduler en memoria — ver `M6_DISEÑO.md`
542
+ §5.4 para el porqué.
543
+
544
+ Reusa `update_reserva_estado` tal cual: mismos side-effects que la transición manual
545
+ (cama a OCUPADA/EN_LIMPIEZA, auditoría). `actor=None` cae en el default ya existente
546
+ de `auditoria_crud.registrar` (rol SISTEMA, sin usuario humano detrás).
547
+
548
+ Que el filtro de origen (`reserva_crud.get_pendientes_de_inicio`) sea `estado=
549
+ RESERVADA` ya resuelve "si no se canceló, arranca sola": una reserva `CANCELADA`
550
+ nunca es candidata. Y como una reserva ya transicionada deja de matchear el filtro,
551
+ reintentar este tick (por ejemplo si el cron externo se solapa) es idempotente.
552
+ """
553
+ ahora = datetime.now(timezone.utc)
554
+
555
+ iniciadas = [
556
+ update_reserva_estado(
557
+ db, r.cama_id, r.id, ReservaEstadoUpdateRequest(estado=EstadoReservaEnum.EN_CURSO), actor=None,
558
+ )
559
+ for r in reserva_crud.get_pendientes_de_inicio(db, ahora)
560
+ ]
561
+ completadas = [
562
+ update_reserva_estado(
563
+ db, r.cama_id, r.id, ReservaEstadoUpdateRequest(estado=EstadoReservaEnum.COMPLETADA), actor=None,
564
+ )
565
+ for r in reserva_crud.get_pendientes_de_fin(db, ahora)
566
+ ]
567
+
568
+ return {"iniciadas": len(iniciadas), "completadas": len(completadas)}
569
+
570
+
571
  def get_disponibilidad_quirofanos(
572
  db: Client,
573
  desde: datetime,
documentation/M6_DISEÑO.md CHANGED
@@ -188,7 +188,13 @@ Si `origen = CIRUGIA_PROGRAMADA`, antes de aprobar se valida el turno quirúrgic
188
 
189
  ### 5.4 Cirugía programada
190
 
191
- `POST /quirofanos/{quirofanoId}/reservas` crea una reserva `PROGRAMADA` en estado `RESERVADA`. Disponibilidad consultable con `GET /quirofanos/disponibilidad?desde&hasta&specialty_id`. El estado se avanza con `PATCH /quirofanos/{quirofanoId}/reservas/{reservaId}` (`EN_CURSO`, `COMPLETADA`, `CANCELADA`).
 
 
 
 
 
 
192
 
193
  ### 5.5 Cirugía urgente con priorización ASAP
194
 
@@ -504,3 +510,8 @@ No hay lookup aparte (`GET /roles`, `GET /users/{id}`) ni verificación de JWT d
504
  33. **Eliminado `facturacion.notify_cierre_cama`.** Apuntaba a `POST /api/v1/webhooks/internacion/cierre-cama`, un endpoint que nunca estuvo en la tabla de webhooks salientes (§7.2) ni pasó por la revisión contra el backend real de M7 que sí tuvo `notify_cama_lista` (changelog #14). Estaba activamente cableada en `procesar_alta_medica` y era **bloqueante**: `if not facturacion.notify_cierre_cama(...): raise 502` — con `mock_external_services=False` en producción, cualquier alta médica real hubiera fallado con `502` contra un endpoint que M7 nunca implementó. Sin test para el camino real (pasaba siempre por el atajo de `mock_external_services=True`).
505
  34. **Corregido el gating bloqueante de `monitoreo.notify_baja` en `procesar_alta_medica`.** Era el único de los 5 call sites de `notify_alta`/`notify_baja` en todo el código que trataba la llamada como bloqueante (`if not ...: raise 502`); los otros 4 (`cama_service.py` ingreso/traslado, `solicitud_service.py` aprobar internación/traslado) ya la tratan fire-and-forget. Alineado con el resto del código y con el principio de §2 ("que el receptor esté caído no debe revertir el alta del paciente"): ahora es `monitoreo.notify_baja(paciente_id)` sin gate.
506
  35. **El alta médica ya no depende de M7 ni M9 para completarse.** La notificación real a M7 (`CAMA_LISTA`) sigue ocurriendo, fire-and-forget, más adelante en el flujo (al completar la limpieza, `cama_service.py`). Blindado con tests: `test_alta_medica_ok_aunque_monitoreo_falle` y `test_alta_medica_no_llama_a_facturacion` (`tests/test_webhooks.py`).
 
 
 
 
 
 
188
 
189
  ### 5.4 Cirugía programada
190
 
191
+ `POST /quirofanos/{quirofanoId}/reservas` crea una reserva `PROGRAMADA` en estado `RESERVADA`. Disponibilidad consultable con `GET /quirofanos/disponibilidad?desde&hasta&specialty_id`. El estado se avanza con `PATCH /quirofanos/{quirofanoId}/reservas/{reservaId}` (`EN_CURSO`, `COMPLETADA`, `CANCELADA`) — vía manual, o automáticamente por horario (ver abajo).
192
+
193
+ **Auto-transición por horario.** `cama_service.procesar_transiciones_automaticas` (invocada por `POST /api/v1/internal/reservas/tick`, `app/routers/internal.py`) avanza sola las reservas que no se resolvieron a mano: al llegar `fecha_hora_inicio`, una reserva `RESERVADA` pasa a `EN_CURSO`; al llegar `fecha_hora_fin_estimada`, una `EN_CURSO` pasa a `COMPLETADA`. Reusa `update_reserva_estado` tal cual — mismos side-effects que la transición manual (cama a `OCUPADA`/`EN_LIMPIEZA`, auditoría con `rol=SISTEMA`). Que el filtro de origen sea `estado=RESERVADA` ya resuelve "si no se canceló, arranca sola": una reserva `CANCELADA` nunca es candidata, sin lógica adicional. El tick es idempotente: una reserva ya transicionada no vuelve a matchear el filtro en la siguiente pasada.
194
+
195
+ El endpoint no usa `get_current_user` (no hay un usuario humano detrás de un cron) — se protege con un secreto compartido simple (`settings.internal_tick_secret`, header `X-Internal-Token`). Está pensado para que lo dispare un **cron externo** (GitHub Actions con `schedule:`, o cron-job.org), no un scheduler en memoria: el deploy de M6 en HF Spaces es del tier gratuito, que duerme el contenedor tras inactividad — un loop interno de `asyncio`/APScheduler se congelaría junto con el proceso. La propia request del cron despierta el Space si estaba dormido y ejecuta el chequeo. Se descartó también `pg_cron` de Supabase: sobrevive al sleep, pero reimplementar los side-effects de `update_reserva_estado` en SQL duplicaría la máquina de estados en dos lenguajes.
196
+
197
+ Margen de precisión aceptable: con un cron cada 1–5 minutos, una cirugía puede reflejarse en el sistema hasta ese margen tarde respecto del horario real — razonable para este caso de uso.
198
 
199
  ### 5.5 Cirugía urgente con priorización ASAP
200
 
 
510
  33. **Eliminado `facturacion.notify_cierre_cama`.** Apuntaba a `POST /api/v1/webhooks/internacion/cierre-cama`, un endpoint que nunca estuvo en la tabla de webhooks salientes (§7.2) ni pasó por la revisión contra el backend real de M7 que sí tuvo `notify_cama_lista` (changelog #14). Estaba activamente cableada en `procesar_alta_medica` y era **bloqueante**: `if not facturacion.notify_cierre_cama(...): raise 502` — con `mock_external_services=False` en producción, cualquier alta médica real hubiera fallado con `502` contra un endpoint que M7 nunca implementó. Sin test para el camino real (pasaba siempre por el atajo de `mock_external_services=True`).
511
  34. **Corregido el gating bloqueante de `monitoreo.notify_baja` en `procesar_alta_medica`.** Era el único de los 5 call sites de `notify_alta`/`notify_baja` en todo el código que trataba la llamada como bloqueante (`if not ...: raise 502`); los otros 4 (`cama_service.py` ingreso/traslado, `solicitud_service.py` aprobar internación/traslado) ya la tratan fire-and-forget. Alineado con el resto del código y con el principio de §2 ("que el receptor esté caído no debe revertir el alta del paciente"): ahora es `monitoreo.notify_baja(paciente_id)` sin gate.
512
  35. **El alta médica ya no depende de M7 ni M9 para completarse.** La notificación real a M7 (`CAMA_LISTA`) sigue ocurriendo, fire-and-forget, más adelante en el flujo (al completar la limpieza, `cama_service.py`). Blindado con tests: `test_alta_medica_ok_aunque_monitoreo_falle` y `test_alta_medica_no_llama_a_facturacion` (`tests/test_webhooks.py`).
513
+
514
+ ### 14.8 Auto-transición de reservas de quirófano por horario (2026-07)
515
+
516
+ 36. **Nuevo `cama_service.procesar_transiciones_automaticas`** (§5.4): avanza `RESERVADA→EN_CURSO` y `EN_CURSO→COMPLETADA` según `fecha_hora_inicio`/`fecha_hora_fin_estimada`, reusando `update_reserva_estado` — mismos side-effects que la transición manual, cero lógica de negocio duplicada. Nuevas queries `reserva_crud.get_pendientes_de_inicio`/`get_pendientes_de_fin`.
517
+ 37. **Nuevo endpoint `POST /api/v1/internal/reservas/tick`** (`app/routers/internal.py`), protegido con secreto compartido (`settings.internal_tick_secret`, header `X-Internal-Token`) en vez de JWT de sesión — no hay usuario humano detrás de un cron. Pensado para dispararse desde un cron externo (GitHub Actions/cron-job.org), no un scheduler en memoria: el deploy en HF Spaces (tier gratuito) duerme el contenedor tras inactividad, y un loop interno se congelaría con él. Verificado en vivo contra la base real: primer tick transicionó reservas vencidas (`{"iniciadas":7,"completadas":7}`), el segundo tick inmediato confirmó la idempotencia (`{"iniciadas":0,"completadas":0}`).
tests/test_internal.py ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Tests de `POST /api/v1/internal/reservas/tick`: no usa `get_current_user` (no hay usuario
3
+ humano detrás de un cron externo) — se protege con `X-Internal-Token` comparado contra
4
+ `settings.internal_tick_secret`.
5
+ """
6
+ from fastapi.testclient import TestClient
7
+
8
+ from app.config import settings
9
+
10
+ TICK_URL = "/api/v1/internal/reservas/tick"
11
+
12
+
13
+ def test_tick_sin_header_401(client: TestClient, monkeypatch):
14
+ monkeypatch.setattr(settings, "internal_tick_secret", "el-secreto-correcto")
15
+ resp = client.post(TICK_URL)
16
+ assert resp.status_code == 422 # Header(...) obligatorio, FastAPI valida antes
17
+
18
+
19
+ def test_tick_token_incorrecto_401(client: TestClient, monkeypatch):
20
+ monkeypatch.setattr(settings, "internal_tick_secret", "el-secreto-correcto")
21
+ resp = client.post(TICK_URL, headers={"X-Internal-Token": "otro-valor"})
22
+ assert resp.status_code == 401
23
+ assert resp.json()["detail"]["codigo"] == "NO_AUTENTICADO"
24
+
25
+
26
+ def test_tick_secreto_no_configurado_401(client: TestClient, monkeypatch):
27
+ """internal_tick_secret="" (default) rechaza todo — falla cerrado, no abierto."""
28
+ monkeypatch.setattr(settings, "internal_tick_secret", "")
29
+ resp = client.post(TICK_URL, headers={"X-Internal-Token": "cualquiera"})
30
+ assert resp.status_code == 401
31
+
32
+
33
+ def test_tick_ok(client: TestClient, monkeypatch):
34
+ monkeypatch.setattr(settings, "internal_tick_secret", "el-secreto-correcto")
35
+ monkeypatch.setattr(
36
+ "app.services.cama_service.procesar_transiciones_automaticas",
37
+ lambda db: {"iniciadas": 2, "completadas": 1},
38
+ )
39
+ resp = client.post(TICK_URL, headers={"X-Internal-Token": "el-secreto-correcto"})
40
+ assert resp.status_code == 200
41
+ assert resp.json() == {"iniciadas": 2, "completadas": 1}
tests/test_reserva_scheduler.py ADDED
@@ -0,0 +1,108 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Tests de `cama_service.procesar_transiciones_automaticas`: avance automático de
3
+ RESERVADA→EN_CURSO→COMPLETADA según horario, reusando `update_reserva_estado` (mismos
4
+ side-effects que la transición manual vía PATCH).
5
+ """
6
+ from unittest.mock import MagicMock
7
+
8
+ from tests.factories import make_cama, make_quirofano, make_reserva
9
+ from app.services import cama_service
10
+
11
+
12
+ def test_reserva_vencida_pasa_a_en_curso(monkeypatch):
13
+ quirofano = make_quirofano(estado="DISPONIBLE")
14
+ reserva = make_reserva(estado="RESERVADA", cama_id=501, paciente_id=7)
15
+
16
+ monkeypatch.setattr("app.crud.reserva.get_pendientes_de_inicio", lambda db, ahora: [reserva])
17
+ monkeypatch.setattr("app.crud.reserva.get_pendientes_de_fin", lambda db, ahora: [])
18
+ monkeypatch.setattr("app.crud.cama.get_by_id", lambda db, cid: quirofano)
19
+ # update_reserva_estado vuelve a buscar la reserva por (cama_id, reserva_id) — no
20
+ # recibe la instancia de get_pendientes_de_inicio directamente.
21
+ monkeypatch.setattr("app.crud.reserva.get_by_cama_and_id", lambda db, cid, rid: reserva)
22
+ monkeypatch.setattr("app.crud.reserva.save", lambda db, r: r)
23
+ monkeypatch.setattr("app.crud.cama.save", lambda db, c: c)
24
+
25
+ result = cama_service.procesar_transiciones_automaticas(MagicMock())
26
+
27
+ assert result == {"iniciadas": 1, "completadas": 0}
28
+ assert reserva.estado == "EN_CURSO"
29
+ assert quirofano.estado == "OCUPADA"
30
+ assert quirofano.paciente_id == 7
31
+
32
+
33
+ def test_reserva_en_curso_vencida_pasa_a_completada(monkeypatch):
34
+ quirofano = make_quirofano(estado="OCUPADA", paciente_id=7)
35
+ reserva = make_reserva(estado="EN_CURSO", cama_id=501, paciente_id=7)
36
+
37
+ monkeypatch.setattr("app.crud.reserva.get_pendientes_de_inicio", lambda db, ahora: [])
38
+ monkeypatch.setattr("app.crud.reserva.get_pendientes_de_fin", lambda db, ahora: [reserva])
39
+ monkeypatch.setattr("app.crud.cama.get_by_id", lambda db, cid: quirofano)
40
+ monkeypatch.setattr("app.crud.reserva.get_by_cama_and_id", lambda db, cid, rid: reserva)
41
+ monkeypatch.setattr("app.crud.reserva.save", lambda db, r: r)
42
+ monkeypatch.setattr("app.crud.cama.save", lambda db, c: c)
43
+
44
+ result = cama_service.procesar_transiciones_automaticas(MagicMock())
45
+
46
+ assert result == {"iniciadas": 0, "completadas": 1}
47
+ assert reserva.estado == "COMPLETADA"
48
+ assert quirofano.estado == "EN_LIMPIEZA"
49
+
50
+
51
+ def test_reserva_cancelada_no_es_candidata(monkeypatch):
52
+ """El filtro de origen ya excluye CANCELADA — no hace falta lógica extra acá; este
53
+ test blinda que get_pendientes_de_inicio nunca devuelva una CANCELADA."""
54
+ monkeypatch.setattr("app.crud.reserva.get_pendientes_de_inicio", lambda db, ahora: [])
55
+ monkeypatch.setattr("app.crud.reserva.get_pendientes_de_fin", lambda db, ahora: [])
56
+
57
+ result = cama_service.procesar_transiciones_automaticas(MagicMock())
58
+
59
+ assert result == {"iniciadas": 0, "completadas": 0}
60
+
61
+
62
+ def test_varias_reservas_se_procesan_en_el_mismo_tick(monkeypatch):
63
+ quirofano_a = make_quirofano(id=501, estado="DISPONIBLE")
64
+ quirofano_b = make_quirofano(id=502, estado="OCUPADA", paciente_id=8)
65
+ reserva_a = make_reserva(id=1, cama_id=501, estado="RESERVADA", paciente_id=7)
66
+ reserva_b = make_reserva(id=2, cama_id=502, estado="EN_CURSO", paciente_id=8)
67
+
68
+ monkeypatch.setattr("app.crud.reserva.get_pendientes_de_inicio", lambda db, ahora: [reserva_a])
69
+ monkeypatch.setattr("app.crud.reserva.get_pendientes_de_fin", lambda db, ahora: [reserva_b])
70
+ monkeypatch.setattr(
71
+ "app.crud.cama.get_by_id",
72
+ lambda db, cid: quirofano_a if cid == 501 else quirofano_b,
73
+ )
74
+ monkeypatch.setattr(
75
+ "app.crud.reserva.get_by_cama_and_id",
76
+ lambda db, cid, rid: reserva_a if rid == 1 else reserva_b,
77
+ )
78
+ monkeypatch.setattr("app.crud.reserva.save", lambda db, r: r)
79
+ monkeypatch.setattr("app.crud.cama.save", lambda db, c: c)
80
+
81
+ result = cama_service.procesar_transiciones_automaticas(MagicMock())
82
+
83
+ assert result == {"iniciadas": 1, "completadas": 1}
84
+ assert reserva_a.estado == "EN_CURSO"
85
+ assert reserva_b.estado == "COMPLETADA"
86
+
87
+
88
+ def test_registra_auditoria_con_rol_sistema(monkeypatch):
89
+ quirofano = make_quirofano(estado="DISPONIBLE")
90
+ reserva = make_reserva(estado="RESERVADA", cama_id=501, paciente_id=7)
91
+ auditoria_calls = []
92
+
93
+ monkeypatch.setattr("app.crud.reserva.get_pendientes_de_inicio", lambda db, ahora: [reserva])
94
+ monkeypatch.setattr("app.crud.reserva.get_pendientes_de_fin", lambda db, ahora: [])
95
+ monkeypatch.setattr("app.crud.cama.get_by_id", lambda db, cid: quirofano)
96
+ monkeypatch.setattr("app.crud.reserva.get_by_cama_and_id", lambda db, cid, rid: reserva)
97
+ monkeypatch.setattr("app.crud.reserva.save", lambda db, r: r)
98
+ monkeypatch.setattr("app.crud.cama.save", lambda db, c: c)
99
+ monkeypatch.setattr(
100
+ "app.crud.auditoria.registrar",
101
+ lambda db, **kwargs: auditoria_calls.append(kwargs),
102
+ )
103
+
104
+ cama_service.procesar_transiciones_automaticas(MagicMock())
105
+
106
+ assert auditoria_calls # al menos la de RESERVA_QUIROFANO (y la de CAMA, si cambió)
107
+ for call in auditoria_calls:
108
+ assert call["actor"] is None # rol SISTEMA por default en auditoria_crud.registrar