Files

578 lines
21 KiB
Python

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/100009/open",
json={"modulo_id": 100009, "motivo": "TEST_AUDIT"},
cookies={"access_token": token},
)
assert res.status_code == 200
data = res.json()
assert data["status"] == "ok"
assert data["modulo_id"] == 100009
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")
import time
doc_test = f"99{str(int(time.time()))[-6:]}"
# 1. Registro de Ingreso
entry_payload = {
"modulo_ingreso_id": 100009,
"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": 100010,
"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 (100009, 100010) 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": 100009,
"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": 100010,
"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": 100009,
"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": 100009,
"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": 100009,
"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": 100009,
"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": 100009,
"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
import time
suffix = str(int(time.time()))[-5:]
doc_mol = f"81{suffix}1"
doc_bar = f"81{suffix}2"
doc_cnd = f"81{suffix}3"
# Caso 1: Peatón en Molinete / Puerta Peatonal (100007 -> tipo_acceso=1)
res_peaton_molinete = await client.post(
"/api/v1/access/entry",
json={
"modulo_ingreso_id": 100007,
"documento": doc_mol,
"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 "habilitado" in data_molinete["message"].lower() or "molinete" in data_molinete["message"].lower() or "puerta" 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": 100008,
"tipo_salida": "PEATON",
"abrir_barrera": True,
},
cookies={"access_token": token},
)
# Caso 2: Peatón en Barrera Vehicular (100009 -> tipo_acceso=5)
res_peaton_barrera = await client.post(
"/api/v1/access/entry",
json={
"modulo_ingreso_id": 100009,
"documento": doc_bar,
"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": 100010,
"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": 100009,
"documento": doc_cnd,
"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": 100010,
"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
@pytest.mark.asyncio
async def test_lote_residents_and_cacheo_garita():
"""
Verifica las capacidades del buscador de lotes y el sistema de cacheo de garita:
1. Consulta de padrón de residentes del lote (GET /api/v1/access/lots/{id}/residents).
2. Validación obligatoria de lote (rechazo 422 si lote_id <= 0).
3. Registro de ingreso vehicular con flags de Cacheo a la Salida e Inspección de Baúl.
4. Comprobación de que el ticket activo conserva cacheo_salida=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")
# 1. Padrón de residentes de un lote
res_padron = await client.get(
"/api/v1/access/lots/100000/residents",
cookies={"access_token": token},
)
assert res_padron.status_code == 200
assert isinstance(res_padron.json(), list)
# 2. Validación obligatoria de lote
res_sin_lote = await client.post(
"/api/v1/access/entry",
json={
"modulo_ingreso_id": 100009,
"documento": "99112233",
"nombre": "SIN LOTE",
"tipo_ingreso": "PEATON",
"lote_id": 0,
"lote_codigo": "",
},
cookies={"access_token": token},
)
assert res_sin_lote.status_code == 422
assert "lote" in res_sin_lote.json()["detail"].lower()
# 3. Registro con cacheo y baúl inspeccionado
import time
doc_cch = f"95{str(int(time.time()))[-5:]}"
res_cch = await client.post(
"/api/v1/access/entry",
json={
"modulo_ingreso_id": 100009,
"documento": doc_cch,
"apellido": "GARCIA",
"nombre": "IGNACIO",
"lote_id": 100000,
"tipo_ingreso": "CONDUCTOR",
"patente": "CACH01",
"cacheo_salida": True,
"baul_inspeccionado": True,
"abrir_barrera": True,
},
cookies={"access_token": token},
)
assert res_cch.status_code == 200
tck_id = res_cch.json()["ticket_id"]
# 4. Validar en tickets activos
act_res = await client.get("/api/v1/access/tickets/active", cookies={"access_token": token})
assert act_res.status_code == 200
tickets = act_res.json()
encontrado = next((t for t in tickets if t["ticket_id"] == tck_id), None)
assert encontrado is not None
assert encontrado["cacheo_salida"] is True
# Egresar
await client.post(
"/api/v1/access/exit",
json={
"ticket_id": tck_id,
"modulo_salida_id": 100010,
"patente_salida": "CACH01",
"tipo_salida": "CONDUCTOR",
},
cookies={"access_token": token},
)