forked from ScoDoc/ScoDoc
372 lines
12 KiB
Python
372 lines
12 KiB
Python
# -*- mode: python -*-
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
Tests unitaires vérifiant le bon fonctionnement du modèle Assiduité et de
|
|
ses fonctions liées
|
|
|
|
Ecrit par HARTMANN Matthias (en s'inspirant de tests.unit.test_abs_count.py par Fares Amer )
|
|
"""
|
|
|
|
from tests.unit import sco_fake_gen
|
|
|
|
from app import db
|
|
|
|
from app.scodoc import sco_formsemestre
|
|
import app.scodoc.sco_assiduites as scass
|
|
from app.models import Assiduite, Identite, FormSemestre, ModuleImpl
|
|
from app.scodoc.sco_exceptions import ScoValueError
|
|
import app.scodoc.sco_utils as scu
|
|
|
|
|
|
def test_general(test_client):
|
|
""" """
|
|
|
|
G = sco_fake_gen.ScoFake(verbose=False)
|
|
|
|
# Création d'une formation (1)
|
|
|
|
formation_id = G.create_formation()
|
|
ue_id = G.create_ue(formation_id=formation_id, acronyme="T1", titre="UE TEST 1")
|
|
matiere_id = G.create_matiere(ue_id=ue_id, titre="test matière")
|
|
module_id_1 = G.create_module(
|
|
matiere_id=matiere_id, code="Mo1", coefficient=1.0, titre="test module"
|
|
)
|
|
module_id_2 = G.create_module(
|
|
matiere_id=matiere_id, code="Mo2", coefficient=1.0, titre="test module2"
|
|
)
|
|
|
|
# Création semestre (2)
|
|
|
|
formsemestre_id_1 = G.create_formsemestre(
|
|
formation_id=formation_id,
|
|
semestre_id=1,
|
|
date_debut="01/09/2022",
|
|
date_fin="31/12/2022",
|
|
)
|
|
formsemestre_id_2 = G.create_formsemestre(
|
|
formation_id=formation_id,
|
|
semestre_id=2,
|
|
date_debut="01/01/2023",
|
|
date_fin="31/07/2023",
|
|
)
|
|
formsemestre_id_3 = G.create_formsemestre(
|
|
formation_id=formation_id,
|
|
semestre_id=3,
|
|
date_debut="01/01/2024",
|
|
date_fin="31/07/2024",
|
|
)
|
|
|
|
formsemestre_1 = sco_formsemestre.get_formsemestre(formsemestre_id_1)
|
|
formsemestre_2 = sco_formsemestre.get_formsemestre(formsemestre_id_2)
|
|
formsemestre_3 = sco_formsemestre.get_formsemestre(formsemestre_id_3)
|
|
|
|
# Création des modulesimpls (4, 2 par semestre)
|
|
|
|
moduleimpl_1_1 = G.create_moduleimpl(
|
|
module_id=module_id_1,
|
|
formsemestre_id=formsemestre_id_1,
|
|
)
|
|
moduleimpl_1_2 = G.create_moduleimpl(
|
|
module_id=module_id_2,
|
|
formsemestre_id=formsemestre_id_1,
|
|
)
|
|
|
|
moduleimpl_2_1 = G.create_moduleimpl(
|
|
module_id=module_id_1,
|
|
formsemestre_id=formsemestre_id_2,
|
|
)
|
|
moduleimpl_2_2 = G.create_moduleimpl(
|
|
module_id=module_id_2,
|
|
formsemestre_id=formsemestre_id_2,
|
|
)
|
|
|
|
moduleimpls = [
|
|
moduleimpl_1_1,
|
|
moduleimpl_1_2,
|
|
moduleimpl_2_1,
|
|
moduleimpl_2_2,
|
|
]
|
|
|
|
moduleimpls = [
|
|
ModuleImpl.query.filter_by(id=mi_id).first() for mi_id in moduleimpls
|
|
]
|
|
|
|
# Création des étudiants (3)
|
|
|
|
etuds_dict = [G.create_etud(code_nip=None, prenom=f"etud{i}") for i in range(3)]
|
|
|
|
etuds = []
|
|
for etud in etuds_dict:
|
|
G.inscrit_etudiant(formsemestre_id=formsemestre_id_1, etud=etud)
|
|
G.inscrit_etudiant(formsemestre_id=formsemestre_id_2, etud=etud)
|
|
|
|
etuds.append(Identite.query.filter_by(id=etud["id"]).first())
|
|
|
|
assert None not in etuds, "Problème avec la conversion en Identite"
|
|
|
|
# Etudiant faux
|
|
|
|
etud_faux_dict = G.create_etud(code_nip=None, prenom="etudfaux")
|
|
etud_faux = Identite.query.filter_by(id=etud_faux_dict["id"]).first()
|
|
|
|
ajouter_assiduites(etuds, moduleimpls, etud_faux)
|
|
verifier_comptage_et_filtrage(
|
|
etuds, moduleimpls, (formsemestre_1, formsemestre_2, formsemestre_3)
|
|
)
|
|
editer_supprimer_assiduiter(etuds, moduleimpls)
|
|
|
|
|
|
def editer_supprimer_assiduiter(etuds: list[Identite], moduleimpls: list[int]):
|
|
"""
|
|
Troisième Partie:
|
|
- Vérification de l'édition des assiduitées
|
|
- Vérification de la suppression des assiduitées
|
|
"""
|
|
|
|
from sqlalchemy.exc import IntegrityError
|
|
|
|
ass1: Assiduite = etuds[0].assiduites.first()
|
|
ass2: Assiduite = etuds[1].assiduites.first()
|
|
ass3: Assiduite = etuds[2].assiduites.first()
|
|
|
|
# Modification de l'état
|
|
ass1.etat = scu.EtatAssiduite.RETARD
|
|
db.session.add(ass1)
|
|
# Modification du moduleimpl
|
|
ass2.moduleimpl_id = moduleimpls[0].id
|
|
db.session.add(ass2)
|
|
db.session.commit()
|
|
|
|
# Vérification du changement
|
|
assert (
|
|
scass.filter_by_etat(etuds[0].assiduites, "retard").count() == 3
|
|
), "Edition d'assiduité mauvais"
|
|
assert (
|
|
scass.filter_by_module_impl(etuds[1].assiduites, moduleimpls[0].id).count() == 2
|
|
), "Edition d'assiduité mauvais"
|
|
|
|
# Supression d'une assiduité
|
|
|
|
db.session.delete(ass3)
|
|
db.session.commit()
|
|
|
|
assert etuds[2].assiduites.count() == 5, "Supression d'assiduité mauvais"
|
|
|
|
|
|
def ajouter_assiduites(
|
|
etuds: list[Identite], moduleimpls: list[ModuleImpl], etud_faux: Identite
|
|
):
|
|
"""
|
|
Première partie:
|
|
- Ajoute 6 assiduités à chaque étudiant
|
|
- 2 présence (semestre 1 et 2)
|
|
- 2 retard (semestre 2)
|
|
- 2 absence (semestre 1)
|
|
- Vérifie la création des assiduités
|
|
"""
|
|
|
|
for etud in etuds:
|
|
obj_assiduites = [
|
|
{
|
|
"etat": scu.EtatAssiduite.PRESENT,
|
|
"deb": "2022-09-03T08:00+01:00",
|
|
"fin": "2022-09-03T10:00+01:00",
|
|
"moduleimpl": None,
|
|
},
|
|
{
|
|
"etat": scu.EtatAssiduite.PRESENT,
|
|
"deb": "2023-01-03T08:00+01:00",
|
|
"fin": "2023-01-03T10:00+01:00",
|
|
"moduleimpl": moduleimpls[2],
|
|
},
|
|
{
|
|
"etat": scu.EtatAssiduite.ABSENT,
|
|
"deb": "2022-09-03T10:00:01+01:00",
|
|
"fin": "2022-09-03T11:00+01:00",
|
|
"moduleimpl": moduleimpls[0],
|
|
},
|
|
{
|
|
"etat": scu.EtatAssiduite.ABSENT,
|
|
"deb": "2022-09-03T14:00:00+01:00",
|
|
"fin": "2022-09-03T15:00+01:00",
|
|
"moduleimpl": moduleimpls[1],
|
|
},
|
|
{
|
|
"etat": scu.EtatAssiduite.RETARD,
|
|
"deb": "2023-01-03T11:00:01+01:00",
|
|
"fin": "2023-01-03T12:00+01:00",
|
|
"moduleimpl": moduleimpls[3],
|
|
},
|
|
{
|
|
"etat": scu.EtatAssiduite.RETARD,
|
|
"deb": "2023-01-04T11:00:01+01:00",
|
|
"fin": "2023-01-04T12:00+01:00",
|
|
"moduleimpl": moduleimpls[3],
|
|
},
|
|
]
|
|
|
|
assiduites = [
|
|
Assiduite.create_assiduite(
|
|
etud, ass["deb"], ass["fin"], ass["etat"], ass["moduleimpl"]
|
|
)
|
|
for ass in obj_assiduites
|
|
]
|
|
|
|
# Vérification de la création des assiduités
|
|
assert [
|
|
ass for ass in assiduites if type(ass) != Assiduite
|
|
] == [], "La création des assiduités de base n'est pas OK"
|
|
|
|
# Vérification de la gestion des erreurs
|
|
|
|
test_assiduite = {
|
|
"etat": scu.EtatAssiduite.RETARD,
|
|
"deb": "2023-01-04T11:00:01+01:00",
|
|
"fin": "2023-01-04T12:00+01:00",
|
|
"moduleimpl": moduleimpls[3],
|
|
}
|
|
|
|
try:
|
|
Assiduite.create_assiduite(
|
|
etuds[0],
|
|
test_assiduite["deb"],
|
|
test_assiduite["fin"],
|
|
test_assiduite["etat"],
|
|
test_assiduite["moduleimpl"],
|
|
)
|
|
except ScoValueError as excp:
|
|
assert (
|
|
excp.args[0]
|
|
== "Duplication des assiduités (la période rentrée rentre en conflit avec une assiduité enregistrée)"
|
|
)
|
|
try:
|
|
Assiduite.create_assiduite(
|
|
etud_faux,
|
|
test_assiduite["deb"],
|
|
test_assiduite["fin"],
|
|
test_assiduite["etat"],
|
|
test_assiduite["moduleimpl"],
|
|
)
|
|
except ScoValueError as excp:
|
|
assert excp.args[0] == "L'étudiant n'est pas inscrit au moduleimpl"
|
|
|
|
|
|
def verifier_comptage_et_filtrage(
|
|
etuds: list[Identite], moduleimpls: list[int], formsemestres: tuple[int]
|
|
):
|
|
"""
|
|
Deuxième partie:
|
|
- vérifier les valeurs du comptage (compte, heure, journée, demi-journée)
|
|
- vérifier le filtrage des assiduites (etat, debut, fin, module, formsemestre)
|
|
|
|
"""
|
|
|
|
etu1, etu2, etu3 = etuds
|
|
|
|
mod11, mod12, mod21, mod22 = moduleimpls
|
|
|
|
# Vérification du comptage classique
|
|
comptage = scass.get_assiduites_stats(etu1.assiduites)
|
|
|
|
assert comptage["compte"] == 6, "la métrique 'Comptage' n'est pas bien calculée"
|
|
assert comptage["journee"] == 3, "la métrique 'Journée' n'est pas bien calculée"
|
|
assert comptage["demi"] == 4, "la métrique 'Demi-Journée' n'est pas bien calculée"
|
|
assert comptage["heure"] == 8, "la métrique 'Heure' n'est pas bien calculée"
|
|
|
|
# Vérification du filtrage classique
|
|
|
|
# Etat
|
|
assert (
|
|
scass.filter_by_etat(etu2.assiduites, "present").count() == 2
|
|
), "Filtrage de l'état 'présent' mauvais"
|
|
assert (
|
|
scass.filter_by_etat(etu2.assiduites, "retard").count() == 2
|
|
), "Filtrage de l'état 'retard' mauvais"
|
|
assert (
|
|
scass.filter_by_etat(etu2.assiduites, "absent").count() == 2
|
|
), "Filtrage de l'état 'absent' mauvais"
|
|
assert (
|
|
scass.filter_by_etat(etu2.assiduites, "absent,retard").count() == 4
|
|
), "Filtrage de l'état 'absent,retard' mauvais"
|
|
assert (
|
|
scass.filter_by_etat(etu2.assiduites, "absent,retard,present").count() == 6
|
|
), "Filtrage de l'état 'absent,retard,present' mauvais"
|
|
assert (
|
|
scass.filter_by_etat(etu2.assiduites, "autre").count() == 0
|
|
), "Filtrage de l'état 'autre' mauvais"
|
|
|
|
# Module
|
|
assert (
|
|
scass.filter_by_module_impl(etu3.assiduites, mod11.id).count() == 1
|
|
), "Filtrage par 'Moduleimpl' mauvais"
|
|
assert (
|
|
scass.filter_by_module_impl(etu3.assiduites, mod12.id).count() == 1
|
|
), "Filtrage par 'Moduleimpl' mauvais"
|
|
assert (
|
|
scass.filter_by_module_impl(etu3.assiduites, mod21.id).count() == 1
|
|
), "Filtrage par 'Moduleimpl' mauvais"
|
|
assert (
|
|
scass.filter_by_module_impl(etu3.assiduites, mod22.id).count() == 2
|
|
), "Filtrage par 'Moduleimpl' mauvais"
|
|
assert (
|
|
scass.filter_by_module_impl(etu3.assiduites, None).count() == 1
|
|
), "Filtrage par 'Moduleimpl' mauvais"
|
|
assert (
|
|
scass.filter_by_module_impl(etu3.assiduites, 152).count() == 0
|
|
), "Filtrage par 'Moduleimpl' mauvais"
|
|
|
|
# Formsemestre
|
|
formsemestres = [
|
|
FormSemestre.query.filter_by(id=fms["id"]).first() for fms in formsemestres
|
|
]
|
|
assert (
|
|
scass.filter_by_formsemstre(etu1.assiduites, formsemestres[0]).count() == 3
|
|
), "Filtrage 'Formsemestre' mauvais"
|
|
assert (
|
|
scass.filter_by_formsemstre(etu1.assiduites, formsemestres[1]).count() == 3
|
|
), "Filtrage 'Formsemestre' mauvais"
|
|
assert (
|
|
scass.filter_by_formsemstre(etu1.assiduites, formsemestres[2]).count() == 0
|
|
), "Filtrage 'Formsemestre' mauvais"
|
|
|
|
# Date début
|
|
date = scu.localize_datetime("2022-09-01T10:00+01:00")
|
|
assert (
|
|
scass.filter_by_date(etu2.assiduites, date, sup=True).count() == 6
|
|
), "Filtrage 'Date début' mauvais"
|
|
date = scu.localize_datetime("2022-09-03T10:00:00+01:00")
|
|
assert (
|
|
scass.filter_by_date(etu2.assiduites, date, sup=True).count() == 5
|
|
), "Filtrage 'Date début' mauvais"
|
|
date = scu.localize_datetime("2022-09-03T10:00:01+01:00")
|
|
assert (
|
|
scass.filter_by_date(etu2.assiduites, date, sup=True).count() == 5
|
|
), "Filtrage 'Date début' mauvais"
|
|
date = scu.localize_datetime("2022-09-03T10:00:02+01:00")
|
|
assert (
|
|
scass.filter_by_date(etu2.assiduites, date, sup=True).count() == 4
|
|
), "Filtrage 'Date début' mauvais"
|
|
|
|
# Date fin
|
|
date = scu.localize_datetime("2022-09-01T10:00+01:00")
|
|
assert (
|
|
scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 0
|
|
), "Filtrage 'Date fin' mauvais"
|
|
date = scu.localize_datetime("2022-09-03T10:00:00+01:00")
|
|
assert (
|
|
scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 1
|
|
), "Filtrage 'Date fin' mauvais"
|
|
date = scu.localize_datetime("2022-09-03T10:00:01+01:00")
|
|
assert (
|
|
scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 1
|
|
), "Filtrage 'Date fin' mauvais"
|
|
date = scu.localize_datetime("2023-01-04T13:00:01+01:00")
|
|
assert (
|
|
scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 6
|
|
), "Filtrage 'Date fin' mauvais"
|
|
date = scu.localize_datetime("2023-01-03T11:00:01+01:00")
|
|
assert (
|
|
scass.filter_by_date(etu2.assiduites, date, sup=False).count() == 4
|
|
), "Filtrage 'Date fin' mauvais"
|