From a7324ac63419640f78fb20454378d0cf6f84425d Mon Sep 17 00:00:00 2001 From: Emmanuel Viennet Date: Sat, 15 Jan 2022 21:36:06 +0100 Subject: [PATCH] =?UTF-8?q?d=C3=A9but=20de=20modernisation=20des=20tests?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/scodoc/sco_saisie_notes.py | 4 +- .../versions/f40fbaf5831c_index_ine_et_nip.py | 2 +- tests/data/but-RT-refcomp-exemple.xml | 544 ------------------ tests/unit/sco_fake_gen.py | 74 +-- tests/unit/setup.py | 65 ++- tests/unit/test_abs_counts.py | 32 +- tests/unit/test_abs_demijournee.py | 62 +- tests/unit/test_but_modules.py | 15 +- tests/unit/test_but_ues.py | 5 +- tests/unit/test_formations.py | 163 +++--- tests/unit/test_notes_modules.py | 87 ++- tests/unit/test_notes_rattrapage.py | 33 +- tests/unit/test_refcomp.py | 4 +- tests/unit/test_sco_basic.py | 52 +- 14 files changed, 318 insertions(+), 824 deletions(-) delete mode 100644 tests/data/but-RT-refcomp-exemple.xml diff --git a/app/scodoc/sco_saisie_notes.py b/app/scodoc/sco_saisie_notes.py index 7f7012db9..fc3fd0818 100644 --- a/app/scodoc/sco_saisie_notes.py +++ b/app/scodoc/sco_saisie_notes.py @@ -597,7 +597,7 @@ def notes_add( nb_changed += 1 if has_existing_decision(M, E, etudid): existing_decisions.append(etudid) - except: + except Exception as exc: log("*** exception in notes_add") if do_it: cnx.rollback() # abort @@ -606,7 +606,7 @@ def notes_add( formsemestre_id=M["formsemestre_id"] ) # > modif notes (exception) sco_cache.EvaluationCache.delete(evaluation_id) - raise ScoGenError("Erreur enregistrement note: merci de ré-essayer") + raise ScoGenError("Erreur enregistrement note: merci de ré-essayer") from exc if do_it: cnx.commit() sco_cache.invalidate_formsemestre( diff --git a/migrations/versions/f40fbaf5831c_index_ine_et_nip.py b/migrations/versions/f40fbaf5831c_index_ine_et_nip.py index 7ff0473d4..015596159 100644 --- a/migrations/versions/f40fbaf5831c_index_ine_et_nip.py +++ b/migrations/versions/f40fbaf5831c_index_ine_et_nip.py @@ -11,7 +11,7 @@ from sqlalchemy.dialects import postgresql # revision identifiers, used by Alembic. revision = "f40fbaf5831c" -down_revision = "91be8a06d423" +down_revision = "197c658cefbb" branch_labels = None depends_on = None diff --git a/tests/data/but-RT-refcomp-exemple.xml b/tests/data/but-RT-refcomp-exemple.xml deleted file mode 100644 index 40cd8ba3b..000000000 --- a/tests/data/but-RT-refcomp-exemple.xml +++ /dev/null @@ -1,544 +0,0 @@ - - - - - - Conception et administration de l’infrastructure du réseau informatique d’une entreprise - Installation et administration des services réseau informatique d’une entreprise - Déploiement et administration des solutions fixes pour les clients d’un opérateur de télécommunication - - - en choisissant les solutions et technologies réseaux adaptées - en respectant les principes fondamentaux de la sécurité informatique - en utilisant une approche rigoureuse pour la résolution des dysfonctionnements - en respectant les règles métiers - en assurant une veille technologique - - - - - Maîtriser les lois fondamentales de l’électricité afin d’intervenir sur des équipements de réseaux et télécommunications - Comprendre l'architecture et les fondements des systèmes numériques, les principes du codage de l'information, des communications et de l'Internet - Configurer les fonctions de base du réseau local - Maîtriser les rôles et les principes fondamentaux des systèmes d’exploitation afin d’interagir avec ceux-ci pour la configuration et l'administration des réseaux et services fournis - Identifier les dysfonctionnements du réseau local et savoir les signaler - Installer un poste client, expliquer la procédure mise en place - - - - - Configurer et dépanner le routage dynamique dans un réseau - Configurer et expliquer une politique simple de QoS et les fonctions de base de la sécurité d’un réseau - Déployer des postes clients et des solutions virtualisées adaptées à une situation donnée - Déployer des services réseaux avancés - Identifier les réseaux opérateurs et l’architecture d’Internet - Travailler en équipe pour développer ses compétences professionnelles - - - - - Concevoir un projet de réseau informatique d’une entreprise en intégrant les problématiques de haute disponibilité, de QoS, de sécurité et de supervision - Réaliser la documentation technique de ce projet - Réaliser une maquette de démonstration du projet - Défendre/argumenter un projet - Communiquer avec les acteurs du projet - Gérer le projet et les différentes étapes de sa mise en œuvre en respectant les délais - - - - - - - Déploiement des supports et systèmes de transmission - Mise en service et administration des équipements d’accès fixe ou mobile d’un opérateur de télécommunications - Déploiement et administration des accès sans fil pour l'entreprise - Déploiement des systèmes de communications - - - en communiquant avec le client et les différents acteurs impliqués, parfois en anglais - en faisant preuve d’une démarche scientifique - en choisissant les solutions et technologies adaptées - en proposant des solutions respectueuses de l'environnement - - - - - Mesurer, analyser et commenter les signaux - Caractériser des systèmes de transmissions élémentaires et découvrir la modélisation mathématique de leur fonctionnement - Déployer des supports de transmission - Connecter les systèmes de ToIP - Communiquer avec un tiers (client, collaborateur...) et adapter son discours et sa langue à son interlocuteur - - - - - Déployer et caractériser des systèmes de transmissions complexes - Mettre en place un accès distant sécurisé - Mettre en place une connexion multi-site via un réseau opérateur - Déployer des réseaux d’accès des opérateurs - Capacité à questionner un cahier des charges RT - - - - - Déployer un système de communication pour l’entreprise - Déployer un réseau d’accès sans fil pour le réseau d’entreprise en intégrant les enjeux de la sécurité - Déployer un réseau d’accès fixe ou mobile pour un opérateur de télécommunications en intégrant la sécurité - Permettre aux collaborateurs de se connecter de manière sécurisée au système d’information de l’entreprise - Collaborer en mode projet en français et en anglais - - - - - - - Conception, déploiement et maintenance du système d’information d’une entreprise - Automatisation du déploiement et de la maintenance des outils logiciels - Développement d’outils informatiques à usage interne d'une équipe - - - en étant à l’écoute des besoins du client - en documentant le travail réalisé - en utilisant les outils numériques à bon escient - en choisissant les outils de développement adaptés - en intégrant les problématiques de sécurité - - - - - Utiliser un système informatique et ses outils - Lire, exécuter, corriger et modifier un programme - Traduire un algorithme, dans un langage et pour un environnement donné - Connaître l’architecture et les technologies d’un site Web - Choisir les mécanismes de gestion de données adaptés au développement de l’outil et argumenter ses choix - S’intégrer dans un environnement propice au développement et au travail collaboratif - - - - - Automatiser l’administration système avec des scripts - Développer une application à partir d’un cahier des charges donné, pour le Web ou les périphériques mobiles - Utiliser un protocole réseau pour programmer une application client/serveur - Installer, administrer un système de gestion de données - Accéder à un ensemble de données depuis une application et/ou un site web - - - - - Élaborer les spécifications techniques et le cahier des charges d’une application informatique - Mettre en place un environnement de travail collaboratif - Participer à la formation des utilisateurs - Déployer et maintenir une solution informatique - S’informer sur les évolutions et les nouveautés technologiques - Sécuriser l'environnement numérique d'une application - - - - - - - Analyse de l’existant et étude des besoins de sécurité d’une petite structure - Évolution et mise en conformité du système d’information d’une entreprise - - - en visant un juste compromis entre exigences de sécurité et contraintes d’utilisation - en respectant les normes et le cadre juridique - en intégrant les dernières technologies - en travaillant en équipe - en sensibilisant efficacement des utilisateurs - - - - - Connaître et utiliser les bonnes pratiques et les recommandations de cybersécurité - Mettre en œuvre les outils fondamentaux de sécurisation d’une infrastructure du réseau - Sécuriser les services - Choisir les outils cryptographiques adaptés au besoin fonctionnel du système d’information - Connaître les différents types d’attaque - Comprendre des documents techniques en anglais - - - - - Participer activement à une analyse de risque pour définir une politique de sécurité pour une petite structure - Mettre en œuvre des outils avancés de sécurisation d’une infrastructure du réseau - Sécuriser les systèmes d’exploitation - Proposer une architecture sécurisée de système d'information pour une petite structure - - - - - - - Industrialisation du déploiement des infrastructures systèmes, réseaux et sécurité en sauvegardant et en restaurant ses configurations - Maintenance des outils pour l’intégration et la mise en production du code logiciel - Administration d’un cluster de containers - Analyse des performances d’un système pour améliorer les processus de production - - - en respectant un cahier des charges - en documentant le travail réalisé - en intégrant les problématiques de sécurité - en assurant une veille technologique - en respectant les pratiques d’équipes et des méthodes de production - - - - - Proposer une solution Cloud adaptée à l’entreprise - Virtualiser un environnement - Utiliser les services du Cloud - Analyser un service Cloud au travers des métriques - - - - - Concevoir, administrer et superviser une infrastructure Cloud - Orchestrer les ressources Cloud - Investiguer sur les incidents et les résoudre afin d’améliorer la qualité et la fiabilité des infrastructures - - - - - - - Gestion des infrastructures d’un opérateur de réseaux mobiles et d’Internet des Objets - Gestion des infrastructures de réseaux mobiles dans le contexte industriel, personnel ou médical - - - en respectant les normes et protocoles en vigueur - en intégrant les dernières technologies mobiles - - - - - Comprendre les architectures et spécificités des réseaux dédiés à l'IoT - Mettre en œuvre des systèmes de transmissions pour l’accès à un réseau IoT - - - - - Comprendre les architectures, protocoles et services des réseaux mobiles 4G/5G - Choisir un réseau pour satisfaire les contraintes énergétiques et spectrales, en délai, en débit et en portée des objets connectés - Mettre en œuvre des réseaux mobiles personnels ou industriels - - - - - - - Adéquation technique des solutions réseaux informatiques et télécoms à la demande client - Élaboration de solutions techniques clients adaptées - Accompagnement technique de la mise en place des solutions clients - - - en maîtrisant les enjeux techniques et réglementaires des nouvelles technologies - en pilotant un projet technique R&T - en faisant preuve de vision stratégique en phase avec le marché des réseaux et des télécommunications - en collaborant de façon responsable avec des équipes - - - - - Compréhension d’un cahier des charges technique R&T - Planification des étapes d’un projet technique R&T - Co-animation d’une équipe technique - Proposition de solutions techniques R&T efficientes - Échanges vulgarisés ou techniques avec tous les acteurs d’un projet - - - - - Rédaction d'un appel d'offres ou d'un cahier des charges technique R&T - Animation technique d’équipes pluridisciplinaires - Coordination d’équipes sur une partie de projet R&T ou sa totalité - Mise en place de solutions techniques R&T efficientes - Livraison et suivi technique de projet R&T - - - - - - - Gestion des services d’un ensemble de clients entreprises d’un opérateur - Gestion du déploiement de nouvelles infrastructures - - - en respectant les règles métiers et les délais - en assurant une communication optimale avec le client - en mettant en place des processus opérationnels de gestion d’incidents - en pilotant les acteurs terrain - - - - - Administrer les réseaux d’accès fixes et mobiles - Virtualiser des services réseaux - Décrire/comprendre l’architecture et les offres des opérateurs - Gérer le routage/commutation et les interconnexions - Automatiser la gestion des équipements réseaux - - - - - Administrer/superviser les infrastructures et les services télécom - Administrer et déployer des fonctions réseaux virtualisées et programmer le réseau - - - - - - - Surveillance et analyse du système d’information - Audit de sécurité - Gestion d’un incident de sécurité - - - en assurant une veille permanente - en réalisant les mises à jour critiques - en automatisant des tâches - en s’intégrant dans une équipe - en surveillant le comportement du réseau - en veillant au respect des contrats et à la conformité des obligations du système d'information - - - - - Administrer les protections contre les logiciels malveillants - Prendre en main des outils de test de pénétration réseau/système - - - - - Surveiller l’activité du système d’information - Appliquer une méthodologie de tests de pénétration - Réagir face à un incident de sécurité - Administrer les outils de surveillance du système d’information - - - - - - - Déploiement d’une application - Intervention sur la chaîne de développement dans une optique DevOps - Surveillance de la qualité de la production - Mise en place des services réseaux nécessaires au développement - - - en respectant un cahier des charges - en documentant le travail réalisé - en respectant les bonnes pratiques de développement et de production - en visant l’amélioration continue - - - - - Développer un microservice - Mettre en production une application - Programmer son réseau par le code - - - - - Adopter les pratiques de pilotage de projet - Concevoir, gérer et sécuriser un environnement de microservices - Gérer son infrastructure comme du code - Gérer une chaîne d’intégration et/ou de déploiement continu - - - - - - - Déploiement d’un système IoT de la source capteur aux traitements des données - Gestion, administration et sécurisation d’un système IoT - - - en travaillant au sein d’une équipe pluridisciplinaire - en respectant les normes et contraintes opérationnelles - - - - - Intégrer des systèmes électroniques et des systèmes d’exploitation embarqués - Mettre en œuvre des protocoles pour les réseaux de l’IoT - Mettre en œuvre des applications et traiter des données issues des objets connectés - - - - - Superviser et analyser le déploiement des réseaux sans-fil - Sécuriser les objets connectés - Créer et innover pour l’IoT - - - - - - - Communication et stratégie technique en interne et en externe pour des projets R&T - Suivi des objectifs opérationnels de projets R&T - Pilotage de la relation client - - - en pilotant avec agilité des solutions techniques - en sachant communiquer à l’écrit et à l’oral avec tous les acteurs d’un projet - en respectant des contraintes technico-économiques (financières, éthiques, temporelles, contractuelles, qualité) - - - - - Prise en compte des contraintes d’un pilotage de projet R&T - Planification de solutions techniques R&T efficientes - Prise de conscience des enjeux de la communication dans les relations interpersonnelles - Établissement d’un relationnel de qualité - - - - - Rigueur dans le pilotage d’un projet R&T dans sa globalité - Flexibilité dans la gestion des équipes et des tâches - Prise de responsabilité envers les équipes - Valorisation de solutions déployées, ou d’offres techniques, ou d’offres commerciales - Force de propositions de solutions R&T innovantes responsables - - - - - - - Déploiement et administration des services de communication - Administration des services multimédia - - - en automatisant la gestion réseau des communications - en sécurisant les infrastructures - en gérant les interconnexions - en assurant une communication optimale avec le client - en respectant les règles métiers et les délais - - - - - Choisir une architecture et déployer des services de ToIP - Administrer un service de téléphonie pour l’entreprise - Mettre en place une politique de QoS pour les applications - - - - - Administrer les services multimédias pour une entreprise - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/tests/unit/sco_fake_gen.py b/tests/unit/sco_fake_gen.py index df530862f..a07e81169 100644 --- a/tests/unit/sco_fake_gen.py +++ b/tests/unit/sco_fake_gen.py @@ -143,7 +143,7 @@ class ScoFake(object): type_parcours=sco_codes_parcours.ParcoursDUT.TYPE_PARCOURS, formation_code=None, code_specialite=None, - ): + ) -> int: """Crée une formation""" if not acronyme: acronyme = "TEST" + str(random.randint(100000, 999999)) @@ -151,7 +151,7 @@ class ScoFake(object): oids = sco_formations.formation_list(formation_id=oid) if not oids: raise ScoValueError("formation not created !") - return oids[0] + return oid @logging_meth def create_ue( @@ -167,23 +167,25 @@ class ScoFake(object): code_apogee=None, coefficient=None, semestre_idx=None, - ): - """Crée une UE""" + ) -> int: + """Crée une UE. + return: ue_id + """ if numero is None: numero = sco_edit_ue.next_ue_numero(formation_id, 0) oid = sco_edit_ue.do_ue_create(locals()) oids = sco_edit_ue.ue_list(args={"ue_id": oid}) if not oids: raise ScoValueError("ue not created !") - return oids[0] + return oid @logging_meth - def create_matiere(self, ue_id=None, titre=None, numero=None): + def create_matiere(self, ue_id=None, titre=None, numero=None) -> int: oid = sco_edit_matiere.do_matiere_create(locals()) oids = sco_edit_matiere.matiere_list(args={"matiere_id": oid}) if not oids: raise ScoValueError("matiere not created !") - return oids[0] + return oid @logging_meth def create_module( @@ -203,12 +205,12 @@ class ScoFake(object): ects=None, code_apogee=None, module_type=None, - ): + ) -> int: oid = sco_edit_module.do_module_create(locals()) oids = sco_edit_module.module_list(args={"module_id": oid}) if not oids: raise ScoValueError("module not created ! (oid=%s)" % oid) - return oids[0] + return oid @logging_meth def create_formsemestre( @@ -232,7 +234,7 @@ class ScoFake(object): elt_annee_apo=None, etapes=None, responsables=None, # sequence of resp. ids - ): + ) -> int: if responsables is None: responsables = (self.default_user.id,) oid = sco_formsemestre.do_formsemestre_create(locals()) @@ -241,7 +243,7 @@ class ScoFake(object): ) # API inconsistency if not oids: raise ScoValueError("formsemestre not created !") - return oids[0] + return oid @logging_meth def create_moduleimpl( @@ -249,19 +251,19 @@ class ScoFake(object): module_id: int = None, formsemestre_id: int = None, responsable_id: typing.Optional[int] = None, - ): + ) -> int: if not responsable_id: responsable_id = self.default_user.id oid = sco_moduleimpl.do_moduleimpl_create(locals()) oids = sco_moduleimpl.moduleimpl_list(moduleimpl_id=oid) # API inconsistency if not oids: raise ScoValueError("moduleimpl not created !") - return oids[0] + return oid @logging_meth - def inscrit_etudiant(self, sem, etud): + def inscrit_etudiant(self, formsemestre_id: int, etud: dict): sco_formsemestre_inscriptions.do_formsemestre_inscription_with_modules( - sem["formsemestre_id"], + formsemestre_id, etud["etudid"], etat="I", etape=etud.get("etape", None), @@ -323,32 +325,32 @@ class ScoFake(object): et dans chaque UE `nb_module_per_ue` modules (on a une seule matière par UE). Returns: - formation (dict), liste d'ue (dicts), liste de modules. + formation_id, liste d'ue (dicts), liste de modules. """ - f = self.create_formation(acronyme=acronyme, titre=titre) - ues = [] - mod_list = [] + formation_id = self.create_formation(acronyme=acronyme, titre=titre) + ue_ids = [] + mod_ids = [] for semestre_id in range(1, nb_semestre + 1): for n in range(1, nb_ue_per_semestre + 1): - ue = self.create_ue( - formation_id=f["formation_id"], + ue_id = self.create_ue( + formation_id=formation_id, acronyme="TSU%s%s" % (semestre_id, n), titre="ue test %s%s" % (semestre_id, n), ) - ues.append(ue) - mat = self.create_matiere(ue_id=ue["ue_id"], titre="matière test") + ue_ids.append(ue_id) + matiere_id = self.create_matiere(ue_id=ue_id, titre="matière test") for _ in range(nb_module_per_ue): mod = self.create_module( - matiere_id=mat["matiere_id"], + matiere_id=matiere_id, semestre_id=semestre_id, - code="TSM%s" % len(mod_list), + code="TSM%s" % len(mod_ids), coefficient=1.0, titre="module test", - ue_id=ue["ue_id"], # faiblesse de l'API - formation_id=f["formation_id"], # faiblesse de l'API + ue_id=ue_id, + formation_id=formation_id, ) - mod_list.append(mod) - return f, ues, mod_list + mod_ids.append(mod) + return formation_id, ue_ids, mod_ids def setup_formsemestre( self, @@ -363,7 +365,7 @@ class ScoFake(object): modalite=None, ): """Création semestre, avec modules et évaluations.""" - sem = self.create_formsemestre( + formsemestre_id = self.create_formsemestre( formation_id=f["formation_id"], semestre_id=semestre_id, date_debut=date_debut, @@ -375,20 +377,20 @@ class ScoFake(object): eval_list = [] for mod in mod_list: if mod["semestre_id"] == semestre_id: - mi = self.create_moduleimpl( + moduleimpl_id = self.create_moduleimpl( module_id=mod["module_id"], - formsemestre_id=sem["formsemestre_id"], + formsemestre_id=formsemestre_id, responsable_id="bach", ) for e_idx in range(1, nb_evaluations_per_module + 1): e = self.create_evaluation( - moduleimpl_id=mi["moduleimpl_id"], + moduleimpl_id=moduleimpl_id, jour=date_debut, description="evaluation test %s" % e_idx, coefficient=1.0, ) eval_list.append(e) - return sem, eval_list + return formsemestre_id, eval_list def set_etud_notes_sem( self, sem, eval_list, etuds, notes=None, random_min=0, random_max=20 @@ -411,7 +413,7 @@ class ScoFake(object): def set_code_jury( self, - sem, + formsemestre_id, etud, code_etat=sco_codes_parcours.ADM, devenir=sco_codes_parcours.NEXT, @@ -419,7 +421,7 @@ class ScoFake(object): ): """Affecte décision de jury""" sco_formsemestre_validation.formsemestre_validation_etud_manu( - formsemestre_id=sem["formsemestre_id"], + formsemestre_id=formsemestre_id, etudid=etud["etudid"], code_etat=code_etat, devenir=devenir, diff --git a/tests/unit/setup.py b/tests/unit/setup.py index f043ba597..f9798f199 100644 --- a/tests/unit/setup.py +++ b/tests/unit/setup.py @@ -10,41 +10,67 @@ import app.scodoc.sco_utils as scu from app.scodoc import sco_codes_parcours -def build_formation_test(nb_mods=1): +def build_formation_test( + nb_mods=1, parcours=sco_codes_parcours.ParcoursBUT, with_ue_sport=False +): G = sco_fake_gen.ScoFake(verbose=False) - _f = G.create_formation( + formation_id = G.create_formation( acronyme="F3", titre="Formation 2", titre_officiel="Titre officiel 2", - type_parcours=sco_codes_parcours.ParcoursBUT.TYPE_PARCOURS, + type_parcours=parcours.TYPE_PARCOURS, ) _ue1 = G.create_ue( - formation_id=_f["formation_id"], acronyme="UE1", titre="ue 1", semestre_idx=2 + formation_id=formation_id, acronyme="UE1", titre="ue 1", semestre_idx=2 ) _ue2 = G.create_ue( - formation_id=_f["formation_id"], acronyme="UE2", titre="ue 2", semestre_idx=2 + formation_id=formation_id, acronyme="UE2", titre="ue 2", semestre_idx=2 ) _ue3 = G.create_ue( - formation_id=_f["formation_id"], acronyme="UE3", titre="ue 3", semestre_idx=2 + formation_id=formation_id, acronyme="UE3", titre="ue 3", semestre_idx=2 ) + ue_ids = [_ue1, _ue2, _ue3] # une 4eme UE en dehors du semestre 2 _ = G.create_ue( - formation_id=_f["formation_id"], acronyme="UE41", titre="ue 41", semestre_idx=4 + formation_id=formation_id, acronyme="UE41", titre="ue 41", semestre_idx=4 ) - _mat = G.create_matiere(ue_id=_ue1["ue_id"], titre="matière test") + matiere_id = G.create_matiere(ue_id=_ue1, titre="matière test") module_ids = [] for i in range(nb_mods): - mod = G.create_module( - matiere_id=_mat["matiere_id"], + module_id = G.create_module( + matiere_id=matiere_id, code=f"TSM{i}", coefficient=1.0, titre=f"module test {i}", - ue_id=_ue1["ue_id"], - formation_id=_f["formation_id"], + ue_id=_ue1, + formation_id=formation_id, + semestre_id=2, + module_type=scu.ModuleType.RESSOURCE + if parcours.APC_SAE + else scu.ModuleType.STANDARD, + ) + module_ids.append(module_id) + if with_ue_sport: + ue_sport = G.create_ue( + formation_id=formation_id, + acronyme="UESPO", + titre="ue sport", + semestre_idx=2, + type=sco_codes_parcours.UE_SPORT, + ) + ue_ids.append(ue_sport) + mat_sport = G.create_matiere(ue_id=ue_sport, titre="matière spo") + mod_sport = G.create_module( + matiere_id=mat_sport, + code="BAD", + coefficient=1.0, + titre="module sport", + ue_id=ue_sport, + formation_id=formation_id, semestre_id=2, ) - module_ids.append(mod["id"]) - return G, _f["id"], _ue1["id"], _ue2["id"], _ue3["id"], module_ids + module_ids.append(mod_sport) + return G, formation_id, ue_ids, module_ids def build_modules_with_evaluations( @@ -55,7 +81,7 @@ def build_modules_with_evaluations( - 1 semestre, nb_mod moduleimpl, 1 eval/moduleimpl """ nb_ues = len(ue_coefs) # 3 UEs par défaut dans ce test - G, formation_id, ue1_id, ue2_id, ue3_id, module_ids = build_formation_test( + G, formation_id, (ue1_id, ue2_id, ue3_id), module_ids = build_formation_test( nb_mods=nb_mods ) ue1 = models.UniteEns.query.get(ue1_id) @@ -69,7 +95,7 @@ def build_modules_with_evaluations( mod.set_ue_coef_dict(coefs_mod) assert mod.get_ue_coef_dict() == coefs_mod # Mise en place: - sem = G.create_formsemestre( + formsemestre_id = G.create_formsemestre( formation_id=formation_id, semestre_id=2, date_debut="01/01/2021", @@ -77,11 +103,10 @@ def build_modules_with_evaluations( ) evaluation_ids = [] for module_id in module_ids: - mi = G.create_moduleimpl( + moduleimpl_id = G.create_moduleimpl( module_id=module_id, - formsemestre_id=sem["formsemestre_id"], + formsemestre_id=formsemestre_id, ) - moduleimpl_id = mi["id"] modimpl = models.ModuleImpl.query.get(moduleimpl_id) assert modimpl.formsemestre.formation.get_parcours().APC_SAE # BUT # Check ModuleImpl @@ -96,4 +121,4 @@ def build_modules_with_evaluations( coefficient=0, ) evaluation_ids.append(e["evaluation_id"]) - return G, formation_id, sem, evaluation_ids, ue1, ue2, ue3 + return G, formation_id, formsemestre_id, evaluation_ids, ue1, ue2, ue3 diff --git a/tests/unit/test_abs_counts.py b/tests/unit/test_abs_counts.py index 4111038a5..3b8f94b77 100644 --- a/tests/unit/test_abs_counts.py +++ b/tests/unit/test_abs_counts.py @@ -10,7 +10,7 @@ import json from tests.unit import sco_fake_gen -from app.scodoc import sco_abs +from app.scodoc import sco_abs, sco_formsemestre from app.scodoc import sco_abs_views from app.scodoc import sco_groups from app.views import absences @@ -24,33 +24,33 @@ def test_abs_counts(test_client): etud = G.create_etud(code_nip=None) # --- Création d'une formation - f = G.create_formation(acronyme="") - ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") - mat = G.create_matiere(ue_id=ue["ue_id"], titre="matière test") - mod = G.create_module( - matiere_id=mat["matiere_id"], + formation_id = G.create_formation(acronyme="") + ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test") + matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test") + module_id = G.create_module( + matiere_id=matiere_id, code="TSM1", coefficient=1.0, titre="module test", - ue_id=ue["ue_id"], # faiblesse de l'API - formation_id=f["formation_id"], # faiblesse de l'API + ue_id=ue_id, + formation_id=formation_id, ) # --- Mise place d'un semestre - sem = G.create_formsemestre( - formation_id=f["formation_id"], + formsemestre_id = G.create_formsemestre( + formation_id=formation_id, semestre_id=1, date_debut="01/01/2021", date_fin="30/06/2021", ) - - mi = G.create_moduleimpl( - module_id=mod["module_id"], - formsemestre_id=sem["formsemestre_id"], + sem = sco_formsemestre.get_formsemestre(formsemestre_id) + _ = G.create_moduleimpl( + module_id=module_id, + formsemestre_id=formsemestre_id, ) # --- Inscription des étudiants - G.inscrit_etudiant(sem, etud) + G.inscrit_etudiant(formsemestre_id, etud) # --- Saisie absences etudid = etud["etudid"] @@ -120,4 +120,4 @@ def test_abs_counts(test_client): assert nbabs_3 == new_nbabs justifs_3 = sco_abs.list_abs_justifs(etudid, "2021-01-01", datefin="2021-06-30") assert len(justifs_3) == len(justifs_2) - # XXX à continuer \ No newline at end of file + # XXX à continuer diff --git a/tests/unit/test_abs_demijournee.py b/tests/unit/test_abs_demijournee.py index 46a81bba3..ab950cd59 100644 --- a/tests/unit/test_abs_demijournee.py +++ b/tests/unit/test_abs_demijournee.py @@ -9,10 +9,11 @@ Créer et justifier des absences en utilisant le parametre demijournee import json from tests.unit import sco_fake_gen - +from app.models import Module from app.scodoc import sco_abs from app.scodoc import sco_abs_views from app.scodoc import sco_groups +from app.scodoc import sco_formsemestre from app.views import absences @@ -26,33 +27,34 @@ def test_abs_demijournee(test_client): etud = G.create_etud(code_nip=None) # --- Création d'une formation - f = G.create_formation(acronyme="") - ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") - mat = G.create_matiere(ue_id=ue["ue_id"], titre="matière test") - mod = G.create_module( - matiere_id=mat["matiere_id"], + formation_id = G.create_formation(acronyme="") + ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test") + matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test") + module_id = G.create_module( + matiere_id=matiere_id, code="TSM1", coefficient=1.0, titre="module test", - ue_id=ue["ue_id"], # faiblesse de l'API - formation_id=f["formation_id"], # faiblesse de l'API + ue_id=ue_id, + formation_id=formation_id, ) # --- Mise place d'un semestre - sem = G.create_formsemestre( - formation_id=f["formation_id"], + formsemestre_id = G.create_formsemestre( + formation_id=formation_id, semestre_id=1, date_debut="01/01/2021", date_fin="30/06/2021", ) + sem = sco_formsemestre.get_formsemestre(formsemestre_id) - mi = G.create_moduleimpl( - module_id=mod["module_id"], - formsemestre_id=sem["formsemestre_id"], + _ = G.create_moduleimpl( + module_id=module_id, + formsemestre_id=formsemestre_id, ) # --- Inscription des étudiants - G.inscrit_etudiant(sem, etud) + G.inscrit_etudiant(formsemestre_id, etud) # --- Saisie absences etudid = etud["etudid"] @@ -131,38 +133,38 @@ def test_abs_basic(test_client): etuds = [G.create_etud(code_nip=None) for _ in range(10)] # --- Création d'une formation - f = G.create_formation(acronyme="") - ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") - mat = G.create_matiere(ue_id=ue["ue_id"], titre="matière test") - mod = G.create_module( - matiere_id=mat["matiere_id"], + formation_id = G.create_formation(acronyme="") + ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test") + matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test") + module_id = G.create_module( + matiere_id=matiere_id, code="TSM1", coefficient=1.0, titre="module test", - ue_id=ue["ue_id"], # faiblesse de l'API - formation_id=f["formation_id"], # faiblesse de l'API + ue_id=ue_id, # faiblesse de l'API + formation_id=formation_id, # faiblesse de l'API ) # --- Mise place d'un semestre - sem = G.create_formsemestre( - formation_id=f["formation_id"], + formsemestre_id = G.create_formsemestre( + formation_id=formation_id, semestre_id=1, date_debut="01/01/2021", date_fin="30/06/2021", ) - mi = G.create_moduleimpl( - module_id=mod["module_id"], - formsemestre_id=sem["formsemestre_id"], + moduleimpl_id = G.create_moduleimpl( + module_id=module_id, + formsemestre_id=formsemestre_id, ) # --- Inscription des étudiants for etud in etuds: - G.inscrit_etudiant(sem, etud) + G.inscrit_etudiant(formsemestre_id, etud) # --- Création d'une évaluation e = G.create_evaluation( - moduleimpl_id=mi["moduleimpl_id"], + moduleimpl_id=moduleimpl_id, jour="22/01/2021", description="evaluation test", coefficient=1.0, @@ -226,6 +228,7 @@ def test_abs_basic(test_client): b = sco_abs.is_work_saturday() assert b == 0 # samedi ne sont pas compris + sem = sco_formsemestre.get_formsemestre(formsemestre_id) nbabs, nbabsjust = sco_abs.get_abs_count(etudid, sem) # l'étudiant a été absent le 15 (apres midi) , (16 et 17 we), # 18 (matin) et 19 janvier (matin et apres midi), et 22 (matin) @@ -258,7 +261,8 @@ def test_abs_basic(test_client): assert len(load_liste_abs) == 2 assert load_liste_abs2[0]["ampm"] == 1 assert load_liste_abs2[0]["datedmy"] == "22/01/2021" - assert load_liste_abs2[0]["exams"] == mod["code"] + mod = Module.query.get(module_id) + assert load_liste_abs2[0]["exams"] == mod.code # absjust_only -> seulement les abs justifiés # --- Création d'un groupe diff --git a/tests/unit/test_but_modules.py b/tests/unit/test_but_modules.py index 07705c211..da393aec6 100644 --- a/tests/unit/test_but_modules.py +++ b/tests/unit/test_but_modules.py @@ -36,18 +36,17 @@ def same_note(x, y): def test_evaluation_poids(test_client): """Association de poids vers les UE""" - G, formation_id, ue1_id, ue2_id, ue3_id, module_ids = setup.build_formation_test() - sem = G.create_formsemestre( + G, formation_id, (ue1_id, ue2_id, ue3_id), module_ids = setup.build_formation_test() + formsemestre_id = G.create_formsemestre( formation_id=formation_id, semestre_id=1, date_debut="01/01/2021", date_fin="30/06/2021", ) # formsemestre_id=716 - mi = G.create_moduleimpl( + moduleimpl_id = G.create_moduleimpl( module_id=module_ids[0], - formsemestre_id=sem["formsemestre_id"], + formsemestre_id=formsemestre_id, ) - moduleimpl_id = mi["id"] _e1 = G.create_evaluation( moduleimpl_id=moduleimpl_id, jour="01/01/2021", @@ -91,7 +90,7 @@ def test_evaluation_poids(test_client): def test_modules_coefs(test_client): """Coefs vers les UE (BUT)""" - G, formation_id, ue1_id, ue2_id, ue3_id, module_ids = setup.build_formation_test() + G, formation_id, (ue1_id, ue2_id, ue3_id), module_ids = setup.build_formation_test() ue1 = models.UniteEns.query.get(ue1_id) ue2 = models.UniteEns.query.get(ue2_id) mod = models.Module.query.get(module_ids[0]) @@ -211,14 +210,14 @@ def test_module_moy(test_client): ( G, formation_id, - sem, + formsemestre_id, evaluation1_ids, ue1, ue2, ue3, ) = setup.build_modules_with_evaluations() etud = G.create_etud(nom="test") - G.inscrit_etudiant(sem, etud) + G.inscrit_etudiant(formsemestre_id, etud) etudid = etud["etudid"] evaluation1 = models.Evaluation.query.get(evaluation1_ids[0]) # Crée une deuxième évaluation dans le même moduleimpl: diff --git a/tests/unit/test_but_ues.py b/tests/unit/test_but_ues.py index 8f9ec3ece..0898bec84 100644 --- a/tests/unit/test_but_ues.py +++ b/tests/unit/test_but_ues.py @@ -27,19 +27,18 @@ def test_ue_moy(test_client): ( G, formation_id, - sem, + formsemestre_id, evaluation_ids, ue1, ue2, ue3, ) = setup.build_modules_with_evaluations(ue_coefs=ue_coefs, nb_mods=nb_mods) assert len(evaluation_ids) == nb_mods - formsemestre_id = sem["formsemestre_id"] formsemestre = FormSemestre.query.get(formsemestre_id) evaluation1 = Evaluation.query.get(evaluation_ids[0]) evaluation2 = Evaluation.query.get(evaluation_ids[1]) etud = G.create_etud(nom="test") - G.inscrit_etudiant(sem, etud) + G.inscrit_etudiant(formsemestre_id, etud) etudid = etud["etudid"] # e1 est l'éval du module 1, et e2 l'éval du module 2 e1p1, e1p2, e1p3 = 1.0, 2.0, 3.0 # poids de l'éval 1 vers les UE 1, 2 et 3 diff --git a/tests/unit/test_formations.py b/tests/unit/test_formations.py index 786ccba24..a20ca3a76 100644 --- a/tests/unit/test_formations.py +++ b/tests/unit/test_formations.py @@ -46,9 +46,10 @@ import json import flask from flask import g import pytest +from app.models.moduleimpls import ModuleImpl from tests.unit import sco_fake_gen -from app.scodoc import sco_edit_formation +from app.scodoc import sco_edit_formation, sco_formsemestre from app.scodoc import sco_edit_matiere from app.scodoc import sco_edit_module from app.scodoc import sco_edit_ue @@ -65,111 +66,109 @@ def test_formations(test_client): # --- Création de formations - f = G.create_formation( + formation_id = G.create_formation( acronyme="F1", titre="Formation 1", titre_officiel="Titre officiel 1" ) - - ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") - mat = G.create_matiere(ue_id=ue["ue_id"], titre="matière test") - mod = G.create_module( - matiere_id=mat["matiere_id"], + f = sco_formations.formation_list(formation_id)[0] + ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test") + matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test") + module_id = G.create_module( + matiere_id=matiere_id, code="TSM1", coefficient=1.0, titre="module test", - ue_id=ue["ue_id"], # faiblesse de l'API - formation_id=f["formation_id"], # faiblesse de l'API + ue_id=ue_id, # faiblesse de l'API + formation_id=formation_id, # faiblesse de l'API ) - ue2 = G.create_ue(formation_id=f["formation_id"], acronyme="TST2", titre="ue test2") - mat2 = G.create_matiere(ue_id=ue2["ue_id"], titre="matière test2") - mod2 = G.create_module( - matiere_id=mat2["matiere_id"], + ue_id2 = G.create_ue(formation_id=formation_id, acronyme="TST2", titre="ue test2") + matiere_id2 = G.create_matiere(ue_id=ue_id2, titre="matière test2") + module_id2 = G.create_module( + matiere_id=matiere_id2, code="TSM2", coefficient=1.0, titre="module test", - ue_id=ue2["ue_id"], # faiblesse de l'API - formation_id=f["formation_id"], # faiblesse de l'API + ue_id=ue_id2, + formation_id=formation_id, ) - uet = G.create_ue(formation_id=f["formation_id"], acronyme="TSTt", titre="ue testt") - matt = G.create_matiere(ue_id=uet["ue_id"], titre="matière testt") - modt = G.create_module( - matiere_id=matt["matiere_id"], + uet_id = G.create_ue(formation_id=formation_id, acronyme="TSTt", titre="ue testt") + matiere_id3 = G.create_matiere(ue_id=uet_id, titre="matière testt") + module_id_t = G.create_module( + matiere_id=matiere_id3, code="TSMt", coefficient=1.0, titre="module test", - ue_id=uet["ue_id"], # faiblesse de l'API - formation_id=f["formation_id"], # faiblesse de l'API + ue_id=uet_id, + formation_id=formation_id, ) - f2 = G.create_formation(acronyme="", titre="Formation test") - - ue3 = G.create_ue( - formation_id=f2["formation_id"], acronyme="TST3", titre="ue test3" - ) - mat3 = G.create_matiere(ue_id=ue3["ue_id"], titre="matière test3") - mod3 = G.create_module( - matiere_id=mat3["matiere_id"], + formation_id2 = G.create_formation(acronyme="", titre="Formation test") + formation2 = sco_formations.formation_list(formation_id2)[0] + ue3 = G.create_ue(formation_id=formation_id2, acronyme="TST3", titre="ue test3") + matiere_id4 = G.create_matiere(ue_id=ue3, titre="matière test3") + module_id3 = G.create_module( + matiere_id=matiere_id4, code="TSM3", coefficient=1.0, titre="module test3", - ue_id=ue3["ue_id"], # faiblesse de l'API - formation_id=f2["formation_id"], # faiblesse de l'API + ue_id=ue3, + formation_id=formation_id2, ) # --- Création et implémentation des semestres - sem1 = G.create_formsemestre( - formation_id=f["formation_id"], + formsemestre_id1 = G.create_formsemestre( + formation_id=formation_id, semestre_id=1, date_debut="01/01/2021", date_fin="30/06/2021", ) - sem2 = G.create_formsemestre( - formation_id=f["formation_id"], + formsemestre_id2 = G.create_formsemestre( + formation_id=formation_id, semestre_id=2, date_debut="01/09/2020", date_fin="31/12/2020", ) - mi = G.create_moduleimpl( - module_id=mod["module_id"], - formsemestre_id=sem1["formsemestre_id"], + moduleimpl_id = G.create_moduleimpl( + module_id=module_id, + formsemestre_id=formsemestre_id1, ) - mi2 = G.create_moduleimpl( - module_id=mod2["module_id"], - formsemestre_id=sem1["formsemestre_id"], + _ = G.create_moduleimpl( + module_id=module_id2, + formsemestre_id=formsemestre_id1, ) - mit = G.create_moduleimpl( - module_id=modt["module_id"], - formsemestre_id=sem2["formsemestre_id"], + _ = G.create_moduleimpl( + module_id=module_id_t, + formsemestre_id=formsemestre_id2, ) - semt = G.create_formsemestre( - formation_id=f2["formation_id"], + formsemestre_idt = G.create_formsemestre( + formation_id=formation_id2, semestre_id=3, date_debut="01/01/2021", date_fin="30/06/2021", ) mi3 = G.create_moduleimpl( - module_id=mod3["module_id"], - formsemestre_id=semt["formsemestre_id"], + module_id=module_id3, + formsemestre_id=formsemestre_idt, ) # --- Afficher la liste des formations - lif = notes.formation_list(format="json", formation_id=f["formation_id"]) + lif = notes.formation_list(format="json", formation_id=formation_id) # lif est une Response car on a appelé une vue (1er appel) assert isinstance(lif, flask.Response) load_lif = json.loads(lif.get_data().decode("utf-8")) assert len(load_lif) == 1 assert load_lif[0]["acronyme"] == f["acronyme"] assert load_lif[0]["titre_officiel"] == f["titre_officiel"] - assert load_lif[0]["formation_id"] == f["formation_id"] + assert load_lif[0]["formation_id"] == formation_id assert load_lif[0]["titre"] == f["titre"] lif2 = notes.formation_list(format="json").get_data(as_text=True) @@ -178,12 +177,12 @@ def test_formations(test_client): load_lif2 = json.loads(lif2) assert len(load_lif2) == 2 assert load_lif2[0] == load_lif[0] - assert load_lif2[1]["titre"] == f2["titre"] + assert load_lif2[1]["titre"] == formation2["titre"] # --- Export de formation_id exp = sco_formations.formation_export( - formation_id=f["formation_id"], format="json" + formation_id=formation_id, format="json" ).get_data(as_text=True) assert isinstance(exp, str) load_exp = json.loads(exp) @@ -195,24 +194,25 @@ def test_formations(test_client): assert len(load_exp["ue"]) == 3 assert load_exp["ue"][0]["acronyme"] == "TST1" assert load_exp["ue"][0]["titre"] == "ue test" - assert load_exp["formation_id"] == f["formation_id"] + assert load_exp["formation_id"] == formation_id assert load_exp["formation_code"] == f["formation_code"] # --- Liste des semestres li_sem1 = notes.formsemestre_list( - formsemestre_id=sem1["formsemestre_id"], format="json" + formsemestre_id=formsemestre_id1, format="json" ).get_data(as_text=True) assert isinstance(li_sem1, str) load_li_sem1 = json.loads(li_sem1) # uniquement le semestre 1 dans la liste assert len(load_li_sem1) == 1 + sem1 = sco_formsemestre.get_formsemestre(formsemestre_id1) assert load_li_sem1[0]["date_fin"] == sem1["date_fin"] assert load_li_sem1[0]["semestre_id"] == sem1["semestre_id"] assert load_li_sem1[0]["formation_id"] == sem1["formation_id"] li_semf = notes.formsemestre_list( - formation_id=f["formation_id"], + formation_id=formation_id, format="json", ).get_data(as_text=True) assert isinstance(li_semf, str) @@ -220,6 +220,7 @@ def test_formations(test_client): assert load_li_sem1[0] in load_li_semf assert len(load_li_semf) == 2 + sem2 = sco_formsemestre.get_formsemestre(formsemestre_id2) assert load_li_semf[1]["semestre_id"] == sem2["semestre_id"] li_sem = notes.formsemestre_list(format="json").get_data(as_text=True) @@ -227,21 +228,26 @@ def test_formations(test_client): assert len(load_li_sem) == 3 assert load_li_semf[0] and load_li_semf[1] in load_li_sem - assert load_li_sem[0]["semestre_id"] == semt["semestre_id"] # --- Liste des modules lim_sem1 = sco_moduleimpl.moduleimpl_list(formsemestre_id=sem1["formsemestre_id"]) assert len(lim_sem1) == 2 - assert mod["module_id"] in (lim_sem1[0]["module_id"], lim_sem1[1]["module_id"]) - assert mod2["module_id"] in (lim_sem1[0]["module_id"], lim_sem1[1]["module_id"]) + assert module_id in ( + lim_sem1[0]["module_id"], + lim_sem1[1]["module_id"], + ) + assert module_id2 in ( + lim_sem1[0]["module_id"], + lim_sem1[1]["module_id"], + ) - lim_modid = sco_moduleimpl.moduleimpl_list(module_id=mod["module_id"]) + lim_modid = sco_moduleimpl.moduleimpl_list(module_id=module_id) assert len(lim_modid) == 1 - lim_modimpl_id = sco_moduleimpl.moduleimpl_list(moduleimpl_id=mi["moduleimpl_id"]) + lim_modimpl_id = sco_moduleimpl.moduleimpl_list(moduleimpl_id=moduleimpl_id) # print(lim_modimpl_id) # ---- Test de moduleimpl_withmodule_list @@ -253,20 +259,23 @@ def test_formations(test_client): ) assert len(liimp_sem1) == 2 - assert mod["module_id"] in (liimp_sem1[0]["module_id"], liimp_sem1[1]["module_id"]) - assert mod2["module_id"] in ( + assert module_id in ( + liimp_sem1[0]["module_id"], + liimp_sem1[1]["module_id"], + ) + assert module_id2 in ( liimp_sem1[0]["module_id"], liimp_sem1[1]["module_id"], ) liimp_sem2 = sco_moduleimpl.moduleimpl_withmodule_list( formsemestre_id=sem2["formsemestre_id"] ) - assert modt["module_id"] == liimp_sem2[0]["module_id"] - liimp_modid = sco_moduleimpl.moduleimpl_withmodule_list(module_id=mod["module_id"]) + assert module_id_t == liimp_sem2[0]["module_id"] + liimp_modid = sco_moduleimpl.moduleimpl_withmodule_list(module_id=module_id) assert len(liimp_modid) == 1 liimp_modimplid = sco_moduleimpl.moduleimpl_withmodule_list( - moduleimpl_id=mi["moduleimpl_id"] + moduleimpl_id=moduleimpl_id ) assert liimp_modid == liimp_modimplid @@ -281,16 +290,17 @@ def test_formations(test_client): li_module = sco_edit_module.module_list() assert len(li_module) == 4 - # Suppression impossible car utilisé dans le semestre semt: + # Suppression impossible car utilisé dans le semestre formsemestre_idt: + module3 = ModuleImpl.query.get(mi3).module with pytest.raises(sco_exceptions.ScoNonEmptyFormationObject): - sco_edit_module.module_delete(module_id=mi3["module_id"]) + sco_edit_module.module_delete(module_id=module3.id) - sco_formsemestre_edit.do_formsemestre_delete(semt["formsemestre_id"]) + sco_formsemestre_edit.do_formsemestre_delete(formsemestre_idt) li_module2_before = sco_edit_module.module_list() - sco_edit_module.do_module_delete(mi3["module_id"]) - sco_edit_module.do_module_delete(modt["module_id"]) + sco_edit_module.do_module_delete(module3.id) + sco_edit_module.do_module_delete(module_id_t) # deuxieme methode de supression d'un module li_module2_after = sco_edit_module.module_list() @@ -305,19 +315,19 @@ def test_formations(test_client): li_mat = sco_edit_matiere.matiere_list() assert len(li_mat) == 4 - sco_edit_matiere.do_matiere_delete(oid=matt["matiere_id"]) # on supprime la matiere + sco_edit_matiere.do_matiere_delete(oid=matiere_id3) # on supprime la matiere li_mat2 = sco_edit_matiere.matiere_list() assert len(li_mat2) == 3 # verification de la suppression de la matiere li_ue = sco_edit_ue.ue_list() assert len(li_ue) == 4 - sco_edit_ue.ue_delete(ue_id=uet["ue_id"], dialog_confirmed=True) + sco_edit_ue.ue_delete(ue_id=uet_id, dialog_confirmed=True) li_ue2 = sco_edit_ue.ue_list() assert len(li_ue2) == 3 # verification de la suppression de l'UE # --- Suppression d'une formation - sco_edit_formation.do_formation_delete(oid=f2["formation_id"]) + sco_edit_formation.do_formation_delete(oid=formation_id2) lif3 = notes.formation_list(format="json").get_data(as_text=True) assert isinstance(lif3, str) load_lif3 = json.loads(lif3) @@ -340,7 +350,7 @@ def test_import_formation(test_client): assert len(ues) == 10 assert all(not ue["is_external"] for ue in ues) # aucune UE externe dans le XML # --- Mise en place de 4 semestres - sems = [ + formsemestre_ids = [ G.create_formsemestre( formation_id=formation_id, semestre_id=x[0], @@ -357,10 +367,11 @@ def test_import_formation(test_client): # et les modules modules = sco_edit_module.module_list({"formation_id": formation_id}) for mod in modules: - mi = G.create_moduleimpl( + moduleimpl_id = G.create_moduleimpl( module_id=mod["module_id"], - formsemestre_id=sems[mod["semestre_id"] - 1]["formsemestre_id"], + formsemestre_id=formsemestre_ids[mod["semestre_id"] - 1], ) + mi = sco_moduleimpl.moduleimpl_list(moduleimpl_id=moduleimpl_id)[0] assert mi["ens"] == [] assert mi["module_id"] == mod["module_id"] diff --git a/tests/unit/test_notes_modules.py b/tests/unit/test_notes_modules.py index 934b4d90b..2e8c7fcd2 100644 --- a/tests/unit/test_notes_modules.py +++ b/tests/unit/test_notes_modules.py @@ -10,7 +10,7 @@ from tests.unit import sco_fake_gen from flask import g import app -from app.scodoc import sco_bulletins +from app.scodoc import sco_bulletins, sco_formsemestre from app.scodoc import sco_cache from app.scodoc import sco_formsemestre_inscriptions from app.scodoc import sco_moduleimpl @@ -57,36 +57,34 @@ def test_notes_modules(test_client): G = sco_fake_gen.ScoFake(verbose=False) etuds = [G.create_etud(code_nip=None) for i in range(2)] # 2 étudiants - f = G.create_formation(acronyme="") - ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") - ue_id = ue["ue_id"] - mat = G.create_matiere(ue_id=ue_id, titre="matière test") + formation_id = G.create_formation(acronyme="") + ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test") + matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test") coef_mod_1 = 1.5 - mod = G.create_module( - matiere_id=mat["matiere_id"], + module_id = G.create_module( + matiere_id=matiere_id, code="TSM1", coefficient=coef_mod_1, titre="module test", - ue_id=ue["ue_id"], - formation_id=f["formation_id"], + ue_id=ue_id, + formation_id=formation_id, ) # --- Mise place d'un semestre - sem = G.create_formsemestre( - formation_id=f["formation_id"], + formsemestre_id = G.create_formsemestre( + formation_id=formation_id, semestre_id=1, date_debut="01/01/2020", date_fin="30/06/2020", ) - formsemestre_id = sem["formsemestre_id"] - mi = G.create_moduleimpl( - module_id=mod["module_id"], + sem = sco_formsemestre.get_formsemestre(formsemestre_id) + moduleimpl_id = G.create_moduleimpl( + module_id=module_id, formsemestre_id=formsemestre_id, ) - moduleimpl_id = mi["moduleimpl_id"] # --- Inscription des étudiants for etud in etuds: - G.inscrit_etudiant(sem, etud) + G.inscrit_etudiant(formsemestre_id, etud) etud = etuds[0] etudid = etud["etudid"] # --- Creation évaluations: e1, e2 @@ -198,8 +196,8 @@ def test_notes_modules(test_client): check_nt( etudid, sem["formsemestre_id"], - ue["ue_id"], - mi["moduleimpl_id"], + ue_id, + moduleimpl_id, expected_mod_moy="NA", expected_moy_ue=0.0, expected_sum_coefs_ue=0.0, @@ -214,8 +212,8 @@ def test_notes_modules(test_client): check_nt( etudid, sem["formsemestre_id"], - ue["ue_id"], - mi["moduleimpl_id"], + ue_id, + moduleimpl_id, expected_mod_moy="NA", expected_moy_ue=0.0, expected_sum_coefs_ue=0.0, @@ -223,12 +221,12 @@ def test_notes_modules(test_client): # Non inscrit # - désinscrit notre étudiant: inscr = sco_moduleimpl.do_moduleimpl_inscription_list( - moduleimpl_id=mi["moduleimpl_id"], etudid=etud["etudid"] + moduleimpl_id=moduleimpl_id, etudid=etud["etudid"] ) assert len(inscr) == 1 oid = inscr[0]["moduleimpl_inscription_id"] sco_moduleimpl.do_moduleimpl_inscription_delete( - oid, formsemestre_id=mi["formsemestre_id"] + oid, formsemestre_id=sem["formsemestre_id"] ) # - b = sco_bulletins.formsemestre_bulletinetud_dict( @@ -246,21 +244,21 @@ def test_notes_modules(test_client): ) # --- Maintenant avec 2 modules dans l'UE coef_mod_2 = 2.1 - mod2 = G.create_module( - matiere_id=mat["matiere_id"], + module_id2 = G.create_module( + matiere_id=matiere_id, code="TSM2", coefficient=coef_mod_2, titre="module test 2", ue_id=ue_id, - formation_id=f["formation_id"], + formation_id=formation_id, ) - mi2 = G.create_moduleimpl( - module_id=mod2["module_id"], + moduleimpl_id2 = G.create_moduleimpl( + module_id=module_id2, formsemestre_id=formsemestre_id, ) # Re-inscription au premier module de l'UE sco_moduleimpl.do_moduleimpl_inscription_create( - {"etudid": etudid, "moduleimpl_id": mi["moduleimpl_id"]}, + {"etudid": etudid, "moduleimpl_id": moduleimpl_id}, formsemestre_id=formsemestre_id, ) _, _, _ = G.create_note(evaluation=e1, etud=etud, note=12.5) @@ -271,11 +269,11 @@ def test_notes_modules(test_client): assert not ue_status["was_capitalized"] # Inscription au deuxième module de l'UE sco_moduleimpl.do_moduleimpl_inscription_create( - {"etudid": etudid, "moduleimpl_id": mi2["moduleimpl_id"]}, + {"etudid": etudid, "moduleimpl_id": moduleimpl_id2}, formsemestre_id=formsemestre_id, ) sco_moduleimpl.do_moduleimpl_inscription_create( - {"etudid": etuds[1]["etudid"], "moduleimpl_id": mi2["moduleimpl_id"]}, + {"etudid": etuds[1]["etudid"], "moduleimpl_id": moduleimpl_id2}, formsemestre_id=formsemestre_id, ) nt = sco_cache.NotesTableCache.get(formsemestre_id) @@ -284,7 +282,7 @@ def test_notes_modules(test_client): assert ue_status["nb_notes"] == 1 # Note dans module 2: e_m2 = G.create_evaluation( - moduleimpl_id=mi2["moduleimpl_id"], + moduleimpl_id=moduleimpl_id2, jour="01/01/2020", description="evaluation mod 2", coefficient=1.0, @@ -327,37 +325,36 @@ def test_notes_modules_att_dem(test_client): G = sco_fake_gen.ScoFake(verbose=False) etuds = [G.create_etud(code_nip=None) for i in range(2)] # 2 étudiants - f = G.create_formation(acronyme="") - ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") - ue_id = ue["ue_id"] - mat = G.create_matiere(ue_id=ue_id, titre="matière test") + formation_id = G.create_formation(acronyme="") + ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test") + matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test") coef_mod_1 = 1.5 - mod = G.create_module( - matiere_id=mat["matiere_id"], + module_id = G.create_module( + matiere_id=matiere_id, code="TSM1", coefficient=coef_mod_1, titre="module test", - ue_id=ue["ue_id"], - formation_id=f["formation_id"], + ue_id=ue_id, + formation_id=formation_id, ) # # -------------------------------- # - sem = G.create_formsemestre( - formation_id=f["formation_id"], + formsemestre_id = G.create_formsemestre( + formation_id=formation_id, semestre_id=1, date_debut="01/01/2020", date_fin="30/06/2020", ) + sem = sco_formsemestre.get_formsemestre(formsemestre_id) formsemestre_id = sem["formsemestre_id"] - mi = G.create_moduleimpl( - module_id=mod["module_id"], + moduleimpl_id = G.create_moduleimpl( + module_id=module_id, formsemestre_id=formsemestre_id, ) - moduleimpl_id = mi["moduleimpl_id"] # --- Inscription des étudiants for etud in etuds: - G.inscrit_etudiant(sem, etud) + G.inscrit_etudiant(formsemestre_id, etud) # --- Creation évaluation: e1 coef_1 = 1.0 e1 = G.create_evaluation( diff --git a/tests/unit/test_notes_rattrapage.py b/tests/unit/test_notes_rattrapage.py index bc2d7bbdf..aaa9e740d 100644 --- a/tests/unit/test_notes_rattrapage.py +++ b/tests/unit/test_notes_rattrapage.py @@ -8,6 +8,7 @@ from flask import g import app from app.scodoc import sco_bulletins +from app.scodoc import sco_formsemestre from app.scodoc import sco_utils as scu DEPT = TestConfig.DEPT_TEST @@ -23,44 +24,44 @@ def test_notes_rattrapage(test_client): G = sco_fake_gen.ScoFake(verbose=False) etuds = [G.create_etud(code_nip=None)] # un seul - f = G.create_formation(acronyme="") - ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") - mat = G.create_matiere(ue_id=ue["ue_id"], titre="matière test") - mod = G.create_module( - matiere_id=mat["matiere_id"], + formation_id = G.create_formation(acronyme="") + ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test") + matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test") + module_id = G.create_module( + matiere_id=matiere_id, code="TSM1", coefficient=1.0, titre="module test", - ue_id=ue["ue_id"], - formation_id=f["formation_id"], + ue_id=ue_id, + formation_id=formation_id, ) # --- Mise place d'un semestre - sem = G.create_formsemestre( - formation_id=f["formation_id"], + formsemestre_id = G.create_formsemestre( + formation_id=formation_id, semestre_id=1, date_debut="01/01/2020", date_fin="30/06/2020", ) - - mi = G.create_moduleimpl( - module_id=mod["module_id"], - formsemestre_id=sem["formsemestre_id"], + sem = sco_formsemestre.get_formsemestre(formsemestre_id) + moduleimpl_id = G.create_moduleimpl( + module_id=module_id, + formsemestre_id=formsemestre_id, ) # --- Inscription des étudiants for etud in etuds: - G.inscrit_etudiant(sem, etud) + G.inscrit_etudiant(formsemestre_id, etud) # --- Creation évaluation e = G.create_evaluation( - moduleimpl_id=mi["moduleimpl_id"], + moduleimpl_id=moduleimpl_id, jour="01/01/2020", description="evaluation test", coefficient=1.0, ) # --- Création d'une évaluation "de rattrapage" e_rat = G.create_evaluation( - moduleimpl_id=mi["moduleimpl_id"], + moduleimpl_id=moduleimpl_id, jour="02/01/2020", description="evaluation rattrapage", coefficient=1.0, diff --git a/tests/unit/test_refcomp.py b/tests/unit/test_refcomp.py index 34678e9f7..f9e92a37d 100644 --- a/tests/unit/test_refcomp.py +++ b/tests/unit/test_refcomp.py @@ -19,7 +19,9 @@ from app.models.but_refcomp import ( def test_but_refcomp(test_client): """modèles ref. comp.""" - xml_data = open("tests/data/but-RT-refcomp-exemple.xml").read() + xml_data = open( + "ressources/referentiels/but2022/competences/but-RT-05012022-081735.xml" + ).read() dept_id = models.Departement.query.first().id ref = orebut_import_refcomp(xml_data, dept_id) assert ref.competences.count() == 13 diff --git a/tests/unit/test_sco_basic.py b/tests/unit/test_sco_basic.py index 4dc2c5a0a..575c41813 100644 --- a/tests/unit/test_sco_basic.py +++ b/tests/unit/test_sco_basic.py @@ -19,7 +19,7 @@ from config import TestConfig from tests.unit import sco_fake_gen import app -from app.scodoc import notesdb as ndb +from app.scodoc import notesdb as ndb, sco_formsemestre from app.scodoc import sco_abs from app.scodoc import sco_abs_views from app.scodoc import sco_bulletins @@ -54,38 +54,38 @@ def run_sco_basic(verbose=False): etuds = [G.create_etud(code_nip=None) for _ in range(10)] # --- Création d'une formation - f = G.create_formation(acronyme="") - ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") - mat = G.create_matiere(ue_id=ue["ue_id"], titre="matière test") - mod = G.create_module( - matiere_id=mat["matiere_id"], + formation_id = G.create_formation(acronyme="") + ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test") + matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test") + module_id = G.create_module( + matiere_id=matiere_id, code="TSM1", coefficient=1.0, titre="module test", - ue_id=ue["ue_id"], - formation_id=f["formation_id"], + ue_id=ue_id, + formation_id=formation_id, ) # --- Mise place d'un semestre - sem = G.create_formsemestre( - formation_id=f["formation_id"], + formsemestre_id = G.create_formsemestre( + formation_id=formation_id, semestre_id=1, date_debut="01/01/2020", date_fin="30/06/2020", ) - - mi = G.create_moduleimpl( - module_id=mod["module_id"], - formsemestre_id=sem["formsemestre_id"], + sem = sco_formsemestre.get_formsemestre(formsemestre_id) + moduleimpl_id = G.create_moduleimpl( + module_id=module_id, + formsemestre_id=formsemestre_id, ) # --- Inscription des étudiants for etud in etuds: - G.inscrit_etudiant(sem, etud) + G.inscrit_etudiant(formsemestre_id, etud) # --- Creation évaluation e = G.create_evaluation( - moduleimpl_id=mi["moduleimpl_id"], + moduleimpl_id=moduleimpl_id, jour="01/01/2020", description="evaluation test", coefficient=1.0, @@ -98,9 +98,7 @@ def run_sco_basic(verbose=False): ) # --- Vérifie que les notes sont prises en compte: - b = sco_bulletins.formsemestre_bulletinetud_dict( - sem["formsemestre_id"], etud["etudid"] - ) + b = sco_bulletins.formsemestre_bulletinetud_dict(formsemestre_id, etud["etudid"]) # Toute les notes sont saisies, donc eval complète etat = sco_evaluations.do_evaluation_etat(e["evaluation_id"]) assert etat["evalcomplete"] @@ -116,7 +114,7 @@ def run_sco_basic(verbose=False): # --- Une autre évaluation e2 = G.create_evaluation( - moduleimpl_id=mi["moduleimpl_id"], + moduleimpl_id=moduleimpl_id, jour="02/01/2020", description="evaluation test 2", coefficient=1.0, @@ -183,34 +181,34 @@ def run_sco_basic(verbose=False): # --- Permission saisie notes et décisions de jury, avec ou sans démission ou défaillance # on n'a pas encore saisi de décisions - assert not sco_parcours_dut.formsemestre_has_decisions(sem["formsemestre_id"]) + assert not sco_parcours_dut.formsemestre_has_decisions(formsemestre_id) # Saisie d'un décision AJ, non assidu etudid = etuds[-1]["etudid"] sco_parcours_dut.formsemestre_validate_ues( - sem["formsemestre_id"], etudid, sco_codes_parcours.AJ, False + formsemestre_id, etudid, sco_codes_parcours.AJ, False ) assert sco_parcours_dut.formsemestre_has_decisions( - sem["formsemestre_id"] + formsemestre_id ), "décisions manquantes" # Suppression de la décision sco_formsemestre_validation.formsemestre_validation_suppress_etud( - sem["formsemestre_id"], etudid + formsemestre_id, etudid ) assert not sco_parcours_dut.formsemestre_has_decisions( - sem["formsemestre_id"] + formsemestre_id ), "décisions non effacées" # --- Décision de jury et validations des ECTS d'UE for etud in etuds[:5]: # les etudiants notés sco_formsemestre_validation.formsemestre_validation_etud_manu( - sem["formsemestre_id"], + formsemestre_id, etud["etudid"], code_etat=sco_codes_parcours.ADJ, assidu=True, redirect=False, ) # Vérifie que toutes les UE des étudiants notés ont été acquises: - nt = sco_cache.NotesTableCache.get(sem["formsemestre_id"]) + nt = sco_cache.NotesTableCache.get(formsemestre_id) for etud in etuds[:5]: dec_ues = nt.get_etud_decision_ues(etud["etudid"]) for ue_id in dec_ues: