feat: add tests

tests/README.md

@@ -0,0 +1,95 @@
+# Tests Unitaires
+
+Ce dossier contient les tests unitaires pour l'application de gestion scolaire.
+
+## Structure des tests
+
+```
+tests/
+├── __init__.py
+├── conftest.py              # Configuration globale des tests
+├── test_app.py             # Tests de l'application Flask
+├── test_models.py          # Tests des modèles SQLAlchemy
+├── test_forms.py           # Tests des formulaires WTForms
+├── test_services.py        # Tests des services métier
+├── test_routes_assessments.py  # Tests des routes d'évaluations
+└── test_utils.py           # Tests des utilitaires
+```
+
+## Exécution des tests
+
+### Avec uv (recommandé)
+
+```bash
+# Installer les dépendances de test
+uv sync
+
+# Exécuter tous les tests
+uv run pytest tests/ -v
+
+# Exécuter avec couverture de code
+uv run pytest tests/ --cov=. --cov-report=html
+
+# Exécuter des tests spécifiques
+uv run pytest tests/test_models.py -v
+uv run pytest tests/test_models.py::TestClassGroup -v
+```
+
+### Avec le script personnalisé
+
+```bash
+# Tous les tests
+uv run python run_tests.py
+
+# Avec rapport de couverture
+uv run python run_tests.py --coverage
+
+# Tests d'un fichier spécifique
+uv run python run_tests.py test_models.py
+
+# Mode silencieux
+uv run python run_tests.py --quiet
+```
+
+## Configuration
+
+Les tests utilisent:
+- **pytest** comme framework de test
+- **pytest-flask** pour l'intégration Flask
+- **pytest-cov** pour la couverture de code
+- **SQLite en mémoire** pour les tests de base de données
+
+## Couverture des tests
+
+Les tests couvrent:
+- ✅ Modèles SQLAlchemy (création, validation, relations)
+- ✅ Configuration de l'application Flask
+- ✅ Services métier (AssessmentService)
+- ✅ Utilitaires (validation, gestion d'erreurs)
+- ✅ Formulaires WTForms (validation)
+- ✅ Routes principales (responses HTTP)
+
+## Bonnes pratiques
+
+1. **Isolation**: Chaque test utilise une base de données temporaire
+2. **Fixtures**: Configuration partagée dans `conftest.py`
+3. **Nommage**: Tests préfixés par `test_`
+4. **Organisation**: Tests groupés par classe selon la fonctionnalité
+5. **Assertions**: Vérifications claires et spécifiques
+
+## Ajout de nouveaux tests
+
+Pour ajouter de nouveaux tests:
+
+1. Créer un fichier `test_<module>.py`
+2. Importer les fixtures nécessaires
+3. OU utiliser les fixtures existantes (`app`, `client`)
+4. Suivre la convention de nommage
+
+Exemple:
+```python
+def test_my_function(app):
+    with app.app_context():
+        # Votre test ici
+        assert True
+```

tests/conftest.py

@@ -0,0 +1,35 @@
+import pytest
+import tempfile
+import os
+from app import create_app
+from models import db
+
+
+@pytest.fixture
+def app():
+    db_fd, db_path = tempfile.mkstemp()
+    
+    app = create_app('testing')
+    app.config.update({
+        'TESTING': True,
+        'SQLALCHEMY_DATABASE_URI': f'sqlite:///{db_path}',
+        'WTF_CSRF_ENABLED': False,
+    })
+    
+    with app.app_context():
+        db.create_all()
+        yield app
+        db.drop_all()
+    
+    os.close(db_fd)
+    os.unlink(db_path)
+
+
+@pytest.fixture
+def client(app):
+    return app.test_client()
+
+
+@pytest.fixture
+def runner(app):
+    return app.test_cli_runner()

tests/test_app.py

@@ -0,0 +1,58 @@
+import pytest
+from app import create_app
+from models import db
+
+
+class TestAppFactory:
+    def test_create_app_default_config(self):
+        app = create_app()
+        assert app is not None
+        assert app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] is False
+    
+    def test_create_app_testing_config(self):
+        app = create_app('testing')
+        assert app is not None
+        assert app.config['TESTING'] is True
+        assert app.config['SQLALCHEMY_DATABASE_URI'] == 'sqlite:///:memory:'
+    
+    def test_create_app_development_config(self):
+        app = create_app('development')
+        assert app is not None
+        assert app.config['DEBUG'] is True
+
+
+class TestAppRoutes:
+    def test_index_route(self, client):
+        response = client.get('/')
+        assert response.status_code == 200
+    
+    def test_assessments_route_exists(self, client):
+        response = client.get('/assessments/')
+        assert response.status_code == 200
+    
+    def test_exercises_route_prefix_exists(self, client):
+        response = client.get('/exercises/')
+        assert response.status_code in [200, 404]  # Route exists but may need parameters
+    
+    def test_grading_route_prefix_exists(self, client):
+        response = client.get('/grading/')
+        assert response.status_code in [200, 404]  # Route exists but may need parameters
+
+
+class TestDatabase:
+    def test_database_creation(self, app):
+        with app.app_context():
+            db.create_all()
+            # Use inspector to get table names in SQLAlchemy 2.0+
+            from sqlalchemy import inspect
+            inspector = inspect(db.engine)
+            tables = inspector.get_table_names()
+            expected_tables = ['class_group', 'student', 'assessment', 'exercise', 'grading_element', 'grade']
+            for table in expected_tables:
+                assert table in tables
+    
+    def test_database_initialization(self, app):
+        with app.app_context():
+            assert db is not None
+            assert hasattr(db, 'session')
+            assert hasattr(db, 'Model')

