Files
admin-edu-space/backend/tests/test_ai_chat.py
T

431 lines
15 KiB
Python

"""
Suite de pruebas automatizadas para el módulo de Asistente IA (SDD-009).
Valida contratos Pydantic v2, inyección de System Prompts por rol,
llamadas asíncronas con httpx (mockeadas) y gestión de configuración administrativa.
"""
from unittest.mock import AsyncMock, patch, MagicMock
import pytest
from pydantic import ValidationError
from fastapi.testclient import TestClient
import httpx
from werkzeug.security import generate_password_hash
from main import app
from schemas.ai_chat import ChatMessage, ChatRequest, ChatResponse, AISettingsSchema
from routers.ai_chat import generate_system_prompt_for_role
from app.models.setting import SystemSetting
from app.models.user import User
def test_ai_chat_pydantic_schemas_validation():
"""Valida restricciones de datos y tipos en Pydantic v2."""
# 1. ChatMessage válido
msg = ChatMessage(role="user", content="¿Dónde curso hoy?")
assert msg.role == "user"
assert msg.content == "¿Dónde curso hoy?"
# 2. Rechazo por rol inválido
with pytest.raises(ValidationError):
ChatMessage(role="hacker", content="Mensaje")
# 3. Rechazo por contenido vacío
with pytest.raises(ValidationError):
ChatMessage(role="user", content="")
# 4. ChatRequest válido
req = ChatRequest(messages=[msg], user_role="docente")
assert len(req.messages) == 1
assert req.user_role == "docente"
# 5. ChatRequest rechaza lista vacía de mensajes
with pytest.raises(ValidationError):
ChatRequest(messages=[], user_role="alumno")
# 6. AISettingsSchema con validaciones de rango
ai_settings = AISettingsSchema(temperature=0.7, timeout=120)
assert ai_settings.temperature == 0.7
assert ai_settings.timeout == 120
with pytest.raises(ValidationError):
AISettingsSchema(temperature=3.5) # Mayor a 2.0
def test_system_prompt_generation_by_role():
"""Verifica que el System Prompt inyectado se adapte rigurosamente al rol y contenga UdeCi y RAG."""
# Docente
prompt_docente = generate_system_prompt_for_role("docente")
assert "UdeCi" in prompt_docente
assert "DOCENTE" in prompt_docente
assert "INFORMACIÓN OFICIAL DEL SISTEMA (RAG)" in prompt_docente
# Alumno
prompt_alumno = generate_system_prompt_for_role("alumno")
assert "UdeCi" in prompt_alumno
assert "ALUMNO" in prompt_alumno
assert "INFORMACIÓN OFICIAL DEL SISTEMA (RAG)" in prompt_alumno
# Bedelía
prompt_bedelia = generate_system_prompt_for_role("bedelia", user_name="Juan")
assert "UdeCi" in prompt_bedelia
assert "Juan" in prompt_bedelia
assert ("BEDELÍA" in prompt_bedelia or "BEDELIA" in prompt_bedelia)
assert "INFORMACIÓN OFICIAL DEL SISTEMA (RAG)" in prompt_bedelia
# Admin
prompt_admin = generate_system_prompt_for_role("admin", user_name="Carlos")
assert "UdeCi" in prompt_admin
assert "Carlos" in prompt_admin
assert "ADMINISTRADOR" in prompt_admin
assert "Gobierno & Sistema" in prompt_admin
def test_ai_chat_public_config_endpoint():
"""Verifica el endpoint público /api/chat/config utilizado por el widget."""
client = TestClient(app)
response = client.get("/api/chat/config")
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
assert "enabled" in data
assert data["name"] == "UdeCi"
assert "role" in data
assert "default_options" in data
def test_ai_chat_endpoint_success_mock(init_database):
"""Simula una respuesta exitosa 200 de Llama.cpp."""
client = TestClient(app)
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.json.return_value = {
"choices": [
{
"message": {
"role": "assistant",
"content": "Para consultar el aula de cursada hoy, accede a la Cartelera de Clases en tu panel principal."
}
}
]
}
mock_response.raise_for_status = MagicMock()
with patch("httpx.AsyncClient.post", new_callable=AsyncMock) as mock_post:
mock_post.return_value = mock_response
# Prueba en /api/chat
res = client.post("/api/chat", json={
"messages": [{"role": "user", "content": "¿En qué aula curso hoy?"}],
"user_role": "alumno"
})
assert res.status_code == 200
data = res.json()
assert "response" in data
assert "Cartelera" in data["response"]
# Prueba en /api/v1/chat
res_v1 = client.post("/api/v1/chat", json={
"messages": [{"role": "user", "content": "¿Cómo reservo un aula?"}],
"user_role": "docente"
})
assert res_v1.status_code == 200
def test_ai_chat_endpoint_validation_error():
"""Valida que una petición malformada responda 422 Unprocessable Entity."""
client = TestClient(app)
# Mensajes vacíos
res = client.post("/api/chat", json={
"messages": [],
"user_role": "alumno"
})
assert res.status_code == 422
# Mensaje sin contenido
res2 = client.post("/api/chat", json={
"messages": [{"role": "user", "content": ""}]
})
assert res2.status_code == 422
def test_ai_chat_endpoint_connection_failure(init_database):
"""Simula error de conexión con el servidor Llama.cpp y verifica HTTP 503."""
client = TestClient(app)
with patch("httpx.AsyncClient.post", new_callable=AsyncMock) as mock_post:
mock_post.side_effect = httpx.ConnectError("Connection refused")
res = client.post("/api/chat", json={
"messages": [{"role": "user", "content": "Hola tutor"}]
})
assert res.status_code == 503
data = res.json()
assert "detail" in data
assert "UdeCi" in data["detail"] or "servidor local de IA" in data["detail"]
def test_ai_chat_endpoint_timeout_failure(init_database):
"""Simula tiempo de espera agotado y verifica HTTP 504."""
client = TestClient(app)
with patch("httpx.AsyncClient.post", new_callable=AsyncMock) as mock_post:
mock_post.side_effect = httpx.TimeoutException("Read timed out")
res = client.post("/api/chat", json={
"messages": [{"role": "user", "content": "Pregunta compleja"}]
})
assert res.status_code == 504
data = res.json()
assert "tiempo límite" in data["detail"]
def test_ai_chat_disabled_flow(init_database):
"""Verifica que si ai_chat_enabled es false, se retorne 503 inmediatamente."""
client = TestClient(app)
SystemSetting.set_value("ai_chat_enabled", "false", category="ai")
try:
res = client.post("/api/chat", json={
"messages": [{"role": "user", "content": "Test"}]
})
assert res.status_code == 503
assert "deshabilitado" in res.json()["detail"].lower()
finally:
SystemSetting.set_value("ai_chat_enabled", "true", category="ai")
def test_admin_settings_ai_crud_and_test_connection(init_database):
"""Verifica los endpoints administrativos de guardado y prueba de conexión de IA."""
client = TestClient(app)
# 1. Crear usuario Admin
u = User(
email="admin.ai@unicaba.edu.ar",
name="Admin AI Settings",
password_hash=generate_password_hash("AiAdminSecret!"),
role="ADMIN",
is_active=True
)
init_database.session.add(u)
init_database.session.commit()
# Login
login_res = client.post("/api/v1/auth/login", json={
"email": "admin.ai@unicaba.edu.ar",
"password": "AiAdminSecret!"
})
token = login_res.json()["access_token"]
headers = {"Authorization": f"Bearer {token}"}
# 2. Consultar GET /admin/settings/all
all_res = client.get("/api/v1/settings/all", headers=headers)
assert all_res.status_code == 200
all_data = all_res.json()
assert "ai" in all_data["settings"]
assert all_data["settings"]["ai"]["model"] == "qwen3-coder:30b"
# 3. Actualizar POST /admin/settings/ai
update_res = client.post("/api/v1/settings/ai", headers=headers, json={
"enabled": True,
"base_url": "http://10.0.0.214:8080/v1",
"api_key": "new_secret_key",
"model": "qwen3-coder:30b",
"model_name": "Qwen3 Coder 30B (Test)",
"temperature": 0.25,
"timeout": 45,
"context_limit": 32768,
"output_limit": 16384
})
assert update_res.status_code == 200
assert update_res.json()["status"] == "success"
# Verificar persistencia en base de datos
assert SystemSetting.get_value("ai_chat_model_name") == "Qwen3 Coder 30B (Test)"
assert SystemSetting.get_decrypted_value("ai_chat_api_key") == "new_secret_key"
# 4. Probar conexión POST /admin/settings/ai/test con mock
mock_models_resp = MagicMock()
mock_models_resp.status_code = 200
mock_models_resp.json.return_value = {
"data": [{"id": "qwen3-coder:30b"}, {"id": "llama-3-8b"}]
}
with patch("httpx.AsyncClient.get", new_callable=AsyncMock) as mock_get:
mock_get.return_value = mock_models_resp
test_res = client.post("/api/v1/settings/ai/test", headers=headers, json={
"base_url": "http://10.0.0.214:8080/v1",
"api_key": "new_secret_key"
})
assert test_res.status_code == 200
test_data = test_res.json()
assert test_data["status"] == "success"
assert "qwen3-coder:30b" in test_data["models"]
assert test_data["latency_ms"] is not None
def test_live_context_service_roles_and_entities(init_database):
"""Verifica la extracción contextual de entidades reales adaptada a cada rol."""
from app.services.live_context_service import LiveContextService
from app.models.career import Career
from app.models.subject import Subject, Commission
from app.models.classroom import Classroom
from app.models.enrollment import StudentEnrollment
from app import db
# 1. Crear entidades de prueba
career = Career(name="Ingeniería en Software", code="ING-SOFT")
db.session.add(career)
db.session.flush()
subj = Subject(name="Algoritmos y Estructuras de Datos", code="ALG101", career_id=career.id)
db.session.add(subj)
db.session.flush()
teacher = User(
name="Profesor Alan Turing",
email="turing@unicaba.edu.ar",
role="Docente",
is_active=True
)
teacher.set_password("pass123")
student = User(
name="Ada Lovelace",
email="ada@unicaba.edu.ar",
role="Alumno",
is_active=True
)
student.set_password("pass123")
db.session.add_all([teacher, student])
db.session.flush()
comm = Commission(
subject_id=subj.id,
code="C1",
semester="1C",
year=2026,
teacher_id=teacher.id,
max_students=30,
current_students=1,
schedule="Martes 18:00 a 22:00",
shift="Noche"
)
db.session.add(comm)
db.session.flush()
enrollment = StudentEnrollment(
student_id=student.id,
commission_id=comm.id,
status="activo"
)
classroom = Classroom(
building="Sede Central",
code="Aula 204",
floor="2",
capacity=40,
is_active=True
)
db.session.add_all([enrollment, classroom])
db.session.flush()
# Hito evaluativo y Calificación
from app.models.milestone import MilestoneType, AcademicMilestone
from app.models.grade import MilestoneGrade
from app.models.reservation import Reservation
from datetime import datetime, timedelta
m_type = MilestoneType(name="Primer Parcial", code="p1_test", is_active=True)
db.session.add(m_type)
db.session.flush()
milestone = AcademicMilestone(
title="Parcial 1 Algoritmos",
materia_codigo="ALG101",
subject_id=subj.id,
commission_id=comm.id,
milestone_type_id=m_type.id,
date=datetime.now() + timedelta(days=5),
classroom="Aula 204"
)
db.session.add(milestone)
db.session.flush()
grade = MilestoneGrade(
milestone_id=milestone.id,
enrollment_id=enrollment.id,
student_id=student.id,
score=9.0,
feedback="Excelente desarrollo en grafos y árboles"
)
db.session.add(grade)
# Próxima reserva física presencial
res_future = Reservation(
classroom_id=classroom.id,
commission_id=comm.id,
user_id=teacher.id,
start_time=datetime.now() + timedelta(days=2, hours=3),
end_time=datetime.now() + timedelta(days=2, hours=6),
purpose="Clase presencial teórica",
expected_attendees=25,
status="CONFIRMED"
)
db.session.add(res_future)
db.session.commit()
# 2. Snapshot para Alumno
alumno_snapshot = LiveContextService.get_system_snapshot(
role="alumno",
user_id=str(student.id),
user_email=student.email,
user_name=student.name
)
assert "DATOS DE CURSADA DEL ALUMNO" in alumno_snapshot
assert "Algoritmos y Estructuras de Datos" in alumno_snapshot
assert "Comisión C1" in alumno_snapshot
assert "Alan Turing" in alumno_snapshot
# Verificación de notas del alumno
assert "CALIFICACIONES Y ESTADO ACADÉMICO" in alumno_snapshot
assert "Nota: 9" in alumno_snapshot
assert "Excelente desarrollo" in alumno_snapshot
# Verificación de próxima presencial
assert "PRÓXIMA CLASE PRESENCIAL" in alumno_snapshot
assert "Aula 204" in alumno_snapshot
# 3. Snapshot para Docente
docente_snapshot = LiveContextService.get_system_snapshot(
role="docente",
user_id=str(teacher.id),
user_email=teacher.email,
user_name=teacher.name
)
assert "DATOS ACADÉMICOS DEL DOCENTE" in docente_snapshot
assert "COMISIONES A TU CARGO" in docente_snapshot
assert "Algoritmos y Estructuras de Datos" in docente_snapshot
# Verificación de notas de alumnos para el docente
assert "NOTAS Y CALIFICACIONES DE TUS ALUMNOS" in docente_snapshot
assert "Ada Lovelace" in docente_snapshot
assert "Parcial 1 Algoritmos: 9" in docente_snapshot
# Verificación de hitos del docente
assert "HITOS EVALUATIVOS Y FECHAS DE EXAMEN" in docente_snapshot
assert "Parcial 1 Algoritmos" in docente_snapshot
# 4. Snapshot para Bedelía
bedelia_snapshot = LiveContextService.get_system_snapshot(role="bedelia")
assert "BALANCE OPERATIVO DE BEDELÍA" in bedelia_snapshot
assert "Comisiones activas" in bedelia_snapshot
# 5. Snapshot para Administrador
admin_snapshot = LiveContextService.get_system_snapshot(role="admin")
assert "GOBIERNO Y ESTADÍSTICAS DEL SISTEMA" in admin_snapshot
assert "Alumnos" in admin_snapshot
# 6. Búsqueda por palabras clave en query
query_snapshot = LiveContextService.get_system_snapshot(
role="alumno",
query="¿Dónde curso algoritmos?"
)
assert "ASIGNATURAS COINCIDENTES" in query_snapshot
assert "ALG101" in query_snapshot