540 lines
21 KiB
Python
540 lines
21 KiB
Python
"""
|
|
test_enrollment_and_commissions.py
|
|
Tests for the enrollment management system:
|
|
- StudentEnrollment model CRUD
|
|
- Commission management routes (Bedelia/Admin)
|
|
- /mis-materias routes per role (Docente, Alumno, Admin, Bedelia)
|
|
- RBAC enrollment permissions
|
|
- Bedelia role deduplication (no accented duplicate)
|
|
"""
|
|
import unittest
|
|
from app import create_app, db
|
|
from app.models.user import User
|
|
from app.models.role import Role, SYSTEM_MODULES
|
|
from app.models.subject import Subject, Commission
|
|
from app.models.enrollment import StudentEnrollment
|
|
|
|
|
|
def _login_as(client, user_id):
|
|
"""Helper: inject Flask-Login session for the given user id."""
|
|
with client.session_transaction() as sess:
|
|
sess['_user_id'] = str(user_id)
|
|
sess['_fresh'] = True
|
|
|
|
|
|
class TestStudentEnrollmentModel(unittest.TestCase):
|
|
"""Unit tests for the StudentEnrollment SQLAlchemy model."""
|
|
|
|
def setUp(self):
|
|
self.app = create_app()
|
|
self.app.config['TESTING'] = True
|
|
self.app.config['WTF_CSRF_ENABLED'] = False
|
|
self.ctx = self.app.app_context()
|
|
self.ctx.push()
|
|
|
|
def tearDown(self):
|
|
self.ctx.pop()
|
|
|
|
def test_table_exists(self):
|
|
"""student_enrollments table must exist in the database."""
|
|
result = db.session.execute(
|
|
db.text("SELECT to_regclass('public.student_enrollments')")
|
|
).scalar()
|
|
self.assertIsNotNone(result, "Tabla student_enrollments no existe en la BD")
|
|
|
|
def test_model_columns(self):
|
|
"""StudentEnrollment must expose all required columns."""
|
|
cols = {c.name for c in StudentEnrollment.__table__.columns}
|
|
for expected in ('id', 'student_id', 'commission_id', 'status', 'enrolled_at', 'notes'):
|
|
self.assertIn(expected, cols, f"Columna faltante: {expected}")
|
|
|
|
def test_unique_constraint_name(self):
|
|
"""Unique constraint uq_student_commission must exist."""
|
|
constraint_names = {c.name for c in StudentEnrollment.__table__.constraints}
|
|
self.assertIn('uq_student_commission', constraint_names)
|
|
|
|
def test_valid_statuses(self):
|
|
"""to_dict must return a status in the accepted set."""
|
|
alumno = User.query.filter(
|
|
User.role.ilike('%ALUMNO%'), User.is_active == True
|
|
).first()
|
|
comm = Commission.query.filter_by(active=True).first()
|
|
|
|
if not alumno or not comm:
|
|
self.skipTest("Se requiere al menos un alumno y una comision activa en la BD")
|
|
|
|
# Check if already enrolled to avoid integrity error
|
|
existing = StudentEnrollment.query.filter_by(
|
|
student_id=alumno.id, commission_id=comm.id
|
|
).first()
|
|
if not existing:
|
|
enr = StudentEnrollment(
|
|
student_id=alumno.id,
|
|
commission_id=comm.id,
|
|
status='activo',
|
|
notes='Test enrollment'
|
|
)
|
|
db.session.add(enr)
|
|
db.session.commit()
|
|
enrolled = enr
|
|
else:
|
|
enrolled = existing
|
|
|
|
d = enrolled.to_dict()
|
|
self.assertIn(d['status'], ['activo', 'retirado', 'condicional'])
|
|
self.assertEqual(d['student_id'], alumno.id)
|
|
self.assertEqual(d['commission_id'], comm.id)
|
|
|
|
# Cleanup (only if we created it)
|
|
if not existing:
|
|
db.session.delete(enrolled)
|
|
# Restore current_students counter
|
|
comm.current_students = max(0, (comm.current_students or 1) - 1)
|
|
db.session.commit()
|
|
|
|
def test_relationships_accessible(self):
|
|
"""student and commission relationships must resolve without error."""
|
|
enr = StudentEnrollment.query.first()
|
|
if enr:
|
|
_ = enr.student
|
|
_ = enr.commission
|
|
|
|
|
|
class TestRBACEnrollmentModule(unittest.TestCase):
|
|
"""Tests for the enrollment RBAC module and role permissions."""
|
|
|
|
def setUp(self):
|
|
self.app = create_app()
|
|
self.app.config['TESTING'] = True
|
|
self.ctx = self.app.app_context()
|
|
self.ctx.push()
|
|
|
|
def tearDown(self):
|
|
self.ctx.pop()
|
|
|
|
def test_enrollment_module_in_system_modules(self):
|
|
"""SYSTEM_MODULES must contain an 'enrollment' module."""
|
|
module_ids = [m['id'] for m in SYSTEM_MODULES]
|
|
self.assertIn('enrollment', module_ids,
|
|
"Modulo 'enrollment' no encontrado en SYSTEM_MODULES")
|
|
|
|
def test_bedelia_has_enrollment_read_write(self):
|
|
"""Bedelia role must have read_write on enrollment."""
|
|
bedelia = Role.query.filter_by(name='Bedelia').first()
|
|
self.assertIsNotNone(bedelia, "Rol 'Bedelia' no existe en la BD")
|
|
self.assertEqual(bedelia.get_permission('enrollment'), 'read_write')
|
|
self.assertTrue(bedelia.has_permission('enrollment', 'read_write'))
|
|
|
|
def test_admin_has_enrollment_read_write(self):
|
|
"""Admin role must have read_write on enrollment."""
|
|
admin = Role.query.filter_by(name='Admin').first()
|
|
self.assertIsNotNone(admin)
|
|
self.assertEqual(admin.get_permission('enrollment'), 'read_write')
|
|
|
|
def test_docente_has_enrollment_read(self):
|
|
"""Docente role must have read on enrollment (not write)."""
|
|
docente = Role.query.filter_by(name='Docente').first()
|
|
self.assertIsNotNone(docente)
|
|
self.assertTrue(docente.has_permission('enrollment', 'read'))
|
|
self.assertFalse(docente.has_permission('enrollment', 'read_write'))
|
|
|
|
def test_alumno_has_enrollment_read(self):
|
|
"""Alumno role must have read on enrollment."""
|
|
alumno_role = Role.query.filter_by(name='Alumno').first()
|
|
self.assertIsNotNone(alumno_role)
|
|
self.assertTrue(alumno_role.has_permission('enrollment', 'read'))
|
|
|
|
def test_no_duplicate_bedelia_roles(self):
|
|
"""There must be exactly one Bedelia role (no accented duplicate)."""
|
|
bedelia_variants = Role.query.filter(
|
|
Role.name.in_(['Bedelia', 'Bedelía', 'BEDELÍA'])
|
|
).all()
|
|
names = [r.name for r in bedelia_variants]
|
|
self.assertNotIn('Bedelía', names,
|
|
"Rol duplicado 'Bedelía' (con acento) todavía existe en la BD")
|
|
self.assertEqual(len(bedelia_variants), 1,
|
|
f"Se encontraron {len(bedelia_variants)} variantes de Bedelia: {names}")
|
|
|
|
|
|
class TestCommissionsManagementRoutes(unittest.TestCase):
|
|
"""Integration tests for /admin/commissions/ routes (Bedelia/Admin)."""
|
|
|
|
def setUp(self):
|
|
self.app = create_app()
|
|
self.app.config['TESTING'] = True
|
|
self.app.config['WTF_CSRF_ENABLED'] = False
|
|
self.client = self.app.test_client()
|
|
self.ctx = self.app.app_context()
|
|
self.ctx.push()
|
|
|
|
# Login as admin (first active user)
|
|
self.admin = User.query.filter_by(email='admin@edu-space.com').first()
|
|
self.bedelia = User.query.filter_by(email='bedelia@edu-space.com').first()
|
|
self.docente = User.query.filter_by(email='docente@edu-space.com').first()
|
|
self.alumno_user = User.query.filter_by(email='alumno@edu-space.com').first()
|
|
|
|
def tearDown(self):
|
|
self.ctx.pop()
|
|
|
|
def _login(self, user):
|
|
_login_as(self.client, user.id)
|
|
|
|
def test_commissions_list_accessible_by_admin(self):
|
|
"""Admin can access /admin/commissions."""
|
|
self._login(self.admin)
|
|
res = self.client.get('/admin/commissions')
|
|
self.assertEqual(res.status_code, 200)
|
|
html = res.get_data(as_text=True)
|
|
self.assertIn('Gestión de Comisiones', html)
|
|
|
|
def test_commissions_list_accessible_by_bedelia(self):
|
|
"""Bedelia can access /admin/commissions."""
|
|
if not self.bedelia:
|
|
self.skipTest("No bedelia user in DB")
|
|
self._login(self.bedelia)
|
|
res = self.client.get('/admin/commissions')
|
|
self.assertEqual(res.status_code, 200)
|
|
|
|
def test_commissions_list_forbidden_for_docente(self):
|
|
"""Docente without manage permissions should get 403 on /admin/commissions."""
|
|
if not self.docente:
|
|
self.skipTest("No docente user in DB")
|
|
self._login(self.docente)
|
|
res = self.client.get('/admin/commissions')
|
|
# Docente has 'academic: read' → can_manage() is False → 403
|
|
self.assertIn(res.status_code, [403, 302])
|
|
|
|
def test_commission_detail_accessible_by_admin(self):
|
|
"""Commission detail page returns 200 for an existing commission."""
|
|
self._login(self.admin)
|
|
comm = Commission.query.filter_by(active=True).first()
|
|
if not comm:
|
|
self.skipTest("No active commission in DB")
|
|
res = self.client.get(f'/admin/commissions/{comm.id}')
|
|
self.assertEqual(res.status_code, 200)
|
|
html = res.get_data(as_text=True)
|
|
self.assertIn('Alumnos Inscriptos', html)
|
|
self.assertIn('Docente Asignado', html)
|
|
|
|
def test_commission_detail_accessible_by_bedelia(self):
|
|
"""Bedelia can view commission detail."""
|
|
if not self.bedelia:
|
|
self.skipTest("No bedelia user in DB")
|
|
self._login(self.bedelia)
|
|
comm = Commission.query.filter_by(active=True).first()
|
|
if not comm:
|
|
self.skipTest("No active commission in DB")
|
|
res = self.client.get(f'/admin/commissions/{comm.id}')
|
|
self.assertEqual(res.status_code, 200)
|
|
|
|
def test_commission_detail_nonexistent_returns_404(self):
|
|
"""Non-existent commission ID must return 404."""
|
|
self._login(self.admin)
|
|
res = self.client.get('/admin/commissions/999999')
|
|
self.assertEqual(res.status_code, 404)
|
|
|
|
def test_assign_teacher_post(self):
|
|
"""Bedelia can POST to assign a teacher to a commission."""
|
|
if not self.bedelia or not self.docente:
|
|
self.skipTest("Need bedelia and docente users")
|
|
self._login(self.bedelia)
|
|
comm = Commission.query.filter_by(active=True).first()
|
|
if not comm:
|
|
self.skipTest("No active commission in DB")
|
|
|
|
res = self.client.post(
|
|
f'/admin/commissions/{comm.id}/assign-teacher',
|
|
data={'teacher_id': self.docente.id},
|
|
follow_redirects=True
|
|
)
|
|
self.assertEqual(res.status_code, 200)
|
|
# Verify assignment persisted
|
|
db.session.refresh(comm)
|
|
self.assertEqual(comm.teacher_id, self.docente.id)
|
|
|
|
def test_enroll_student_and_unenroll(self):
|
|
"""Bedelia can enroll and unenroll an alumno in a commission."""
|
|
if not self.bedelia or not self.alumno_user:
|
|
self.skipTest("Need bedelia and alumno users")
|
|
self._login(self.bedelia)
|
|
comm = Commission.query.filter_by(active=True).first()
|
|
if not comm:
|
|
self.skipTest("No active commission in DB")
|
|
|
|
# Clean up any prior enrollment to ensure idempotent test
|
|
prior = StudentEnrollment.query.filter_by(
|
|
student_id=self.alumno_user.id, commission_id=comm.id
|
|
).first()
|
|
if prior:
|
|
db.session.delete(prior)
|
|
db.session.commit()
|
|
|
|
prev_count = comm.current_students or 0
|
|
|
|
# Enroll
|
|
res = self.client.post(
|
|
f'/admin/commissions/{comm.id}/enroll-student',
|
|
data={'student_id': self.alumno_user.id, 'notes': 'Test'},
|
|
follow_redirects=True
|
|
)
|
|
self.assertEqual(res.status_code, 200)
|
|
enr = StudentEnrollment.query.filter_by(
|
|
student_id=self.alumno_user.id, commission_id=comm.id
|
|
).first()
|
|
self.assertIsNotNone(enr, "Inscripción no encontrada tras POST enroll")
|
|
self.assertEqual(enr.status, 'activo')
|
|
db.session.refresh(comm)
|
|
self.assertEqual(comm.current_students, prev_count + 1)
|
|
|
|
# Unenroll
|
|
res2 = self.client.post(
|
|
f'/admin/commissions/{comm.id}/unenroll-student/{self.alumno_user.id}',
|
|
follow_redirects=True
|
|
)
|
|
self.assertEqual(res2.status_code, 200)
|
|
enr_after = StudentEnrollment.query.filter_by(
|
|
student_id=self.alumno_user.id, commission_id=comm.id
|
|
).first()
|
|
self.assertIsNone(enr_after, "Inscripción debería haber sido eliminada")
|
|
db.session.refresh(comm)
|
|
self.assertEqual(comm.current_students, prev_count)
|
|
|
|
def test_update_enrollment_status(self):
|
|
"""Bedelia can change enrollment status (activo→condicional→retirado)."""
|
|
if not self.bedelia or not self.alumno_user:
|
|
self.skipTest("Need bedelia and alumno users")
|
|
self._login(self.bedelia)
|
|
comm = Commission.query.filter_by(active=True).first()
|
|
if not comm:
|
|
self.skipTest("No active commission in DB")
|
|
|
|
# Ensure enrollment exists
|
|
enr = StudentEnrollment.query.filter_by(
|
|
student_id=self.alumno_user.id, commission_id=comm.id
|
|
).first()
|
|
if not enr:
|
|
enr = StudentEnrollment(
|
|
student_id=self.alumno_user.id,
|
|
commission_id=comm.id,
|
|
status='activo'
|
|
)
|
|
db.session.add(enr)
|
|
db.session.commit()
|
|
|
|
for new_status in ['condicional', 'retirado', 'activo']:
|
|
res = self.client.post(
|
|
f'/admin/commissions/{comm.id}/update-enrollment/{self.alumno_user.id}',
|
|
data={'status': new_status},
|
|
follow_redirects=True
|
|
)
|
|
self.assertEqual(res.status_code, 200)
|
|
db.session.refresh(enr)
|
|
self.assertEqual(enr.status, new_status)
|
|
|
|
# Cleanup
|
|
db.session.delete(enr)
|
|
db.session.commit()
|
|
|
|
def test_duplicate_enrollment_rejected(self):
|
|
"""Enrolling the same student twice in the same commission is rejected."""
|
|
if not self.bedelia or not self.alumno_user:
|
|
self.skipTest("Need bedelia and alumno users")
|
|
self._login(self.bedelia)
|
|
comm = Commission.query.filter_by(active=True).first()
|
|
if not comm:
|
|
self.skipTest("No active commission in DB")
|
|
|
|
# Ensure a clean start
|
|
prior = StudentEnrollment.query.filter_by(
|
|
student_id=self.alumno_user.id, commission_id=comm.id
|
|
).first()
|
|
if not prior:
|
|
enr = StudentEnrollment(
|
|
student_id=self.alumno_user.id,
|
|
commission_id=comm.id,
|
|
status='activo'
|
|
)
|
|
db.session.add(enr)
|
|
db.session.commit()
|
|
|
|
# Second enroll attempt
|
|
res = self.client.post(
|
|
f'/admin/commissions/{comm.id}/enroll-student',
|
|
data={'student_id': self.alumno_user.id},
|
|
follow_redirects=True
|
|
)
|
|
self.assertEqual(res.status_code, 200)
|
|
# Should see a warning message, and only one enrollment should exist
|
|
count = StudentEnrollment.query.filter_by(
|
|
student_id=self.alumno_user.id, commission_id=comm.id
|
|
).count()
|
|
self.assertEqual(count, 1)
|
|
|
|
# Cleanup
|
|
StudentEnrollment.query.filter_by(
|
|
student_id=self.alumno_user.id, commission_id=comm.id
|
|
).delete()
|
|
db.session.commit()
|
|
|
|
|
|
class TestMySubjectsRoutes(unittest.TestCase):
|
|
"""/mis-materias route tests per role."""
|
|
|
|
def setUp(self):
|
|
self.app = create_app()
|
|
self.app.config['TESTING'] = True
|
|
self.app.config['WTF_CSRF_ENABLED'] = False
|
|
self.client = self.app.test_client()
|
|
self.ctx = self.app.app_context()
|
|
self.ctx.push()
|
|
|
|
self.admin = User.query.filter_by(email='admin@edu-space.com').first()
|
|
self.bedelia = User.query.filter_by(email='bedelia@edu-space.com').first()
|
|
self.docente = User.query.filter_by(email='docente@edu-space.com').first()
|
|
self.alumno_user = User.query.filter_by(email='alumno@edu-space.com').first()
|
|
|
|
def tearDown(self):
|
|
self.ctx.pop()
|
|
|
|
def _login(self, user):
|
|
_login_as(self.client, user.id)
|
|
|
|
def test_mis_materias_requires_login(self):
|
|
"""Unauthenticated request to /mis-materias/ must redirect to login."""
|
|
res = self.client.get('/mis-materias/')
|
|
self.assertIn(res.status_code, [302, 401])
|
|
|
|
def test_mis_materias_admin_ok(self):
|
|
"""Admin sees all commissions at /mis-materias/."""
|
|
self._login(self.admin)
|
|
res = self.client.get('/mis-materias/')
|
|
self.assertEqual(res.status_code, 200)
|
|
html = res.get_data(as_text=True)
|
|
self.assertIn('Todas las Comisiones', html)
|
|
|
|
def test_mis_materias_bedelia_ok(self):
|
|
"""Bedelia sees all commissions at /mis-materias/."""
|
|
if not self.bedelia:
|
|
self.skipTest("No bedelia user")
|
|
self._login(self.bedelia)
|
|
res = self.client.get('/mis-materias/')
|
|
self.assertEqual(res.status_code, 200)
|
|
|
|
def test_mis_materias_docente_ok(self):
|
|
"""Docente gets 200 at /mis-materias/ (even with no assigned commissions)."""
|
|
if not self.docente:
|
|
self.skipTest("No docente user")
|
|
self._login(self.docente)
|
|
res = self.client.get('/mis-materias/')
|
|
self.assertEqual(res.status_code, 200)
|
|
html = res.get_data(as_text=True)
|
|
self.assertIn('Mis Materias', html)
|
|
|
|
def test_mis_materias_alumno_ok(self):
|
|
"""Alumno gets 200 at /mis-materias/ (even with no enrollments)."""
|
|
if not self.alumno_user:
|
|
self.skipTest("No alumno user")
|
|
self._login(self.alumno_user)
|
|
res = self.client.get('/mis-materias/')
|
|
self.assertEqual(res.status_code, 200)
|
|
html = res.get_data(as_text=True)
|
|
self.assertIn('Mis Materias', html)
|
|
|
|
def test_mis_materias_detail_enrolled_alumno(self):
|
|
"""Alumno enrolled in a commission can see its detail page."""
|
|
if not self.alumno_user:
|
|
self.skipTest("No alumno user")
|
|
|
|
comm = Commission.query.filter_by(active=True).first()
|
|
if not comm:
|
|
self.skipTest("No active commission in DB")
|
|
|
|
# Create temporary enrollment
|
|
enr = StudentEnrollment.query.filter_by(
|
|
student_id=self.alumno_user.id, commission_id=comm.id
|
|
).first()
|
|
cleanup_needed = False
|
|
if not enr:
|
|
enr = StudentEnrollment(
|
|
student_id=self.alumno_user.id,
|
|
commission_id=comm.id,
|
|
status='activo'
|
|
)
|
|
db.session.add(enr)
|
|
db.session.commit()
|
|
cleanup_needed = True
|
|
|
|
self._login(self.alumno_user)
|
|
res = self.client.get(f'/mis-materias/{comm.id}')
|
|
self.assertEqual(res.status_code, 200)
|
|
html = res.get_data(as_text=True)
|
|
self.assertIn('Tu inscripción', html)
|
|
|
|
if cleanup_needed:
|
|
db.session.delete(enr)
|
|
db.session.commit()
|
|
|
|
def test_mis_materias_detail_forbidden_for_unenrolled_alumno(self):
|
|
"""Alumno NOT enrolled in a commission gets 403 on its detail page."""
|
|
if not self.alumno_user:
|
|
self.skipTest("No alumno user")
|
|
|
|
comm = Commission.query.filter_by(active=True).first()
|
|
if not comm:
|
|
self.skipTest("No active commission in DB")
|
|
|
|
# Ensure alumno is NOT enrolled
|
|
StudentEnrollment.query.filter_by(
|
|
student_id=self.alumno_user.id, commission_id=comm.id
|
|
).delete()
|
|
db.session.commit()
|
|
|
|
self._login(self.alumno_user)
|
|
res = self.client.get(f'/mis-materias/{comm.id}')
|
|
self.assertEqual(res.status_code, 403)
|
|
|
|
def test_mis_materias_detail_docente_own_commission(self):
|
|
"""Docente can see detail of their own assigned commission."""
|
|
if not self.docente:
|
|
self.skipTest("No docente user")
|
|
|
|
comm = Commission.query.filter_by(active=True).first()
|
|
if not comm:
|
|
self.skipTest("No active commission in DB")
|
|
|
|
# Assign commission to docente
|
|
prev_teacher = comm.teacher_id
|
|
comm.teacher_id = self.docente.id
|
|
db.session.commit()
|
|
|
|
self._login(self.docente)
|
|
res = self.client.get(f'/mis-materias/{comm.id}')
|
|
self.assertEqual(res.status_code, 200)
|
|
html = res.get_data(as_text=True)
|
|
self.assertIn(comm.subject.name, html)
|
|
|
|
# Restore
|
|
comm.teacher_id = prev_teacher
|
|
db.session.commit()
|
|
|
|
def test_mis_materias_detail_docente_unauthorized_commission(self):
|
|
"""Docente cannot see a commission they are not assigned to."""
|
|
if not self.docente:
|
|
self.skipTest("No docente user")
|
|
|
|
# Find a commission where docente is NOT the teacher
|
|
comm = Commission.query.filter(
|
|
Commission.active == True,
|
|
Commission.teacher_id != self.docente.id
|
|
).first()
|
|
if not comm:
|
|
self.skipTest("No commission without this docente in DB")
|
|
|
|
self._login(self.docente)
|
|
res = self.client.get(f'/mis-materias/{comm.id}')
|
|
self.assertEqual(res.status_code, 403)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main(verbosity=2)
|