import pytest from httpx import AsyncClient, ASGITransport from app.main import app from app.services.dni_parser_service import DNIParsingService @pytest.mark.asyncio async def test_parse_dni_api(): transport = ASGITransport(app=app) async with AsyncClient(transport=transport, base_url="http://test") as client: # Autenticación previa login_res = await client.post( "/api/v1/auth/login", json={"username": "guardia", "password": "guardia"}, ) token = login_res.cookies.get("access_token") raw_qr = "0034567890@PEREZ@JUAN CARLOS@M@30123456@A@01/01/1985@01/01/2020@200" res = await client.post( "/api/v1/access/parse-dni", json={"raw_data": raw_qr}, cookies={"access_token": token}, ) assert res.status_code == 200 data = res.json() assert data["valido"] is True assert data["documento"] == "30123456" assert data["apellido"] == "PEREZ" assert data["nombre"] == "JUAN CARLOS" assert data["sexo"] == "M" @pytest.mark.asyncio async def test_search_people_and_lots(): transport = ASGITransport(app=app) async with AsyncClient(transport=transport, base_url="http://test") as client: login_res = await client.post( "/api/v1/auth/login", json={"username": "guardia", "password": "guardia"}, ) token = login_res.cookies.get("access_token") # Búsqueda de personas p_res = await client.get( "/api/v1/access/people/search?q=TEST", cookies={"access_token": token}, ) assert p_res.status_code == 200 assert isinstance(p_res.json(), list) # Búsqueda de lotes l_res = await client.get( "/api/v1/access/lots/search?q=1", cookies={"access_token": token}, ) assert l_res.status_code == 200 assert isinstance(l_res.json(), list) @pytest.mark.asyncio async def test_hardware_manual_open(): transport = ASGITransport(app=app) async with AsyncClient(transport=transport, base_url="http://test") as client: login_res = await client.post( "/api/v1/auth/login", json={"username": "guardia", "password": "guardia"}, ) token = login_res.cookies.get("access_token") res = await client.post( "/api/v1/hardware/modules/100004/open", json={"modulo_id": 100004, "motivo": "TEST_AUDIT"}, cookies={"access_token": token}, ) assert res.status_code == 200 data = res.json() assert data["status"] == "ok" assert data["modulo_id"] == 100004 assert data["latencia_ms"] < 500.0 @pytest.mark.asyncio async def test_flujo_completo_ingreso_y_salida(): transport = ASGITransport(app=app) async with AsyncClient(transport=transport, base_url="http://test") as client: login_res = await client.post( "/api/v1/auth/login", json={"username": "guardia", "password": "guardia"}, ) token = login_res.cookies.get("access_token") doc_test = "99887766" # 1. Registro de Ingreso entry_payload = { "modulo_ingreso_id": 100004, "documento": doc_test, "apellido": "TESTER", "nombre": "INTEGRAL", "sexo": "M", "patente": "TST999", "lote_codigo": "100", "motivo": "PRUEBA AUTOMATIZADA", "cantidad_ocupantes": 1, "abrir_barrera": True, } entry_res = await client.post( "/api/v1/access/entry", json=entry_payload, cookies={"access_token": token}, ) assert entry_res.status_code == 200 tck_data = entry_res.json() assert tck_data["status"] == "ok" ticket_id = tck_data["ticket_id"] assert ticket_id > 0 assert tck_data["barrier_opened"] is True # 2. Verificar que aparezca en tickets activos active_res = await client.get( "/api/v1/access/tickets/active", cookies={"access_token": token}, ) assert active_res.status_code == 200 tickets = active_res.json() ids_activos = [t["ticket_id"] for t in tickets] assert ticket_id in ids_activos # 3. Intentar reingreso (Antipassback) dup_res = await client.post( "/api/v1/access/entry", json=entry_payload, cookies={"access_token": token}, ) assert dup_res.status_code == 409 assert "Antipassback" in dup_res.json()["detail"] # 4. Registrar Salida exit_payload = { "ticket_id": ticket_id, "modulo_salida_id": 100005, "patente_salida": "TST999", "abrir_barrera": True, } exit_res = await client.post( "/api/v1/access/exit", json=exit_payload, cookies={"access_token": token}, ) assert exit_res.status_code == 200 exit_data = exit_res.json() assert exit_data["status"] == "ok" assert exit_data["barrier_opened"] is True # 5. Verificar que ya no esté en activos active_res2 = await client.get( "/api/v1/access/tickets/active", cookies={"access_token": token}, ) ids_activos2 = [t["ticket_id"] for t in active_res2.json()] assert ticket_id not in ids_activos2 # Teardown / Limpieza from app.core.database import db_session with db_session() as conn: cursor = conn.cursor() cursor.execute("DELETE FROM PerDocCatVal WHERE Documento = %s", (doc_test,)) cursor.execute("DELETE FROM Per WHERE Apellido = 'TESTER'") cursor.execute("DELETE FROM pdtmdl WHERE ModuloID IN (100004, 100005) AND Extra = %s", (str(ticket_id),)) cursor.execute("DELETE FROM mvthist WHERE TicketID = %s", (ticket_id,)) cursor.execute("DELETE FROM tckhst WHERE TicketID = %s", (ticket_id,)) @pytest.mark.asyncio async def test_lot_permission_and_occupants_api(): transport = ASGITransport(app=app) async with AsyncClient(transport=transport, base_url="http://test") as client: login_res = await client.post( "/api/v1/auth/login", json={"username": "guardia", "password": "guardia"}, ) token = login_res.cookies.get("access_token") # 1. Validar permiso de lote lot_res = await client.get( "/api/v1/access/lots/1/permission", cookies={"access_token": token}, ) assert lot_res.status_code == 200 lot_data = lot_res.json() assert "estado" in lot_data assert "color" in lot_data assert "detalle" in lot_data # 2. Registrar ingreso con acompañantes doc_cond = "88112233" doc_acomp1 = "88112234" doc_acomp2 = "88112235" entry_res = await client.post( "/api/v1/access/entry", json={ "modulo_ingreso_id": 100004, "documento": doc_cond, "apellido": "GARCIA", "nombre": "ROBERTO", "patente": "GRC888", "lote_codigo": "1", "cantidad_ocupantes": 3, "abrir_barrera": False, "integrantes": [ { "documento": doc_acomp1, "apellido": "GARCIA", "nombre": "ANA", "sexo": "F", "es_menor": False, "rol_id": 2, }, { "documento": doc_acomp2, "apellido": "GARCIA", "nombre": "LUCAS", "sexo": "M", "es_menor": True, "rol_id": 3, }, ], }, cookies={"access_token": token}, ) assert entry_res.status_code == 200 tid = entry_res.json()["ticket_id"] # 3. Consultar ocupantes del ticket occ_res = await client.get( f"/api/v1/access/tickets/{tid}/occupants", cookies={"access_token": token}, ) assert occ_res.status_code == 200 ocupantes = occ_res.json() assert len(ocupantes) >= 2 docs_cargados = [o["documento"] for o in ocupantes] assert doc_cond in docs_cargados # 4. Registrar salida verificando al conductor y desacoplando al acompañante que permanece pid_permanece = next((o["persona_id"] for o in ocupantes if o["documento"] == doc_acomp1), 0) exit_res = await client.post( "/api/v1/access/exit", json={ "ticket_id": tid, "modulo_salida_id": 100005, "patente_salida": "GRC888", "abrir_barrera": False, "personas_ids_permanecen": [pid_permanece] if pid_permanece else [], "integrantes_verificados": [], }, cookies={"access_token": token}, ) assert exit_res.status_code == 200 assert exit_res.json()["status"] == "ok" # Limpieza from app.core.database import db_session with db_session() as conn: cursor = conn.cursor() cursor.execute("DELETE FROM PerDocCatVal WHERE Documento IN (%s, %s, %s)", (doc_cond, doc_acomp1, doc_acomp2)) cursor.execute("DELETE FROM Per WHERE Apellido = 'GARCIA'") cursor.execute("DELETE FROM mvthist WHERE TicketID = %s", (tid,)) cursor.execute("DELETE FROM tckhst WHERE TicketID = %s", (tid,)) cursor.execute("DELETE FROM tckper WHERE TicketID = %s", (tid,)) cursor.execute("DELETE FROM tck WHERE TicketID = %s", (tid,)) @pytest.mark.asyncio async def test_validations_and_policies(): """Valida los chequeos de paridad de OnEverAccess (documento, nombre, lote, seguro automotor, ART).""" transport = ASGITransport(app=app) async with AsyncClient(transport=transport, base_url="http://test") as client: login_res = await client.post( "/api/v1/auth/login", json={"username": "guardia", "password": "guardia"}, ) token = login_res.cookies.get("access_token") # 1. Falta nombre -> 422 res_no_nombre = await client.post( "/api/v1/access/entry", json={ "modulo_ingreso_id": 100004, "documento": "11223344", "nombre": "", "lote_codigo": "100", "tipo_ingreso": "PEATON", }, cookies={"access_token": token}, ) assert res_no_nombre.status_code == 422 assert "nombre" in res_no_nombre.json()["detail"].lower() # 2. Falta lote -> 422 res_no_lote = await client.post( "/api/v1/access/entry", json={ "modulo_ingreso_id": 100004, "documento": "11223344", "nombre": "CARLOS", "tipo_ingreso": "PEATON", }, cookies={"access_token": token}, ) assert res_no_lote.status_code == 422 assert "lote" in res_no_lote.json()["detail"].lower() # 3. Conductor sin patente -> 422 res_no_patente = await client.post( "/api/v1/access/entry", json={ "modulo_ingreso_id": 100004, "documento": "11223344", "nombre": "CARLOS", "lote_codigo": "100", "tipo_ingreso": "CONDUCTOR", "patente": "", }, cookies={"access_token": token}, ) assert res_no_patente.status_code == 422 assert "patente" in res_no_patente.json()["detail"].lower() # 4. Conductor con seguro automotor vencido -> 403 res_seguro_vencido = await client.post( "/api/v1/access/entry", json={ "modulo_ingreso_id": 100004, "documento": "11223344", "nombre": "CARLOS", "lote_codigo": "100", "tipo_ingreso": "CONDUCTOR", "patente": "ABC123", "seguro_hasta": "2020-01-01", }, cookies={"access_token": token}, ) assert res_seguro_vencido.status_code == 403 assert "seguro" in res_seguro_vencido.json()["detail"].lower() # 5. Trabajador con ART vencida -> 403 res_art_vencida = await client.post( "/api/v1/access/entry", json={ "modulo_ingreso_id": 100004, "documento": "11223344", "nombre": "CARLOS", "lote_codigo": "100", "tipo_ingreso": "PEATON", "motivo": "TRABAJADOR DE OBRA", "art_hasta": "2021-05-10", }, cookies={"access_token": token}, ) assert res_art_vencida.status_code == 403 assert "art" in res_art_vencida.json()["detail"].lower() @pytest.mark.asyncio async def test_verificaciones_peaton_vs_conductor_hardware_pulse(monkeypatch): """ Verifica la regla de negocio de escritorio (pct_view.py:2861-2868 y 3088-3093): 1. Si es Peatón y el módulo es Barrera Vehicular (tipo_acceso=3 o 5): NO se envía pulso de apertura (barrier_opened == False). 2. Si es Peatón y el módulo es Molinete o Puerta (tipo_acceso in (1, 2, 7)): SÍ se envía pulso de apertura (barrier_opened == True). 3. Si es Conductor: SÍ se envía pulso de apertura independientemente del tipo de acceso (barrier_opened == True). """ transport = ASGITransport(app=app) async with AsyncClient(transport=transport, base_url="http://test") as client: login_res = await client.post( "/api/v1/auth/login", json={"username": "guardia", "password": "guardia"}, ) token = login_res.cookies.get("access_token") from app.services.hardware_service import HardwareService # Caso 1: Peatón en Molinete Club (100004 -> tipo_acceso=7) res_peaton_molinete = await client.post( "/api/v1/access/entry", json={ "modulo_ingreso_id": 100004, "documento": "88771122", "nombre": "PEATON MOLINETE", "lote_codigo": "100", "tipo_ingreso": "PEATON", "abrir_barrera": True, }, cookies={"access_token": token}, ) assert res_peaton_molinete.status_code == 200 data_molinete = res_peaton_molinete.json() assert data_molinete["barrier_opened"] is True assert "molinete" in data_molinete["message"].lower() or "habilitado" in data_molinete["message"].lower() # Egresar para no dejar ticket bloqueante await client.post( "/api/v1/access/exit", json={ "ticket_id": data_molinete["ticket_id"], "modulo_salida_id": 100005, "tipo_salida": "PEATON", "abrir_barrera": True, }, cookies={"access_token": token}, ) # Caso 2: Peatón en Barrera Vehicular (simulamos módulo tipo_acceso = 3: Barrera Estado) monkeypatch.setattr(HardwareService, "obtener_tipo_acceso", lambda mod_id: 3) res_peaton_barrera = await client.post( "/api/v1/access/entry", json={ "modulo_ingreso_id": 100004, "documento": "88771133", "nombre": "PEATON BARRERA", "lote_codigo": "100", "tipo_ingreso": "PEATON", "abrir_barrera": True, }, cookies={"access_token": token}, ) assert res_peaton_barrera.status_code == 200 data_barrera = res_peaton_barrera.json() # Regla clave: NO DEBE ABRIR LA BARRERA VEHICULAR A UN PEATÓN assert data_barrera["barrier_opened"] is False assert "no accionada" in data_barrera["message"].lower() # Caso 3: Salida Peatón en Barrera Vehicular -> Tampoco acciona barrera exit_res_barrera = await client.post( "/api/v1/access/exit", json={ "ticket_id": data_barrera["ticket_id"], "modulo_salida_id": 100005, "tipo_salida": "PEATON", "abrir_barrera": True, }, cookies={"access_token": token}, ) assert exit_res_barrera.status_code == 200 assert exit_res_barrera.json()["barrier_opened"] is False # Caso 4: Conductor en Barrera Vehicular -> SÍ acciona barrera res_conductor = await client.post( "/api/v1/access/entry", json={ "modulo_ingreso_id": 100004, "documento": "88771144", "nombre": "CONDUCTOR BARRERA", "lote_codigo": "100", "tipo_ingreso": "CONDUCTOR", "patente": "ABC789", "abrir_barrera": True, }, cookies={"access_token": token}, ) assert res_conductor.status_code == 200 data_cond = res_conductor.json() assert data_cond["barrier_opened"] is True # Salida Conductor -> SÍ acciona barrera exit_cond = await client.post( "/api/v1/access/exit", json={ "ticket_id": data_cond["ticket_id"], "modulo_salida_id": 100005, "patente_salida": "ABC789", "tipo_salida": "CONDUCTOR", "abrir_barrera": True, }, cookies={"access_token": token}, ) assert exit_cond.status_code == 200 assert exit_cond.json()["barrier_opened"] is True