488 lines
18 KiB
Python
488 lines
18 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/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
|
|
|
|
|
|
|