marcos
02feb973c9
Clon del gateway Anexo22 -> EFC que ya esta en produccion, con los nombres
cambiados. No es una reinterpretacion: la maquina de reintentos de tres capas,
el corte en 4xx y las cuatro guardas de idempotencia se conservan tal cual.
Sin esto, "EFC es la fuente unica" obligaria a llamar a EFC dentro del request
del usuario, y un EFC caido le haria perder su trabajo. Con outbox + Celery, la
subida responde 201 siempre y el sistema entrega cuando EFC vuelve, sin
duplicar: el crm_document_ref viaja con la subida y EFC devuelve 200 con el
documento que ya existia en vez de crear otro. Es lo que cubre el timeout
ambiguo -EFC commiteo y contesto tarde-, donde el CRM no puede saber si entro.
TRES DESVIACIONES DELIBERADAS DEL ORIGINAL, las tres con su razon en el codigo:
1. SAVEPOINT en vez de db.rollback() en el except del encolado. En Anexo22 el
outbox vive en OTRA base que el pedimento, asi que su rollback solo revertia
la sesion del outbox. El CRM es mono-base y el encolado corre DENTRO de la
transaccion del usuario: heredar ese rollback tumbaba la solicitud y el
expediente recien creados -exactamente lo contrario de best-effort, y en
silencio-. Lo destapo un test y asi se manifestaba:
"InvalidRequestError: Instance '<ServiceRequest>' is not persistent within
this Session". Con el savepoint el fallo deshace solo la fila del outbox.
2. source_table junto a source_id en la guarda _ya_entregado. El CRM tiene DOS
tablas de documentos con secuencias independientes: crm.documents.id = 5 y
ops.shipment_documents.id = 5 son documentos distintos. Con el id solo, haber
entregado el primero haria que el segundo se saltara para siempre sin un solo
error visible. Hay test que lo fija.
3. EFC_UPLOAD_TIMEOUT_MS aparte de EFC_API_TIMEOUT_MS. Los 8 s de los metadatos
no alcanzan para un archivo de 25 MB, y el timeout debe quedar POR DEBAJO del
proxy_read_timeout del nginx de EFC: si el CRM esperara mas, veria un 504
opaco sin saber si el documento entro.
El cliente HTTP llega con las pruebas que el carril de referencia NO tiene
-verificado: en Anexo22 no hay ni un test de EfcClient._request-, asi que alli
el bucle de reintentos, el backoff y el corte en 4xx nunca se ejercitan. Ese
hueco no se clona: 16 casos contra httpx.MockTransport, sin tocar la red.
Las migraciones se GENERAN y se dejan SIN aplicar.
BLOQUEADO: docker-compose.prod.yml no se toco. El ticket pide las 8 variables en
api, worker y beat, pero Orquestacion.md 13.14 y 4.5 lo prohiben expresamente
("ni tocarlo"), y el orquestador manda sobre el ticket. Queda como paso manual
en el reporte; sin el, worker y beat no ven EFC_API_URL y el carril queda
apagado en produccion, que es degradar limpio y no romper.
Verificacion: pytest tests/ EXIT=0, 151 passed 1 skipped (baseline 70 passed).
Cuatro roturas deliberadas y restauradas: quitando source_table de la guarda el
test de la ambiguedad se puso rojo; reintentando los 4xx los tres tests del
corte dieron "assert 3 == 1"; borrando el objeto local antes de subir cayeron
los tres del corte directo; y disparando el ensure por cualquier 404 se rompio
el test del code.
Ticket: T2026-08-046 (fase 6 de 7)
135 lines
5.0 KiB
Python
135 lines
5.0 KiB
Python
"""Contrato del tablero de ops del carril CRM -> EFC.
|
|
|
|
Lo que se fija aquí es lo que el frontend espera recibir: el 404 del reintento sobre una fila que no
|
|
existe (y **no** un 200 silencioso), la forma exacta de la respuesta de éxito, y el aislamiento por
|
|
tenant/company.
|
|
"""
|
|
|
|
import pytest
|
|
from fastapi import HTTPException
|
|
|
|
from api.v1.modules.crm.expediente_gateway import routes
|
|
from api.v1.modules.crm.expediente_gateway import service as gateway
|
|
from api.v1.modules.crm.expediente_gateway.models import (
|
|
FILE_KIND_DOCUMENTO,
|
|
SOURCE_CRM_DOCUMENTS,
|
|
STATUS_FAILED,
|
|
STATUS_PENDING,
|
|
STATUS_SENT,
|
|
EfcFileOutbox,
|
|
)
|
|
from api.v1.modules.crm.expedientes import service as expedientes_service
|
|
from api.v1.modules.crm.service_requests import service as sr_service
|
|
from api.v1.modules.crm.service_requests.dto import ServiceRequestCreate
|
|
from tests.conftest import COMPANY_ID, TENANT_ID
|
|
|
|
OTRO_TENANT = 99
|
|
OTRA_COMPANY = 77
|
|
USUARIO = {"tenant_id": TENANT_ID, "sub": "user-1"}
|
|
|
|
|
|
@pytest.fixture()
|
|
def entorno(db, monkeypatch):
|
|
from core.config import settings
|
|
|
|
monkeypatch.setattr(settings, "EFC_API_URL", "https://efc.example.test/", raising=False)
|
|
monkeypatch.setattr(gateway, "_dispatch_delivery", lambda *a, **k: None)
|
|
monkeypatch.setattr(gateway, "_dispatch_file_delivery", lambda *a, **k: None)
|
|
monkeypatch.setattr(gateway, "_tenant_slug", lambda tid: ("temex", "TEMEX"))
|
|
|
|
solicitud = sr_service.create_service_request(
|
|
db, ServiceRequestCreate(operation_type="importacion"), TENANT_ID, COMPANY_ID, "user-1"
|
|
)
|
|
expediente = expedientes_service.find_by_service_request(db, solicitud.id, TENANT_ID, COMPANY_ID)
|
|
return {"db": db, "expediente": expediente}
|
|
|
|
|
|
def _fila_archivo(db, expediente, **kwargs) -> EfcFileOutbox:
|
|
row = EfcFileOutbox(
|
|
kind=FILE_KIND_DOCUMENTO,
|
|
s3_key="k",
|
|
file_name="guia.pdf",
|
|
content_type="application/pdf",
|
|
efc_tipo="MBL",
|
|
source_table=SOURCE_CRM_DOCUMENTS,
|
|
source_id=kwargs.pop("source_id", 1),
|
|
crm_document_ref="CRMDOC-1-1",
|
|
expediente_ref=expediente.id,
|
|
status=kwargs.pop("status", STATUS_PENDING),
|
|
tenant_id=kwargs.pop("tenant_id", TENANT_ID),
|
|
company_id=kwargs.pop("company_id", COMPANY_ID),
|
|
**kwargs,
|
|
)
|
|
db.add(row)
|
|
db.commit()
|
|
return row
|
|
|
|
|
|
def test_retry_de_una_fila_inexistente_da_404_con_mensaje_especifico(entorno):
|
|
"""**Es contrato con el frontend.** Un 200 le haría pintar «reencolado» cuando no hay nada que
|
|
entregar, y el usuario esperaría un badge que nunca va a cambiar."""
|
|
with pytest.raises(HTTPException) as exc:
|
|
routes.retry_outbox(999999, COMPANY_ID, "file", USUARIO, entorno["db"])
|
|
|
|
assert exc.value.status_code == 404
|
|
assert exc.value.detail == "Fila de outbox no encontrada"
|
|
|
|
|
|
def test_retry_exitoso_devuelve_requeued_con_el_id(entorno):
|
|
row = _fila_archivo(entorno["db"], entorno["expediente"], status=STATUS_FAILED)
|
|
|
|
resp = routes.retry_outbox(row.id, COMPANY_ID, "file", USUARIO, entorno["db"])
|
|
|
|
assert resp == {"status": "requeued", "id": row.id}
|
|
assert row.status == STATUS_PENDING
|
|
|
|
|
|
def test_retry_de_una_fila_de_otra_company_da_404(entorno):
|
|
"""No se filtra la existencia: para ese usuario la fila simplemente no existe."""
|
|
row = _fila_archivo(entorno["db"], entorno["expediente"], company_id=OTRA_COMPANY)
|
|
|
|
with pytest.raises(HTTPException) as exc:
|
|
routes.retry_outbox(row.id, COMPANY_ID, "file", USUARIO, entorno["db"])
|
|
assert exc.value.status_code == 404
|
|
|
|
|
|
def test_metrics_cuenta_por_status(entorno):
|
|
db, expediente = entorno["db"], entorno["expediente"]
|
|
_fila_archivo(db, expediente, source_id=1, status=STATUS_FAILED)
|
|
_fila_archivo(db, expediente, source_id=2, status=STATUS_SENT)
|
|
|
|
metricas = routes.metrics(COMPANY_ID, USUARIO, db)
|
|
|
|
assert set(metricas) == {"pending", "sent", "failed"}
|
|
assert metricas["failed"] == 1
|
|
assert metricas["sent"] == 1
|
|
|
|
|
|
def test_metrics_no_ve_otro_tenant(entorno):
|
|
db, expediente = entorno["db"], entorno["expediente"]
|
|
_fila_archivo(db, expediente, source_id=3, status=STATUS_FAILED, tenant_id=OTRO_TENANT)
|
|
|
|
assert routes.metrics(COMPANY_ID, USUARIO, db)["failed"] == 0
|
|
|
|
|
|
def test_el_listado_solo_devuelve_lo_del_tenant_y_la_company(entorno):
|
|
db, expediente = entorno["db"], entorno["expediente"]
|
|
_fila_archivo(db, expediente, source_id=1)
|
|
_fila_archivo(db, expediente, source_id=2, tenant_id=OTRO_TENANT)
|
|
_fila_archivo(db, expediente, source_id=3, company_id=OTRA_COMPANY)
|
|
|
|
filas = routes.list_outbox(COMPANY_ID, "file", None, 100, USUARIO, db)
|
|
|
|
assert len(filas) == 1
|
|
assert filas[0]["source_id"] == 1
|
|
|
|
|
|
def test_el_listado_filtra_por_status(entorno):
|
|
db, expediente = entorno["db"], entorno["expediente"]
|
|
_fila_archivo(db, expediente, source_id=1, status=STATUS_FAILED)
|
|
_fila_archivo(db, expediente, source_id=2, status=STATUS_SENT)
|
|
|
|
fallidas = routes.list_outbox(COMPANY_ID, "file", STATUS_FAILED, 100, USUARIO, db)
|
|
|
|
assert [f["source_id"] for f in fallidas] == [1]
|