api / documentation /end_to_end_tests /flujo_internacion_completo.md
juampisor's picture
Implementacion GETs de M1 para front
3bc4d13
|
Raw History Blame Contribute Delete
12.5 kB

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

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) 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

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 <event_type_name> (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).