From e11b7fa076986892008d19408311d41da01f600b Mon Sep 17 00:00:00 2001 From: Emmanuel Viennet Date: Sat, 11 Feb 2023 05:04:10 +0100 Subject: [PATCH] =?UTF-8?q?Tests=20YAML:=20s=C3=A9paration=20fct=20sp?= =?UTF-8?q?=C3=A9cifiques=20BUT?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- sco_version.py | 2 +- tests/unit/test_but_jury.py | 18 +- tests/unit/yaml_setup.py | 330 ++++------------------------------- tests/unit/yaml_setup_but.py | 304 ++++++++++++++++++++++++++++++++ 4 files changed, 346 insertions(+), 308 deletions(-) create mode 100644 tests/unit/yaml_setup_but.py diff --git a/sco_version.py b/sco_version.py index 6561608c5..b38f10a87 100644 --- a/sco_version.py +++ b/sco_version.py @@ -1,7 +1,7 @@ # -*- mode: python -*- # -*- coding: utf-8 -*- -SCOVERSION = "9.4.40" +SCOVERSION = "9.4.41" SCONAME = "ScoDoc" diff --git a/tests/unit/test_but_jury.py b/tests/unit/test_but_jury.py index fec4976c6..e4ea40e0e 100644 --- a/tests/unit/test_but_jury.py +++ b/tests/unit/test_but_jury.py @@ -19,7 +19,7 @@ pytest --pdb -m lyon tests/unit/test_but_jury.py """ import pytest -from tests.unit import yaml_setup +from tests.unit import yaml_setup, yaml_setup_but import app from app.but.jury_but_validation_auto import formsemestre_validation_auto_but @@ -46,7 +46,7 @@ def test_but_jury_GB(test_client): # Vérifie les deca de tous les semestres: for formsemestre in FormSemestre.query: - yaml_setup.check_deca_fields(formsemestre) + yaml_setup_but.check_deca_fields(formsemestre) # Saisie de toutes les décisions de jury for formsemestre in FormSemestre.query.order_by(FormSemestre.semestre_id): @@ -54,11 +54,11 @@ def test_but_jury_GB(test_client): # Vérifie résultats attendus: S1: FormSemestre = FormSemestre.query.filter_by(titre="S1_SEE").first() - yaml_setup.test_but_jury(S1, doc) + yaml_setup_but.but_test_jury(S1, doc) S2: FormSemestre = FormSemestre.query.filter_by(titre="S2_SEE").first() - yaml_setup.test_but_jury(S2, doc) + yaml_setup_but.but_test_jury(S2, doc) S3: FormSemestre = FormSemestre.query.filter_by(titre="S3").first() - yaml_setup.test_but_jury(S3, doc) + yaml_setup_but.but_test_jury(S3, doc) # _test_but_jury(S1_redoublant, doc) @@ -77,7 +77,7 @@ def test_but_jury_GMP_lm(test_client): # Vérifie les deca de tous les semestres: for formsemestre in formsemestres: - yaml_setup.check_deca_fields(formsemestre) + yaml_setup_but.check_deca_fields(formsemestre) # Saisie de toutes les décisions de jury qui ne le seraient pas déjà for formsemestre in formsemestres: @@ -85,7 +85,7 @@ def test_but_jury_GMP_lm(test_client): # Vérifie résultats attendus: for formsemestre in formsemestres: - yaml_setup.test_but_jury(formsemestre, doc) + yaml_setup_but.but_test_jury(formsemestre, doc) @pytest.mark.slow @@ -102,7 +102,7 @@ def test_but_jury_GEII_lyon(test_client): # Vérifie les champs de DecisionsProposeesAnnee de tous les semestres: for formsemestre in formsemestres: - yaml_setup.check_deca_fields(formsemestre) + yaml_setup_but.check_deca_fields(formsemestre) # Saisie de toutes les décisions de jury "automatiques" # et vérification des résultats attendus: @@ -110,4 +110,4 @@ def test_but_jury_GEII_lyon(test_client): formsemestre_validation_auto_but( formsemestre, only_adm=False, no_overwrite=False ) - yaml_setup.test_but_jury(formsemestre, doc) + yaml_setup_but.but_test_jury(formsemestre, doc) diff --git a/tests/unit/yaml_setup.py b/tests/unit/yaml_setup.py index 997298461..4d4c9257a 100644 --- a/tests/unit/yaml_setup.py +++ b/tests/unit/yaml_setup.py @@ -13,7 +13,7 @@ Le traitement est effectué dans l'ordre suivant: setup_from_yaml() - - setup_but_formation(): + - setup_formation(): - import de la formation (le test utilise une seule formation) - associe_ues_et_parcours(): - crée les associations formation <-> référentiel de compétence @@ -43,33 +43,22 @@ et donc marqués par `@pytest.mark.slow`. """ import os -from pathlib import Path -import re import yaml -from flask import current_app, g +from flask import g from app import db from app.auth.models import User -from app.but.import_refcomp import orebut_import_refcomp -from app.but.jury_but import ( - DecisionsProposeesAnnee, - DecisionsProposeesRCUE, - DecisionsProposeesUE, -) + from app.models import ( - ApcNiveau, ApcParcours, - ApcReferentielCompetences, Evaluation, Formation, FormSemestre, Identite, Module, ModuleImpl, - ModuleUECoef, - UniteEns, ) from app.scodoc import sco_formations @@ -79,9 +68,10 @@ from app.scodoc import sco_saisie_notes from app.scodoc import sco_utils as scu from tests.conftest import RESOURCES_DIR +from tests.unit import yaml_setup_but -def setup_but_formation(formation_infos: dict) -> Formation: +def setup_formation(formation_infos: dict) -> Formation: """Importe la formation, qui est lue à partir du fichier XML formation_infos["filename"]. La formation peut être quelconque, on vérifie juste qu'elle est bien créée. @@ -100,94 +90,7 @@ def setup_but_formation(formation_infos: dict) -> Formation: return formation -def setup_formation_referentiel(formation: Formation, refcomp_infos: dict): - """Associe la formation au référentiel de compétences""" - if not refcomp_infos: - return - refcomp_filename = refcomp_infos["filename"] - refcomp_specialite = refcomp_infos["specialite"] - # --- Chargement Référentiel - if ( - ApcReferentielCompetences.query.filter_by( - scodoc_orig_filename=refcomp_filename, dept_id=g.scodoc_dept_id - ).first() - is None - ): - # pas déjà chargé - filename = ( - Path(current_app.config["SCODOC_DIR"]) - / "ressources/referentiels/but2022/competences" - / refcomp_filename - ) - with open(filename, encoding="utf-8") as f: - xml_data = f.read() - referentiel_competence = orebut_import_refcomp( - xml_data, dept_id=g.scodoc_dept_id, orig_filename=Path(filename).name - ) - assert referentiel_competence - - # --- Association au référentiel de compétences - referentiel_competence = ApcReferentielCompetences.query.filter_by( - specialite=refcomp_specialite - ).first() # le recherche à nouveau (test) - assert referentiel_competence - formation.referentiel_competence_id = referentiel_competence.id - db.session.add(formation) - - -def associe_ues_et_parcours(formation: Formation, formation_infos: dict): - """Associe les UE et modules de la formation aux parcours du ref. comp.""" - referentiel_competence = formation.referentiel_competence - if not referentiel_competence: - return - # --- Association des UEs aux parcours niveaux de compétences - for ue_acronyme, ue_infos in formation_infos["ues"].items(): - ue: UniteEns = formation.ues.filter_by(acronyme=ue_acronyme).first() - assert ue is not None # l'UE doit exister dans la formation avec cet acronyme - # Parcours: - if ue_infos.get("parcours", False): - parcour = referentiel_competence.parcours.filter_by( - code=ue_infos["parcours"] - ).first() - assert parcour is not None # le parcours indiqué pour cette UE doit exister - ue.set_parcour(parcour) - - # Niveaux compétences: - competence = referentiel_competence.competences.filter_by( - titre=ue_infos["competence"] - ).first() - assert competence is not None # La compétence de titre indiqué doit exister - niveau: ApcNiveau = competence.niveaux.filter_by( - annee=ue_infos["annee"] - ).first() - assert niveau is not None # le niveau de l'année indiquée doit exister - ue.set_niveau_competence(niveau) - - db.session.commit() - associe_modules_et_parcours(formation, formation_infos) - - -def associe_modules_et_parcours(formation: Formation, formation_infos: dict): - """Associe les modules à des parcours, grâce au champ modules_parcours""" - for code_parcours, codes_modules in formation_infos.get( - "modules_parcours", {} - ).items(): - parcour = formation.referentiel_competence.parcours.filter_by( - code=code_parcours - ).first() - assert parcour is not None # code parcours doit exister dans le ref. comp. - for code_module in codes_modules: - for module in [ - module - for module in formation.modules - if re.match(code_module, module.code) - ]: - module.parcours.append(parcour) - db.session.add(module) - db.session.commit() - - -def _un_semestre( +def create_formsemestre( formation: Formation, parcours: list[ApcParcours], semestre_id: int, @@ -195,7 +98,8 @@ def _un_semestre( date_debut: str, date_fin: str, ) -> FormSemestre: - "Création d'un formsemestre" + "Création d'un formsemestre, avec ses modimpls et évaluations" + assert formation.is_apc() or not parcours # parcours seulement si APC formsemestre = FormSemestre( formation=formation, parcours=parcours, @@ -230,8 +134,10 @@ def _un_semestre( formsemestre.id, default=True, redirect=False ) _ = sco_groups.create_group(partition_id, default=True) + # Partition de parcours: - formsemestre.setup_parcours_groups() + if formsemestre.formation.is_apc(): + formsemestre.setup_parcours_groups() return formsemestre @@ -248,13 +154,17 @@ def create_evaluations(formsemestre: FormSemestre): numero=1, ) db.session.add(evaluation) - # Affecte les mêmes poids que les coefs APC: - ue_coef_dict = modimpl.module.get_ue_coef_dict() # { ue_id : coef } - evaluation.set_ue_poids_dict(ue_coef_dict) + + if formsemestre.formation.is_apc(): + # Affecte les mêmes poids que les coefs APC: + ue_coef_dict = modimpl.module.get_ue_coef_dict() # { ue_id : coef } + evaluation.set_ue_poids_dict(ue_coef_dict) def note_les_modules(doc: dict): - """Saisie les notes des étudiants""" + """Saisie les notes des étudiants + doc : données YAML + """ a_user = User.query.first() for nom, infos in doc["Etudiants"].items(): etud: Identite = Identite.query.filter_by(nom=nom).first() @@ -295,16 +205,21 @@ def note_les_modules(doc: dict): def setup_formsemestres(formation: Formation, doc: str): - """Création des formsemestres pour tester les parcours BUT""" + """Création des formsemestres + Le cas échéant associés à leur(s) parcours. + """ for titre, infos in doc["FormSemestres"].items(): + codes_parcours = infos.get("codes_parcours", []) + assert formation.is_apc() or not codes_parcours # parcours seulement en APC parcours = [] - for code_parcour in infos.get("codes_parcours", []): + for code_parcour in codes_parcours: parcour = formation.referentiel_competence.parcours.filter_by( code=code_parcour ).first() assert parcour is not None parcours.append(parcour) - _ = _un_semestre( + + _ = create_formsemestre( formation, parcours, infos["idx"], @@ -362,193 +277,12 @@ def setup_from_yaml(filename: str) -> dict: with open(filename, encoding="utf-8") as f: doc = yaml.safe_load(f.read()) - formation = setup_but_formation(doc["Formation"]) - setup_formation_referentiel(formation, doc.get("ReferentielCompetences", {})) - associe_ues_et_parcours(formation, doc["Formation"]) + formation = setup_formation(doc["Formation"]) + yaml_setup_but.setup_formation_referentiel( + formation, doc.get("ReferentielCompetences", {}) + ) + yaml_setup_but.associe_ues_et_parcours(formation, doc["Formation"]) setup_formsemestres(formation, doc) inscrit_les_etudiants(formation, doc) note_les_modules(doc) return doc - - -def _check_codes_jury(codes: list[str], codes_att: list[str]): - """Vérifie (assert) la liste des codes - l'ordre n'a pas d'importance ici. - Si codes_att contient un "...", on se contente de vérifier que - les codes de codes_att sont tous présents dans codes. - """ - codes_set = set(codes) - codes_att_set = set(codes_att) - if "..." in codes_att_set: - codes_att_set.remove("...") - assert codes_att_set.issubset(codes_set) - else: - assert codes_att_set == codes_set - - -def _check_decisions_ues( - decisions_ues: dict[int, DecisionsProposeesUE], decisions_ues_att: dict[str:dict] -): - """Vérifie les décisions d'UE - puis enregistre décision manuelle si indiquée dans le YAML. - """ - for acronyme, dec_ue_att in decisions_ues_att.items(): - # retrouve l'UE - ues_d = [ - dec_ue - for dec_ue in decisions_ues.values() - if dec_ue.ue.acronyme == acronyme - ] - assert len(ues_d) == 1 # une et une seule UE avec l'acronyme indiqué - dec_ue = ues_d[0] - if "codes" in dec_ue_att: - _check_codes_jury(dec_ue.codes, dec_ue_att["codes"]) - - for attr in ("explanation", "code_valide"): - if attr in dec_ue_att: - if getattr(dec_ue, attr) != dec_ue_att[attr]: - raise ValueError( - f"""Erreur: décision d'UE: {dec_ue.ue.acronyme - } : champs {attr}={getattr(dec_ue, attr)} != attendu {dec_ue_att[attr]}""" - ) - for attr in ("moy_ue", "moy_ue_with_cap"): - if attr in dec_ue_att: - assert ( - abs(getattr(dec_ue, attr) - dec_ue_att[attr]) < scu.NOTES_PRECISION - ) - # Force décision de jury: - code_manuel = dec_ue_att.get("decision_jury") - if code_manuel is not None: - assert code_manuel in dec_ue.codes - dec_ue.record(code_manuel) - - -def _check_decisions_rcues( - decisions_rcues: list[DecisionsProposeesRCUE], decisions_rcues_att: dict -): - "Vérifie les décisions d'RCUEs" - for acronyme, dec_rcue_att in decisions_rcues_att.items(): - # retrouve la décision RCUE à partir de l'acronyme de la 1ère UE - rcues_d = [ - dec_rcue - for dec_rcue in decisions_rcues - if dec_rcue.rcue.ue_1.acronyme == acronyme - ] - assert len(rcues_d) == 1 # un et un seul RCUE avec l'UE d'acronyme indiqué - dec_rcue = rcues_d[0] - if "codes" in dec_rcue_att: - _check_codes_jury(dec_rcue.codes, dec_rcue_att["codes"]) - for attr in ("explanation", "code_valide"): - if attr in dec_rcue_att: - assert getattr(dec_rcue, attr) == dec_rcue_att[attr] - # Descend dans le RCUE: - if "rcue" in dec_rcue_att: - if "moy_rcue" in dec_rcue_att["rcue"]: - assert ( - abs(dec_rcue.rcue.moy_rcue - dec_rcue_att["rcue"]["moy_rcue"]) - < scu.NOTES_PRECISION - ) - if "est_compensable" in dec_rcue_att["rcue"]: - assert ( - dec_rcue.rcue.est_compensable() - == dec_rcue_att["rcue"]["est_compensable"] - ) - # Force décision de jury: - code_manuel = dec_rcue_att.get("decision_jury") - if code_manuel is not None: - assert code_manuel in dec_rcue.codes - dec_rcue.record(code_manuel) - - -def compare_decisions_annee(deca: DecisionsProposeesAnnee, deca_att: dict): - """Vérifie que les résultats de jury calculés pour l'année, les RCUEs et les UEs - sont ceux attendus, - puis enregistre les décisions manuelles indiquées dans le YAML. - - deca est le résultat calculé par ScoDoc - deca_att est un dict lu du YAML - """ - if "codes" in deca_att: - _check_codes_jury(deca.codes, deca_att["codes"]) - - for attr in ("passage_de_droit", "code_valide", "nb_competences"): - if attr in deca_att: - assert getattr(deca, attr) == deca_att[attr] - - if "decisions_ues" in deca_att: - _check_decisions_ues(deca.decisions_ues, deca_att["decisions_ues"]) - - if "nb_rcues_annee" in deca_att: - assert deca_att["nb_rcues_annee"] == len(deca.rcues_annee) - - if "decisions_rcues" in deca_att: - _check_decisions_rcues( - deca.decisions_rcue_by_niveau.values(), deca_att["decisions_rcues"] - ) - # Force décision de jury: - code_manuel = deca_att.get("decision_jury") - if code_manuel is not None: - assert code_manuel in deca.codes - deca.record(code_manuel) - assert deca.recorded - - -def check_deca_fields(formsemestre: FormSemestre, etud: Identite = None): - """Vérifie les champs principaux (inscription, nb UE, nb compétences) - de l'instance de DecisionsProposeesAnnee. - Ne vérifie pas les décisions de jury proprement dites. - Si etud n'est pas spécifié, prend le premier inscrit trouvé dans le semestre. - """ - etud = etud or formsemestre.etuds.first() - assert etud # il faut au moins un étudiant dans le semestre - deca = DecisionsProposeesAnnee(etud, formsemestre) - assert deca.validation is None # pas encore de validation enregistrée - assert False is deca.recorded - assert deca.code_valide is None - if formsemestre.semestre_id % 2: - assert deca.formsemestre_impair == formsemestre - assert formsemestre.query_ues_parcours_etud(etud.id).all() == deca.ues_impair - else: - assert deca.formsemestre_pair == formsemestre - assert formsemestre.query_ues_parcours_etud(etud.id).all() == deca.ues_pair - assert deca.inscription_etat == scu.INSCRIT - assert deca.inscription_etat_impair == scu.INSCRIT - assert (deca.parcour is None) or ( - deca.parcour.id in {p.id for p in formsemestre.parcours} - ) - - nb_ues = ( - len(deca.formsemestre_pair.query_ues_parcours_etud(etud.id).all()) - if deca.formsemestre_pair - else 0 - ) - nb_ues += ( - len(deca.formsemestre_impair.query_ues_parcours_etud(etud.id).all()) - if deca.formsemestre_impair - else 0 - ) - assert len(deca.decisions_ues) == nb_ues - - nb_ues_un_sem = ( - len(deca.formsemestre_impair.query_ues_parcours_etud(etud.id).all()) - if deca.formsemestre_impair - else len(deca.formsemestre_pair.query_ues_parcours_etud(etud.id).all()) - ) - assert len(deca.niveaux_competences) == nb_ues_un_sem - assert deca.nb_competences == nb_ues_un_sem - - -def test_but_jury(formsemestre: FormSemestre, doc: dict): - """Test jurys BUT - Vérifie les champs de DecisionsProposeesAnnee et UEs - """ - for etud in formsemestre.etuds: - deca = DecisionsProposeesAnnee(etud, formsemestre) - doc_formsemestre = doc["Etudiants"][etud.nom]["formsemestres"][ - formsemestre.titre - ] - assert doc_formsemestre - if "attendu" in doc_formsemestre: - if "deca" in doc_formsemestre["attendu"]: - deca_att = doc_formsemestre["attendu"]["deca"] - compare_decisions_annee(deca, deca_att) diff --git a/tests/unit/yaml_setup_but.py b/tests/unit/yaml_setup_but.py new file mode 100644 index 000000000..c11e58288 --- /dev/null +++ b/tests/unit/yaml_setup_but.py @@ -0,0 +1,304 @@ +############################################################################## +# ScoDoc +# Copyright (c) 1999 - 2023 Emmanuel Viennet. All rights reserved. +# See LICENSE +############################################################################## + +"""Mise en place pour tests unitaires à partir de descriptions YAML: + fonctions spécifiques au BUT +""" +from pathlib import Path +import re + +from flask import current_app, g + +from app import db +from app.but.import_refcomp import orebut_import_refcomp +from app.but.jury_but import ( + DecisionsProposeesAnnee, + DecisionsProposeesRCUE, + DecisionsProposeesUE, +) + +from app.models import ( + ApcNiveau, + ApcReferentielCompetences, + Formation, + FormSemestre, + Identite, + UniteEns, +) +from app.scodoc import sco_utils as scu + + +def setup_formation_referentiel(formation: Formation, refcomp_infos: dict): + """Si il y a un référentiel de compétences, indiqué dans le YAML, + le charge au besoin et l'associe à la formation. + """ + if not refcomp_infos: + return + assert formation.is_apc() # si ref; comp., doit être APC + refcomp_filename = refcomp_infos["filename"] + refcomp_specialite = refcomp_infos["specialite"] + # --- Chargement Référentiel + if ( + ApcReferentielCompetences.query.filter_by( + scodoc_orig_filename=refcomp_filename, dept_id=g.scodoc_dept_id + ).first() + is None + ): + # pas déjà chargé + filename = ( + Path(current_app.config["SCODOC_DIR"]) + / "ressources/referentiels/but2022/competences" + / refcomp_filename + ) + with open(filename, encoding="utf-8") as f: + xml_data = f.read() + referentiel_competence = orebut_import_refcomp( + xml_data, dept_id=g.scodoc_dept_id, orig_filename=Path(filename).name + ) + assert referentiel_competence + + # --- Association au référentiel de compétences + referentiel_competence = ApcReferentielCompetences.query.filter_by( + specialite=refcomp_specialite + ).first() # le recherche à nouveau (test) + assert referentiel_competence + formation.referentiel_competence_id = referentiel_competence.id + db.session.add(formation) + + +def associe_ues_et_parcours(formation: Formation, formation_infos: dict): + """Associe les UE et modules de la formation aux parcours du ref. comp.""" + referentiel_competence = formation.referentiel_competence + if not referentiel_competence: + return + # --- Association des UEs aux parcours niveaux de compétences + for ue_acronyme, ue_infos in formation_infos["ues"].items(): + ue: UniteEns = formation.ues.filter_by(acronyme=ue_acronyme).first() + assert ue is not None # l'UE doit exister dans la formation avec cet acronyme + # Parcours: + if ue_infos.get("parcours", False): + parcour = referentiel_competence.parcours.filter_by( + code=ue_infos["parcours"] + ).first() + assert parcour is not None # le parcours indiqué pour cette UE doit exister + ue.set_parcour(parcour) + + # Niveaux compétences: + competence = referentiel_competence.competences.filter_by( + titre=ue_infos["competence"] + ).first() + assert competence is not None # La compétence de titre indiqué doit exister + niveau: ApcNiveau = competence.niveaux.filter_by( + annee=ue_infos["annee"] + ).first() + assert niveau is not None # le niveau de l'année indiquée doit exister + ue.set_niveau_competence(niveau) + + db.session.commit() + associe_modules_et_parcours(formation, formation_infos) + + +def associe_modules_et_parcours(formation: Formation, formation_infos: dict): + """Associe les modules à des parcours, grâce au champ modules_parcours""" + for code_parcours, codes_modules in formation_infos.get( + "modules_parcours", {} + ).items(): + parcour = formation.referentiel_competence.parcours.filter_by( + code=code_parcours + ).first() + assert parcour is not None # code parcours doit exister dans le ref. comp. + for code_module in codes_modules: + for module in [ + module + for module in formation.modules + if re.match(code_module, module.code) + ]: + module.parcours.append(parcour) + db.session.add(module) + db.session.commit() + + +def _check_codes_jury(codes: list[str], codes_att: list[str]): + """Vérifie (assert) la liste des codes + l'ordre n'a pas d'importance ici. + Si codes_att contient un "...", on se contente de vérifier que + les codes de codes_att sont tous présents dans codes. + """ + codes_set = set(codes) + codes_att_set = set(codes_att) + if "..." in codes_att_set: + codes_att_set.remove("...") + assert codes_att_set.issubset(codes_set) + else: + assert codes_att_set == codes_set + + +def but_check_decisions_ues( + decisions_ues: dict[int, DecisionsProposeesUE], decisions_ues_att: dict[str:dict] +): + """Vérifie les décisions d'UE + puis enregistre décision manuelle si indiquée dans le YAML. + """ + for acronyme, dec_ue_att in decisions_ues_att.items(): + # retrouve l'UE + ues_d = [ + dec_ue + for dec_ue in decisions_ues.values() + if dec_ue.ue.acronyme == acronyme + ] + assert len(ues_d) == 1 # une et une seule UE avec l'acronyme indiqué + dec_ue = ues_d[0] + if "codes" in dec_ue_att: + _check_codes_jury(dec_ue.codes, dec_ue_att["codes"]) + + for attr in ("explanation", "code_valide"): + if attr in dec_ue_att: + if getattr(dec_ue, attr) != dec_ue_att[attr]: + raise ValueError( + f"""Erreur: décision d'UE: {dec_ue.ue.acronyme + } : champs {attr}={getattr(dec_ue, attr)} != attendu {dec_ue_att[attr]}""" + ) + for attr in ("moy_ue", "moy_ue_with_cap"): + if attr in dec_ue_att: + assert ( + abs(getattr(dec_ue, attr) - dec_ue_att[attr]) < scu.NOTES_PRECISION + ) + # Force décision de jury: + code_manuel = dec_ue_att.get("decision_jury") + if code_manuel is not None: + assert code_manuel in dec_ue.codes + dec_ue.record(code_manuel) + + +def but_check_decisions_rcues( + decisions_rcues: list[DecisionsProposeesRCUE], decisions_rcues_att: dict +): + "Vérifie les décisions d'RCUEs" + for acronyme, dec_rcue_att in decisions_rcues_att.items(): + # retrouve la décision RCUE à partir de l'acronyme de la 1ère UE + rcues_d = [ + dec_rcue + for dec_rcue in decisions_rcues + if dec_rcue.rcue.ue_1.acronyme == acronyme + ] + assert len(rcues_d) == 1 # un et un seul RCUE avec l'UE d'acronyme indiqué + dec_rcue = rcues_d[0] + if "codes" in dec_rcue_att: + _check_codes_jury(dec_rcue.codes, dec_rcue_att["codes"]) + for attr in ("explanation", "code_valide"): + if attr in dec_rcue_att: + assert getattr(dec_rcue, attr) == dec_rcue_att[attr] + # Descend dans le RCUE: + if "rcue" in dec_rcue_att: + if "moy_rcue" in dec_rcue_att["rcue"]: + assert ( + abs(dec_rcue.rcue.moy_rcue - dec_rcue_att["rcue"]["moy_rcue"]) + < scu.NOTES_PRECISION + ) + if "est_compensable" in dec_rcue_att["rcue"]: + assert ( + dec_rcue.rcue.est_compensable() + == dec_rcue_att["rcue"]["est_compensable"] + ) + # Force décision de jury: + code_manuel = dec_rcue_att.get("decision_jury") + if code_manuel is not None: + assert code_manuel in dec_rcue.codes + dec_rcue.record(code_manuel) + + +def but_compare_decisions_annee(deca: DecisionsProposeesAnnee, deca_att: dict): + """Vérifie que les résultats de jury calculés pour l'année, les RCUEs et les UEs + sont ceux attendus, + puis enregistre les décisions manuelles indiquées dans le YAML. + + deca est le résultat calculé par ScoDoc + deca_att est un dict lu du YAML + """ + if "codes" in deca_att: + _check_codes_jury(deca.codes, deca_att["codes"]) + + for attr in ("passage_de_droit", "code_valide", "nb_competences"): + if attr in deca_att: + assert getattr(deca, attr) == deca_att[attr] + + if "decisions_ues" in deca_att: + but_check_decisions_ues(deca.decisions_ues, deca_att["decisions_ues"]) + + if "nb_rcues_annee" in deca_att: + assert deca_att["nb_rcues_annee"] == len(deca.rcues_annee) + + if "decisions_rcues" in deca_att: + but_check_decisions_rcues( + deca.decisions_rcue_by_niveau.values(), deca_att["decisions_rcues"] + ) + # Force décision de jury: + code_manuel = deca_att.get("decision_jury") + if code_manuel is not None: + assert code_manuel in deca.codes + deca.record(code_manuel) + assert deca.recorded + + +def check_deca_fields(formsemestre: FormSemestre, etud: Identite = None): + """Vérifie les champs principaux (inscription, nb UE, nb compétences) + de l'instance de DecisionsProposeesAnnee. + Ne vérifie pas les décisions de jury proprement dites. + Si etud n'est pas spécifié, prend le premier inscrit trouvé dans le semestre. + """ + etud = etud or formsemestre.etuds.first() + assert etud # il faut au moins un étudiant dans le semestre + deca = DecisionsProposeesAnnee(etud, formsemestre) + assert deca.validation is None # pas encore de validation enregistrée + assert False is deca.recorded + assert deca.code_valide is None + if formsemestre.semestre_id % 2: + assert deca.formsemestre_impair == formsemestre + assert formsemestre.query_ues_parcours_etud(etud.id).all() == deca.ues_impair + else: + assert deca.formsemestre_pair == formsemestre + assert formsemestre.query_ues_parcours_etud(etud.id).all() == deca.ues_pair + assert deca.inscription_etat == scu.INSCRIT + assert deca.inscription_etat_impair == scu.INSCRIT + assert (deca.parcour is None) or ( + deca.parcour.id in {p.id for p in formsemestre.parcours} + ) + + nb_ues = ( + len(deca.formsemestre_pair.query_ues_parcours_etud(etud.id).all()) + if deca.formsemestre_pair + else 0 + ) + nb_ues += ( + len(deca.formsemestre_impair.query_ues_parcours_etud(etud.id).all()) + if deca.formsemestre_impair + else 0 + ) + assert len(deca.decisions_ues) == nb_ues + + nb_ues_un_sem = ( + len(deca.formsemestre_impair.query_ues_parcours_etud(etud.id).all()) + if deca.formsemestre_impair + else len(deca.formsemestre_pair.query_ues_parcours_etud(etud.id).all()) + ) + assert len(deca.niveaux_competences) == nb_ues_un_sem + assert deca.nb_competences == nb_ues_un_sem + + +def but_test_jury(formsemestre: FormSemestre, doc: dict): + """Test jurys BUT + Vérifie les champs de DecisionsProposeesAnnee et UEs + """ + for etud in formsemestre.etuds: + deca = DecisionsProposeesAnnee(etud, formsemestre) + doc_formsemestre = doc["Etudiants"][etud.nom]["formsemestres"][ + formsemestre.titre + ] + assert doc_formsemestre + if "attendu" in doc_formsemestre: + if "deca" in doc_formsemestre["attendu"]: + deca_att = doc_formsemestre["attendu"]["deca"] + but_compare_decisions_annee(deca, deca_att)