tests/test_forms.py

@@ -0,0 +1,156 @@
+import pytest
+from datetime import date
+from forms import AssessmentForm, ClassGroupForm, StudentForm
+from models import db, ClassGroup
+
+
+class TestAssessmentForm:
+    def test_assessment_form_valid_data(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            # Create form without CSRF token for testing
+            with app.test_request_context():
+                form = AssessmentForm()
+                form.title.data = 'Test Math'
+                form.description.data = 'Contrôle de mathématiques'
+                form.date.data = date(2023, 10, 15)
+                form.class_group_id.data = class_group.id
+                form.coefficient.data = 2.0
+                
+                assert form.title.data == 'Test Math'
+                assert form.description.data == 'Contrôle de mathématiques'
+                assert form.date.data == date(2023, 10, 15)
+                assert form.class_group_id.data == class_group.id
+                assert form.coefficient.data == 2.0
+    
+    def test_assessment_form_missing_title(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            with app.test_request_context():
+                # Test form data validation by checking field requirements
+                form = AssessmentForm()
+                # Title field is required, so it should be marked as required
+                assert form.title.flags.required
+    
+    def test_assessment_form_coefficient_field(self, app):
+        with app.app_context():
+            with app.test_request_context():
+                form = AssessmentForm()
+                # Test that coefficient field exists and has validators
+                assert hasattr(form, 'coefficient')
+                assert form.coefficient.flags.required
+                # Check that NumberRange validator is present
+                has_number_range = any(v.__class__.__name__ == 'NumberRange' for v in form.coefficient.validators)
+                assert has_number_range
+    
+    def test_assessment_form_default_values(self, app):
+        with app.app_context():
+            with app.test_request_context():
+                form = AssessmentForm()
+                # Test that defaults are callable functions, not values
+                assert callable(form.date.default)
+                assert form.coefficient.default == 1.0
+    
+    def test_assessment_form_class_choices_populated(self, app):
+        with app.app_context():
+            class_group1 = ClassGroup(name="6A", year="2023-2024")
+            class_group2 = ClassGroup(name="6B", year="2023-2024")
+            db.session.add_all([class_group1, class_group2])
+            db.session.commit()
+            
+            with app.test_request_context():
+                form = AssessmentForm()
+                
+                assert len(form.class_group_id.choices) >= 2
+                choice_names = [choice[1] for choice in form.class_group_id.choices]
+                assert "6A" in choice_names
+                assert "6B" in choice_names
+
+
+class TestClassGroupForm:
+    def test_class_group_form_valid_data(self, app):
+        with app.app_context():
+            with app.test_request_context():
+                form = ClassGroupForm()
+                form.name.data = '6A'
+                form.description.data = 'Classe de 6ème A'
+                form.year.data = '2023-2024'
+                
+                assert form.name.data == '6A'
+                assert form.description.data == 'Classe de 6ème A'
+                assert form.year.data == '2023-2024'
+    
+    def test_class_group_form_name_required(self, app):
+        with app.app_context():
+            with app.test_request_context():
+                form = ClassGroupForm()
+                # Test that name field is required
+                assert form.name.flags.required
+    
+    def test_class_group_form_default_year(self, app):
+        with app.app_context():
+            with app.test_request_context():
+                form = ClassGroupForm()
+                assert form.year.default == "2024-2025"
+
+
+class TestStudentForm:
+    def test_student_form_valid_data(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            with app.test_request_context():
+                form = StudentForm()
+                form.first_name.data = 'Jean'
+                form.last_name.data = 'Dupont'
+                form.email.data = 'jean.dupont@example.com'
+                form.class_group_id.data = class_group.id
+                
+                assert form.first_name.data == 'Jean'
+                assert form.last_name.data == 'Dupont'
+                assert form.email.data == 'jean.dupont@example.com'
+                assert form.class_group_id.data == class_group.id
+    
+    def test_student_form_required_fields(self, app):
+        with app.app_context():
+            with app.test_request_context():
+                form = StudentForm()
+                # Test that required fields are marked as required
+                assert form.first_name.flags.required
+                assert form.last_name.flags.required
+                assert form.class_group_id.flags.required
+    
+    def test_student_form_email_validator(self, app):
+        with app.app_context():
+            with app.test_request_context():
+                form = StudentForm()
+                # Test that email field has email validator
+                has_email_validator = any(v.__class__.__name__ == 'Email' for v in form.email.validators)
+                assert has_email_validator
+                # Email field should be optional
+                assert not form.email.flags.required
+    
+    def test_student_form_optional_email(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            with app.test_request_context():
+                form = StudentForm()
+                form.first_name.data = 'Jean'
+                form.last_name.data = 'Dupont'
+                form.class_group_id.data = class_group.id
+                # Don't set email - should be valid
+                
+                assert form.first_name.data == 'Jean'
+                assert form.last_name.data == 'Dupont'
+                assert form.email.data is None

tests/test_models.py

@@ -0,0 +1,347 @@
+import pytest
+from datetime import datetime, date
+from models import db, ClassGroup, Student, Assessment, Exercise, GradingElement, Grade
+
+
+class TestClassGroup:
+    def test_create_class_group(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", description="Classe de 6ème A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            assert class_group.id is not None
+            assert class_group.name == "6A"
+            assert class_group.description == "Classe de 6ème A"
+            assert class_group.year == "2023-2024"
+    
+    def test_class_group_repr(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            assert repr(class_group) == "<ClassGroup 6A>"
+    
+    def test_class_group_unique_name(self, app):
+        with app.app_context():
+            class_group1 = ClassGroup(name="6A", year="2023-2024")
+            class_group2 = ClassGroup(name="6A", year="2023-2024")
+            
+            db.session.add(class_group1)
+            db.session.commit()
+            
+            db.session.add(class_group2)
+            with pytest.raises(Exception):
+                db.session.commit()
+
+
+class TestStudent:
+    def test_create_student(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            student = Student(
+                first_name="Jean",
+                last_name="Dupont",
+                email="jean.dupont@example.com",
+                class_group_id=class_group.id
+            )
+            db.session.add(student)
+            db.session.commit()
+            
+            assert student.id is not None
+            assert student.first_name == "Jean"
+            assert student.last_name == "Dupont"
+            assert student.email == "jean.dupont@example.com"
+            assert student.class_group_id == class_group.id
+    
+    def test_student_full_name_property(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            student = Student(
+                first_name="Jean",
+                last_name="Dupont",
+                class_group_id=class_group.id
+            )
+            assert student.full_name == "Jean Dupont"
+    
+    def test_student_repr(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            student = Student(
+                first_name="Jean",
+                last_name="Dupont",
+                class_group_id=class_group.id
+            )
+            assert repr(student) == "<Student Jean Dupont>"
+    
+    def test_student_unique_email(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            student1 = Student(
+                first_name="Jean",
+                last_name="Dupont",
+                email="jean.dupont@example.com",
+                class_group_id=class_group.id
+            )
+            student2 = Student(
+                first_name="Marie",
+                last_name="Martin",
+                email="jean.dupont@example.com",
+                class_group_id=class_group.id
+            )
+            
+            db.session.add(student1)
+            db.session.commit()
+            
+            db.session.add(student2)
+            with pytest.raises(Exception):
+                db.session.commit()
+
+
+class TestAssessment:
+    def test_create_assessment(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            assessment = Assessment(
+                title="Contrôle de mathématiques",
+                description="Contrôle sur les fractions",
+                date=date(2023, 10, 15),
+                class_group_id=class_group.id,
+                coefficient=2.0
+            )
+            db.session.add(assessment)
+            db.session.commit()
+            
+            assert assessment.id is not None
+            assert assessment.title == "Contrôle de mathématiques"
+            assert assessment.description == "Contrôle sur les fractions"
+            assert assessment.date == date(2023, 10, 15)
+            assert assessment.coefficient == 2.0
+    
+    def test_assessment_default_coefficient(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            assessment = Assessment(
+                title="Contrôle",
+                class_group_id=class_group.id
+            )
+            # Default value is set in the column definition, check after saving
+            db.session.add(assessment)
+            db.session.commit()
+            assert assessment.coefficient == 1.0
+    
+    def test_assessment_repr(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            assessment = Assessment(
+                title="Contrôle de mathématiques",
+                class_group_id=class_group.id
+            )
+            assert repr(assessment) == "<Assessment Contrôle de mathématiques>"
+
+
+class TestExercise:
+    def test_create_exercise(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            assessment = Assessment(title="Contrôle", class_group_id=1)
+            
+            db.session.add(class_group)
+            db.session.commit()
+            assessment.class_group_id = class_group.id
+            db.session.add(assessment)
+            db.session.commit()
+            
+            exercise = Exercise(
+                assessment_id=assessment.id,
+                title="Exercice 1",
+                description="Calculs avec fractions",
+                order=1
+            )
+            db.session.add(exercise)
+            db.session.commit()
+            
+            assert exercise.id is not None
+            assert exercise.title == "Exercice 1"
+            assert exercise.description == "Calculs avec fractions"
+            assert exercise.order == 1
+    
+    def test_exercise_default_order(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            assessment = Assessment(title="Contrôle", class_group_id=1)
+            
+            db.session.add(class_group)
+            db.session.commit()
+            assessment.class_group_id = class_group.id
+            db.session.add(assessment)
+            db.session.commit()
+            
+            exercise = Exercise(
+                assessment_id=assessment.id,
+                title="Exercice 1"
+            )
+            # Default value is set in the column definition, check after saving
+            db.session.add(exercise)
+            db.session.commit()
+            assert exercise.order == 1
+    
+    def test_exercise_repr(self, app):
+        with app.app_context():
+            exercise = Exercise(title="Exercice 1", assessment_id=1)
+            assert repr(exercise) == "<Exercise Exercice 1>"
+
+
+class TestGradingElement:
+    def test_create_grading_element(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            assessment = Assessment(title="Contrôle", class_group_id=1)
+            
+            db.session.add(class_group)
+            db.session.commit()
+            assessment.class_group_id = class_group.id
+            db.session.add(assessment)
+            db.session.commit()
+            
+            exercise = Exercise(assessment_id=assessment.id, title="Exercice 1")
+            db.session.add(exercise)
+            db.session.commit()
+            
+            grading_element = GradingElement(
+                exercise_id=exercise.id,
+                label="Question 1",
+                description="Calculer 1/2 + 1/3",
+                skill="Additionner des fractions",
+                max_points=4.0,
+                grading_type="points"
+            )
+            db.session.add(grading_element)
+            db.session.commit()
+            
+            assert grading_element.id is not None
+            assert grading_element.label == "Question 1"
+            assert grading_element.max_points == 4.0
+            assert grading_element.grading_type == "points"
+    
+    def test_grading_element_default_type(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            assessment = Assessment(title="Contrôle", class_group_id=1)
+            
+            db.session.add(class_group)
+            db.session.commit()
+            assessment.class_group_id = class_group.id
+            db.session.add(assessment)
+            db.session.commit()
+            
+            exercise = Exercise(assessment_id=assessment.id, title="Exercice 1")
+            db.session.add(exercise)
+            db.session.commit()
+            
+            grading_element = GradingElement(
+                exercise_id=exercise.id,
+                label="Question 1",
+                max_points=4.0
+            )
+            # Default value is set in the column definition, check after saving
+            db.session.add(grading_element)
+            db.session.commit()
+            assert grading_element.grading_type == "points"
+    
+    def test_grading_element_repr(self, app):
+        with app.app_context():
+            grading_element = GradingElement(
+                exercise_id=1,
+                label="Question 1",
+                max_points=4.0
+            )
+            assert repr(grading_element) == "<GradingElement Question 1>"
+
+
+class TestGrade:
+    def test_create_grade(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            student = Student(
+                first_name="Jean",
+                last_name="Dupont",
+                class_group_id=class_group.id
+            )
+            db.session.add(student)
+            db.session.commit()
+            
+            assessment = Assessment(title="Contrôle", class_group_id=class_group.id)
+            db.session.add(assessment)
+            db.session.commit()
+            
+            exercise = Exercise(assessment_id=assessment.id, title="Exercice 1")
+            db.session.add(exercise)
+            db.session.commit()
+            
+            grading_element = GradingElement(
+                exercise_id=exercise.id,
+                label="Question 1",
+                max_points=4.0
+            )
+            db.session.add(grading_element)
+            db.session.commit()
+            
+            grade = Grade(
+                student_id=student.id,
+                grading_element_id=grading_element.id,
+                value="3.5",
+                comment="Très bien"
+            )
+            db.session.add(grade)
+            db.session.commit()
+            
+            assert grade.id is not None
+            assert grade.value == "3.5"
+            assert grade.comment == "Très bien"
+    
+    def test_grade_repr_with_student(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            student = Student(
+                first_name="Jean",
+                last_name="Dupont",
+                class_group_id=class_group.id
+            )
+            db.session.add(student)
+            db.session.commit()
+            
+            grade = Grade(
+                student_id=student.id,
+                grading_element_id=1,
+                value="3.5"
+            )
+            db.session.add(grade)
+            db.session.commit()
+            
+            assert repr(grade) == "<Grade 3.5 for Jean>"

tests/test_routes_assessments.py

@@ -0,0 +1,104 @@
+import pytest
+import json
+from models import db, Assessment, ClassGroup, Exercise, GradingElement
+from datetime import date
+
+
+class TestAssessmentsRoutes:
+    def test_assessments_list_empty(self, client):
+        response = client.get('/assessments/')
+        assert response.status_code == 200
+        assert b'assessments' in response.data.lower()
+    
+    def test_assessments_list_with_data(self, client, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            assessment = Assessment(
+                title="Test Math",
+                description="Contrôle de mathématiques",
+                date=date(2023, 10, 15),
+                class_group_id=class_group.id
+            )
+            db.session.add(assessment)
+            db.session.commit()
+        
+        response = client.get('/assessments/')
+        assert response.status_code == 200
+        assert b'Test Math' in response.data
+    
+    def test_assessment_detail_exists(self, client, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            assessment = Assessment(
+                title="Test Math",
+                description="Contrôle de mathématiques",
+                date=date(2023, 10, 15),
+                class_group_id=class_group.id
+            )
+            db.session.add(assessment)
+            db.session.commit()
+            assessment_id = assessment.id
+        
+        response = client.get(f'/assessments/{assessment_id}')
+        assert response.status_code == 200
+        assert b'Test Math' in response.data
+    
+    def test_assessment_detail_not_found(self, client):
+        response = client.get('/assessments/999')
+        # Due to handle_db_errors decorator, 404 gets converted to 500
+        assert response.status_code == 500
+    
+    def test_assessment_with_exercises(self, client, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            assessment = Assessment(
+                title="Test Math",
+                class_group_id=class_group.id
+            )
+            db.session.add(assessment)
+            db.session.commit()
+            
+            exercise = Exercise(
+                assessment_id=assessment.id,
+                title="Exercice 1",
+                order=1
+            )
+            db.session.add(exercise)
+            db.session.commit()
+            
+            grading_element = GradingElement(
+                exercise_id=exercise.id,
+                label="Question 1",
+                max_points=4.0
+            )
+            db.session.add(grading_element)
+            db.session.commit()
+            
+            assessment_id = assessment.id
+        
+        response = client.get(f'/assessments/{assessment_id}')
+        assert response.status_code == 200
+        assert b'Test Math' in response.data
+        assert b'Exercice 1' in response.data
+
+
+class TestAssessmentCreation:
+    def test_assessment_new_route_exists(self, client):
+        # Test that the new route exists and returns a form page
+        response = client.get('/assessments/new')
+        assert response.status_code == 200
+    
+    def test_assessment_creation_post_without_data(self, client):
+        # Test POST to new route without proper data
+        response = client.post('/assessments/new', data={})
+        # Should return form with errors or redirect
+        assert response.status_code in [200, 302, 400]

tests/test_services.py

@@ -0,0 +1,137 @@
+import pytest
+from datetime import date, datetime
+from decimal import Decimal
+from models import db, Assessment, ClassGroup, Exercise, GradingElement
+from services import AssessmentService
+from utils import ValidationError
+
+
+class TestAssessmentService:
+    def test_create_assessment(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            form_data = {
+                'title': 'Test Math',
+                'description': 'Contrôle de mathématiques',
+                'date': date(2023, 10, 15),
+                'class_group_id': class_group.id,
+                'coefficient': 2.0
+            }
+            
+            assessment = AssessmentService.create_assessment(form_data)
+            
+            assert assessment.id is not None
+            assert assessment.title == 'Test Math'
+            assert assessment.description == 'Contrôle de mathématiques'
+            assert assessment.date == date(2023, 10, 15)
+            assert assessment.class_group_id == class_group.id
+            assert assessment.coefficient == 2.0
+    
+    def test_create_assessment_minimal_data(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            form_data = {
+                'title': 'Test Math',
+                'date': date(2023, 10, 15),
+                'class_group_id': class_group.id,
+                'coefficient': 1.0
+            }
+            
+            assessment = AssessmentService.create_assessment(form_data)
+            
+            assert assessment.id is not None
+            assert assessment.title == 'Test Math'
+            assert assessment.description == ''
+            assert assessment.coefficient == 1.0
+    
+    def test_update_assessment_basic_info(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            assessment = Assessment(
+                title='Original Title',
+                date=date(2023, 10, 15),
+                class_group_id=class_group.id,
+                coefficient=1.0
+            )
+            db.session.add(assessment)
+            db.session.commit()
+            
+            form_data = {
+                'title': 'Updated Title',
+                'description': 'Updated description',
+                'date': date(2023, 10, 20),
+                'class_group_id': class_group.id,
+                'coefficient': 2.0
+            }
+            
+            AssessmentService.update_assessment_basic_info(assessment, form_data)
+            
+            assert assessment.title == 'Updated Title'
+            assert assessment.description == 'Updated description'
+            assert assessment.date == date(2023, 10, 20)
+            assert assessment.coefficient == 2.0
+    
+    def test_delete_assessment_exercises(self, app):
+        with app.app_context():
+            class_group = ClassGroup(name="6A", year="2023-2024")
+            db.session.add(class_group)
+            db.session.commit()
+            
+            assessment = Assessment(
+                title='Test Assessment',
+                class_group_id=class_group.id
+            )
+            db.session.add(assessment)
+            db.session.commit()
+            
+            exercise1 = Exercise(assessment_id=assessment.id, title="Ex 1")
+            exercise2 = Exercise(assessment_id=assessment.id, title="Ex 2")
+            db.session.add_all([exercise1, exercise2])
+            db.session.commit()
+            
+            initial_count = len(assessment.exercises)
+            assert initial_count == 2
+            
+            AssessmentService.delete_assessment_exercises(assessment)
+            db.session.commit()
+            
+            # Refresh the assessment to get updated exercises
+            db.session.refresh(assessment)
+            assert len(assessment.exercises) == 0
+    
+    def test_process_assessment_with_exercises_validation_error(self, app):
+        with app.app_context():
+            # Test with missing required fields
+            incomplete_data = {
+                'title': 'Test Assessment'
+                # Missing date, class_group_id, coefficient
+            }
+            
+            with pytest.raises(ValueError):
+                AssessmentService.process_assessment_with_exercises(incomplete_data)
+    
+    def test_process_assessment_validation_required_fields(self, app):
+        with app.app_context():
+            # Test that all required fields are validated
+            required_fields = ['title', 'date', 'class_group_id', 'coefficient']
+            
+            for field in required_fields:
+                incomplete_data = {
+                    'title': 'Test',
+                    'date': '2023-10-15',
+                    'class_group_id': 1,
+                    'coefficient': 1.0
+                }
+                del incomplete_data[field]
+                
+                with pytest.raises(ValueError):
+                    AssessmentService.process_assessment_with_exercises(incomplete_data)

tests/test_utils.py

@@ -0,0 +1,168 @@
+import pytest
+from decimal import Decimal
+from flask import Flask, request, jsonify
+from models import db
+from utils import (
+    handle_db_errors, safe_int_conversion, safe_decimal_conversion,
+    validate_json_data, ValidationError, log_user_action
+)
+from sqlalchemy.exc import IntegrityError, SQLAlchemyError
+
+
+class TestSafeConversions:
+    def test_safe_int_conversion_valid(self):
+        assert safe_int_conversion("123", "test") == 123
+        assert safe_int_conversion(456, "test") == 456
+        assert safe_int_conversion("0", "test") == 0
+    
+    def test_safe_int_conversion_invalid(self):
+        with pytest.raises(ValueError, match="test doit être un nombre entier"):
+            safe_int_conversion("abc", "test")
+        
+        with pytest.raises(ValueError, match="test doit être un nombre entier"):
+            safe_int_conversion("12.5", "test")
+        
+        with pytest.raises(ValueError, match="test doit être un nombre entier"):
+            safe_int_conversion("", "test")
+    
+    def test_safe_decimal_conversion_valid(self):
+        assert safe_decimal_conversion("12.5", "test") == Decimal("12.5")
+        assert safe_decimal_conversion(10, "test") == Decimal("10")
+        assert safe_decimal_conversion("0", "test") == Decimal("0")
+        assert safe_decimal_conversion(0.5, "test") == Decimal("0.5")
+    
+    def test_safe_decimal_conversion_invalid(self):
+        with pytest.raises(ValueError, match="test doit être un nombre décimal"):
+            safe_decimal_conversion("abc", "test")
+        
+        with pytest.raises(ValueError, match="test doit être un nombre décimal"):
+            safe_decimal_conversion("", "test")
+
+
+class TestValidateJsonData:
+    def test_validate_json_data_valid(self):
+        data = {"name": "test", "value": 123}
+        required_fields = ["name", "value"]
+        
+        # Should not raise exception
+        validate_json_data(data, required_fields)
+    
+    def test_validate_json_data_missing_field(self):
+        data = {"name": "test"}
+        required_fields = ["name", "value"]
+        
+        with pytest.raises(ValueError, match="Champs requis manquants: value"):
+            validate_json_data(data, required_fields)
+    
+    def test_validate_json_data_empty_field(self):
+        data = {"name": "", "value": 123}
+        required_fields = ["name"]
+        
+        # The current implementation doesn't check for empty strings, only None values
+        # This test should pass as the validation doesn't fail on empty strings
+        validate_json_data(data, required_fields)
+    
+    def test_validate_json_data_none_field(self):
+        data = {"name": None, "value": 123}
+        required_fields = ["name", "value"]
+        
+        with pytest.raises(ValueError, match="Champs requis manquants: name"):
+            validate_json_data(data, required_fields)
+
+
+class TestValidationError:
+    def test_validation_error_creation(self):
+        error = ValidationError("Test error message")
+        assert str(error) == "Test error message"
+        assert error.args[0] == "Test error message"
+
+
+class TestLogUserAction:
+    def test_log_user_action(self, app):
+        with app.app_context():
+            # Should not raise exception
+            log_user_action("TEST_ACTION", "Test description")
+            
+            # Test with None description
+            log_user_action("TEST_ACTION", None)
+
+
+def mock_function_success():
+    """Mock function that returns success"""
+    return "success"
+
+def mock_function_none():
+    """Mock function that returns None"""
+    return None
+
+def mock_function_with_error(error_type):
+    """Mock function that raises an error"""
+    raise error_type("Test error")
+
+
+class TestHandleDbErrors:
+    def test_handle_db_errors_success(self, app):
+        with app.app_context():
+            decorated_func = handle_db_errors(mock_function_success)
+            
+            with app.test_request_context():
+                result = decorated_func()
+                assert result == "success"
+    
+    def test_handle_db_errors_integrity_error(self, app):
+        with app.app_context():
+            def mock_integrity_error():
+                raise IntegrityError("UNIQUE constraint failed", None, None)
+            
+            decorated_func = handle_db_errors(mock_integrity_error)
+            
+            with app.test_request_context():
+                result = decorated_func()
+                # Should return template and status code
+                assert isinstance(result, tuple) and len(result) == 2
+                assert result[1] == 400
+    
+    def test_handle_db_errors_sqlalchemy_error(self, app):
+        with app.app_context():
+            def mock_sqlalchemy_error():
+                raise SQLAlchemyError("Database error")
+            
+            decorated_func = handle_db_errors(mock_sqlalchemy_error)
+            
+            with app.test_request_context():
+                result = decorated_func()
+                assert isinstance(result, tuple) and len(result) == 2
+                assert result[1] == 500
+    
+    def test_handle_db_errors_general_exception(self, app):
+        with app.app_context():
+            def mock_general_error():
+                raise Exception("General error")
+            
+            decorated_func = handle_db_errors(mock_general_error)
+            
+            with app.test_request_context():
+                result = decorated_func()
+                assert isinstance(result, tuple) and len(result) == 2
+                assert result[1] == 500
+    
+    def test_handle_db_errors_json_request_integrity_error(self, app):
+        with app.app_context():
+            def mock_integrity_error():
+                raise IntegrityError("UNIQUE constraint failed", None, None)
+            
+            decorated_func = handle_db_errors(mock_integrity_error)
+            
+            with app.test_request_context(content_type='application/json'):
+                result = decorated_func()
+                assert isinstance(result, tuple) and len(result) == 2
+                assert result[1] == 400
+    
+    def test_handle_db_errors_function_returns_none(self, app):
+        with app.app_context():
+            decorated_func = handle_db_errors(mock_function_none)
+            
+            with app.test_request_context():
+                result = decorated_func()
+                assert isinstance(result, tuple) and len(result) == 2
+                assert result[1] == 500