# E2E — Internación completa por la cola real de RabbitMQ Prueba de punta a punta usando el **bus de eventos real** del Core (M10), no los webhooks REST directos: trae los datos de un paciente real desde M1, publica la solicitud de internación y el alta médica como eventos en `internacion.requests`, y confirma que el consumer de M6 (`app/integrations/rabbit_consumer.py`) los procesa igual que el webhook REST equivalente — hasta que la cama llega a `EN_LIMPIEZA` y M6 notifica (real, no mockeado) a Facturación (M7) y Monitoreo (M9). Para el flujo equivalente por REST directo (más simple, sin depender del broker), ver el historial de este archivo o `documentation/M6_demo_payloads.md`. ## 0. Requisitos previos Esta prueba corre contra el **deploy real** (`https://modulo-6-api.hf.space`), con: - `RABBITMQ_CONSUMER_ENABLED=true`, `RABBITMQ_HOST=queue.healthgrid.cantero.ar`, `RABBITMQ_PORT=5672`, `RABBITMQ_VHOST=/` — el consumer tiene que estar corriendo. - `MOCK_EXTERNAL_SERVICES=false` — **loop completo**: la aprobación valida al paciente contra el Core real (M10) y notifica a M1/M9 reales; el alta médica notifica a M7 (real, evento `CIERRE_INTERNACION`, `event_type_id=19`) y a M9. - `CORE_SERVICE_EMAIL`/`CORE_SERVICE_PASSWORD` válidos (cuenta de servicio de M6 en el Core — se usa tanto para las llamadas salientes como, en el broker, como credencial RabbitMQ). - `M10_CORE_URL`, `M1_HCE_URL`, `M7_FACTURACION_URL`, `M9_MONITOREO_URL` apuntando a los servicios reales. **Con `MOCK_EXTERNAL_SERVICES=false`, el `PACIENTE_ID` de prueba tiene que existir realmente como usuario en el Core** — si no, el paso 3 (aprobar) falla con `502 SERVICIO_EXTERNO_NO_DISPONIBLE` (`core.validate_patient`). Usar un paciente ya dado de alta en M10/M1, no un ID inventado. ### 0.1 — Confirmar que el consumer está arriba ```bash export M6_URL="https://modulo-6-api.hf.space/api/v1" M6_TOKEN=$(curl -s "$M6_URL/auth/token?usuario=ADMINISTRATIVO&password=x" \ | python3 -c "import sys,json; print(json.load(sys.stdin)['access_token'])") curl -s "$M6_URL/_debug/settings" -H "Authorization: Bearer $M6_TOKEN" \ | python3 -m json.tool ``` Confirmar `rabbitmq_consumer_enabled: true`, `mock_external_services: false`, y que `m10_core_url`/`m1_hce_url`/`m7_facturacion_url`/`m9_monitoreo_url` apuntan a los servicios reales (no a los `localhost` por default). Si `/auth/token` da `404` (el Space corre en `ENVIRONMENT=production`), conseguir el token de M6 vía SSO real en su lugar (`documentation/M6_AUTH_SSO.md`). También revisar los **logs del Space** (HF → Logs): debe aparecer `Iniciando consumer de internacion.requests` sin un traceback de conexión inmediatamente después. Si el broker rechaza credenciales o la cola no existe, el consumer muere ahí y nada de lo que sigue va a funcionar. ### 0.2 — Token de la cuenta de servicio de M6 en el Core (para publicar eventos) Los eventos los publica quien los emite realmente (M1/M9) contra su propia cuenta — para simularlo en esta prueba manual, se publica con la cuenta de servicio de M6 (mismas credenciales que usa el backend). ```bash export CORE_URL="https://api.healthcare.cantero.ar" CORE_TOKEN=$(curl -s -X POST "$CORE_URL/auth/login" \ -H "Content-Type: application/json" \ -d '{"email": "'"$CORE_SERVICE_EMAIL"'", "password": "'"$CORE_SERVICE_PASSWORD"'"}' \ | python3 -c "import sys,json; print(json.load(sys.stdin)['token'])") echo "CORE_TOKEN=$CORE_TOKEN" ``` ### 0.3 — Variables del flujo ```bash export M1_URL="http://localhost:8001" # ajustar al M1 real / desplegado export PACIENTE_ID=7 # tiene que existir en el Core (ver arriba) export CAMA_ID=101 export HOSPITAL_ID="HOSP-001" ``` --- ## 1. [M1] Obtener datos del paciente Sin cambios respecto al flujo REST — esto sigue siendo una consulta directa a M1, no pasa por la cola. ### 1.1 — Token de desarrollo de M1 ```bash M1_TOKEN=$(curl -s -X POST "$M1_URL/api/v1/dev/login" \ -H "Content-Type: application/json" \ -d '{}' | python3 -c "import sys,json; print(json.load(sys.stdin)['access_token'])") echo "M1_TOKEN=$M1_TOKEN" ``` ### 1.2 — Datos básicos, ficha médica, antecedentes y alertas ```bash curl -s "$M1_URL/api/v1/pacientes/$PACIENTE_ID" -H "Authorization: Bearer $M1_TOKEN" curl -s "$M1_URL/api/v1/pacientes/$PACIENTE_ID/ficha-medica" -H "Authorization: Bearer $M1_TOKEN" curl -s "$M1_URL/api/v1/pacientes/$PACIENTE_ID/antecedentes" -H "Authorization: Bearer $M1_TOKEN" curl -s "$M1_URL/api/v1/pacientes/$PACIENTE_ID/alertas" -H "Authorization: Bearer $M1_TOKEN" ``` --- ## 2. [Cola] Publicar el evento de solicitud de internación `event_type_id=14` (`internacion.solicitud.creada`) → bindeado a `internacion.requests` → lo consume `rabbit_consumer.dispatch` → `solicitud_service.recibir_solicitud` (la misma función que usa `POST /webhooks/hce/solicitud`). ### 2.1 — (Prerrequisito) crear la cama de destino si todavía no existe ```bash curl -s -X POST "$M6_URL/camas" \ -H "Authorization: Bearer $M6_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "numero": '"$CAMA_ID"', "piso": 1, "sector": "SALA_COMUN", "tipo": "ESTANDAR", "hospital_id": "'"$HOSPITAL_ID"'" }' ``` Tiene que quedar en `estado: "DISPONIBLE"`. ### 2.2 — Publicar el evento al Core El `payload` interno viaja como **string JSON** (no como objeto anidado) — se arma con `python3 -c` para que quede bien escapado dentro del body del `POST /events/log`. ```bash PAYLOAD=$(python3 -c ' import json, sys print(json.dumps({ "tipo": "INTERNACION", "solicitud_hce_id": "HCE-SOL-001", "episodio_id": 46, "paciente_id": int(sys.argv[1]), "medico_solicitante_id": 10, "cama_solicitada_id": int(sys.argv[2]), "origen": "GUARDIA", "diagnostico_ingreso": "Neumonía adquirida en la comunidad", "obra_social_id": "OSDE-210", "numero_afiliado": "A-99887766", "prioridad": "ALTA", "hospital_id": sys.argv[3], "observaciones": "Paciente requiere oxígeno suplementario", "timestamp": sys.argv[4], })) ' "$PACIENTE_ID" "$CAMA_ID" "$HOSPITAL_ID" "$(date -u +%Y-%m-%dT%H:%M:%SZ)") curl -s -X POST "$CORE_URL/events/log" \ -H "Authorization: Bearer $CORE_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "event_type_id": 14, "publisher_module": "hce", "payload": '"$(python3 -c 'import json,sys; print(json.dumps(sys.argv[1]))' "$PAYLOAD")"' }' ``` La respuesta de `POST /events/log` solo confirma que el Core **recibió** el evento — no que M6 ya lo procesó. El procesamiento es asíncrono. ### 2.3 — Verificar que M6 la procesó (polling) ```bash for i in $(seq 1 10); do RESP=$(curl -s "$M6_URL/solicitudes?estado=PENDIENTE&hospital_id=$HOSPITAL_ID" \ -H "Authorization: Bearer $M6_TOKEN") echo "$RESP" | python3 -c " import json, sys data = json.load(sys.stdin) match = [s for s in data['solicitudes'] if s['paciente_id'] == $PACIENTE_ID] if match: print('OK:', match[0]['id'], match[0]['estado']) sys.exit(0) sys.exit(1) " && break echo "todavía no llegó, reintentando en 2s ($i/10)..." sleep 2 done ``` Si a los ~20s no apareció, ver la sección **Troubleshooting** más abajo antes de seguir. ```bash export SOLICITUD_ID="SOL-00001" # el id que devolvió el polling de arriba ``` --- ## 3. [M6] Aprobar la solicitud **Esto no pasa por la cola** — es una acción de administración de M6, siempre REST. ```bash curl -s -X PATCH "$M6_URL/solicitudes/$SOLICITUD_ID" \ -H "Authorization: Bearer $M6_TOKEN" \ -H "Content-Type: application/json" \ -d '{"accion": "APROBAR"}' ``` Con `MOCK_EXTERNAL_SERVICES=false`, esto dispara llamadas reales: `core.validate_patient` (M10 — por eso `PACIENTE_ID` debe existir ahí), `hce.get_contraindicaciones`/`notify_movimiento`/`notify_resultado_solicitud` (M1), y `monitoreo.notify_alta` (M9). Un `502 SERVICIO_EXTERNO_NO_DISPONIBLE` acá indica que alguno de esos servicios no respondió o el paciente no existe en el Core — no es un problema de la cola. Respuesta esperada (`200`): `estado: "APROBADA"`, `cama_asignada_id` seteado. ```bash curl -s "$M6_URL/camas/$CAMA_ID" -H "Authorization: Bearer $M6_TOKEN" ``` --- ## 4. [Cola] Publicar el evento de alta médica `event_type_id=15` (`internacion.alta-medica.registrada`) → `dispatch` → `solicitud_service.procesar_alta_medica`. ```bash PAYLOAD=$(python3 -c ' import json, sys print(json.dumps({ "paciente_id": int(sys.argv[1]), "medico_firmante_id": 10, "tipo_alta": "ALTA_MEDICA", "timestamp": sys.argv[2], })) ' "$PACIENTE_ID" "$(date -u +%Y-%m-%dT%H:%M:%SZ)") curl -s -X POST "$CORE_URL/events/log" \ -H "Authorization: Bearer $CORE_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "event_type_id": 15, "publisher_module": "hce", "payload": '"$(python3 -c 'import json,sys; print(json.dumps(sys.argv[1]))' "$PAYLOAD")"' }' ``` ### 4.1 — Verificar que la cama pasó a limpieza (polling) ```bash for i in $(seq 1 10); do ESTADO=$(curl -s "$M6_URL/camas/$CAMA_ID" -H "Authorization: Bearer $M6_TOKEN" \ | python3 -c "import json,sys; print(json.load(sys.stdin)['estado'])") echo "estado actual: $ESTADO" [ "$ESTADO" = "EN_LIMPIEZA" ] && break sleep 2 done ``` ### 4.2 — Confirmar la notificación saliente real a M7 (`CIERRE_INTERNACION`) Con `MOCK_EXTERNAL_SERVICES=false`, `procesar_alta_medica` dispara `facturacion.notify_cama_lista`, que publica el evento `CIERRE_INTERNACION` (`event_type_id=19`, `publisher_module="modulo_6"`) al Core además de un `POST` REST directo a M7. Confirmarlo en los **logs de M6** (debería verse la llamada saliente a `POST {M10_CORE_URL}/events/log` y a `{M7_FACTURACION_URL}/api/v1/webhooks/internacion/cama-lista`) y, si hay acceso, del lado de M7 (`https://modulo7-backend.onrender.com`) que el cierre llegó — quedará `RECIBIDO_PENDIENTE_DATOS` si `idEpisodioExterno` sigue en `None` (pendiente de M1, ver `M6_EVENTOS_RABBITMQ.md` §9). > **Si en los logs aparece `Evento no publicado (event_type_id todavía no configurado)` > para `CIERRE_INTERNACION`**, no es un problema del payload — es que > `facturacion_cama_lista_event_type_id` resolvió a `None` en el proceso corriendo (pasó una > vez: la variable HF nunca llegó a impactar, mismo patrón que otros casos de esta > conversación). Confirmar primero con `GET /api/v1/_debug/settings` que ese campo sea `19` > antes de sospechar del código. > > El `POST` REST directo a M7 puede devolver `401 Unauthorized` — es conocido y no bloquea > el alta (es fire-and-forget): M7 no documenta ningún `Authorization` para ese endpoint de > fallback/testing manual, y M6 igual manda el Bearer de la cuenta de servicio del Core. Sin > resolver todavía del lado de M7; la vía oficial es el evento del bus, no este REST. ### Verificación final ```bash curl -s "$M6_URL/camas/$CAMA_ID" -H "Authorization: Bearer $M6_TOKEN" curl -s "$M6_URL/auditoria?cama_id=$CAMA_ID" -H "Authorization: Bearer $M6_TOKEN" ``` `GET /auditoria` debe mostrar la traza completa: `SOLICITUD_RECIBIDA` → `SOLICITUD_APROBADA` → `CAMA_ASIGNADA` → `CAMA_ALTA` — igual que en el flujo por REST directo, la vía de entrada (cola vs. webhook) no cambia el resultado de negocio. --- ## Troubleshooting - **La solicitud/cama nunca aparece tras publicar el evento.** El mensaje puede haber caído a la dead-letter queue `internacion.requests.dlq` (panel de RabbitMQ) — pasa cuando el JSON está malformado, `event_type_name` no está mapeado, o la función de servicio lanzó una excepción (p.ej. cama inexistente, `solicitud_hce_id` repetido con otro payload). Revisar los logs de M6: cada rechazo loguea `Error procesando (log_id=...)`. - **`502` al aprobar la solicitud.** No es un problema de la cola — es que `MOCK_EXTERNAL_SERVICES=false` y algún servicio externo (M10/M1/M9) no respondió, o `PACIENTE_ID` no existe en el Core. - **Reintentar un evento no duplica nada.** La deduplicación es por `solicitud_hce_id` (`recibir_solicitud`) — si hay que reintentar el paso 2 tras corregir algo, alcanza con volver a publicar el mismo `POST /events/log`. - **`/_debug/settings` muestra `rabbitmq_consumer_enabled: false` o URLs en `localhost`.** Las variables de HF no llegaron al proceso — ver la sección de diagnóstico de variables/secrets más arriba en esta conversación (mismo endpoint, mismo mecanismo).