ScoDoc/tests/unit/test_assiduites.py

# -*- 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
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_id_1_1 = G.create_moduleimpl(
        module_id=module_id_1,
        formsemestre_id=formsemestre_id_1,
    )
    moduleimpl_id_1_2 = G.create_moduleimpl(
        module_id=module_id_2,
        formsemestre_id=formsemestre_id_1,
    )

    moduleimpl_id_2_1 = G.create_moduleimpl(
        module_id=module_id_1,
        formsemestre_id=formsemestre_id_2,
    )
    moduleimpl_id_2_2 = G.create_moduleimpl(
        module_id=module_id_2,
        formsemestre_id=formsemestre_id_2,
    )

    moduleimpls = [
        moduleimpl_id_1_1,
        moduleimpl_id_1_2,
        moduleimpl_id_2_1,
        moduleimpl_id_2_2,
    ]

    # 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"

    ajouter_assiduites(etuds, moduleimpls=moduleimpls)
    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]
    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]).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[int]):
    """
    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_id": None,
            },
            {
                "etat": scu.EtatAssiduite.PRESENT,
                "deb": "2023-01-03T08:00+01:00",
                "fin": "2023-01-03T10:00+01:00",
                "moduleimpl_id": moduleimpls[2],
            },
            {
                "etat": scu.EtatAssiduite.ABSENT,
                "deb": "2022-09-03T10:00:01+01:00",
                "fin": "2022-09-03T11:00+01:00",
                "moduleimpl_id": moduleimpls[0],
            },
            {
                "etat": scu.EtatAssiduite.ABSENT,
                "deb": "2022-09-03T14:00:00+01:00",
                "fin": "2022-09-03T15:00+01:00",
                "moduleimpl_id": moduleimpls[1],
            },
            {
                "etat": scu.EtatAssiduite.RETARD,
                "deb": "2023-01-03T11:00:01+01:00",
                "fin": "2023-01-03T12:00+01:00",
                "moduleimpl_id": moduleimpls[3],
            },
            {
                "etat": scu.EtatAssiduite.RETARD,
                "deb": "2023-01-04T11:00:01+01:00",
                "fin": "2023-01-04T12:00+01:00",
                "moduleimpl_id": moduleimpls[3],
            },
        ]

        assiduites = [
            Assiduite.create_assiduite(
                etud, ass["deb"], ass["fin"], ass["etat"], ass["moduleimpl_id"]
            )
            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_assiduites = [
        {
            "etat": scu.EtatAssiduite.RETARD,
            "deb": "2023-01-04T11:00:01+01:00",
            "fin": "2023-01-04T12:00+01:00",
            "moduleimpl_id": moduleimpls[3],
        },
        {
            "etat": scu.EtatAssiduite.RETARD,
            "deb": "2023-01-05T11:00:01+01:00",
            "fin": "2023-01-05T12:00+01:00",
            "moduleimpl_id": 1000,
        },
    ]

    assiduites_crees = [
        Assiduite.create_assiduite(
            etuds[0], ass["deb"], ass["fin"], ass["etat"], ass["moduleimpl_id"]
        )
        for ass in test_assiduites
    ]

    assert [ass for ass in assiduites_crees if type(ass) != Assiduite] == [
        1,
        2,
    ], "La vérification des erreurs ne fonctionne pas"


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).count() == 1
    ), "Filtrage par 'Moduleimpl' mauvais"
    assert (
        scass.filter_by_module_impl(etu3.assiduites, mod12).count() == 1
    ), "Filtrage par 'Moduleimpl' mauvais"
    assert (
        scass.filter_by_module_impl(etu3.assiduites, mod21).count() == 1
    ), "Filtrage par 'Moduleimpl' mauvais"
    assert (
        scass.filter_by_module_impl(etu3.assiduites, mod22).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"