Download documentation/end_to_end_tests/flujo_internacion_completo.md from Modulo-6/api: direct link, hf CLI and curl.
- Browser
- Download file 12.5 kB
-
https://huggingface.co/spaces/Modulo-6/api/resolve/main/documentation/end_to_end_tests/flujo_internacion_completo.md
- Command line
-
hf download hf://spaces/Modulo-6/api/documentation/end_to_end_tests/flujo_internacion_completo.md
-
curl -L -o flujo_internacion_completo.md https://huggingface.co/spaces/Modulo-6/api/resolve/main/documentation/end_to_end_tests/flujo_internacion_completo.md
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, eventoCIERRE_INTERNACION,event_type_id=19) y a M9.CORE_SERVICE_EMAIL/CORE_SERVICE_PASSWORDvá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_URLapuntando 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
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).
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
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
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
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
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.
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)
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.
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.
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.
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.
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)
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)paraCIERRE_INTERNACION, no es un problema del payload — es quefacturacion_cama_lista_event_type_idresolvió aNoneen 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 conGET /api/v1/_debug/settingsque ese campo sea19antes de sospechar del código.El
POSTREST directo a M7 puede devolver401 Unauthorized— es conocido y no bloquea el alta (es fire-and-forget): M7 no documenta ningúnAuthorizationpara 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
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_nameno está mapeado, o la función de servicio lanzó una excepción (p.ej. cama inexistente,solicitud_hce_idrepetido con otro payload). Revisar los logs de M6: cada rechazo logueaError procesando <event_type_name> (log_id=...). 502al aprobar la solicitud. No es un problema de la cola — es queMOCK_EXTERNAL_SERVICES=falsey algún servicio externo (M10/M1/M9) no respondió, oPACIENTE_IDno 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 mismoPOST /events/log. /_debug/settingsmuestrarabbitmq_consumer_enabled: falseo URLs enlocalhost. 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).