jmplace/DocScoDoc
1
0
Fork 0
forked from ScoDoc/DocScoDoc
Code Issues Pull Requests Projects Releases Wiki Activity

début de modernisation des tests

Browse Source
This commit is contained in:
Emmanuel Viennet 2022-01-15 21:36:06 +01:00
parent 3639d5db94
commit a7324ac634
14 changed files with 318 additions and 824 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app/scodoc/sco_saisie_notes.py
View File

@ -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(

2
migrations/versions/f40fbaf5831c_index_ine_et_nip.py
View File

@ -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

544
tests/data/but-RT-refcomp-exemple.xml
View File

@ -1,544 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<referentiel_competence specialite="RT" specialite_long="Réseaux et télécommunications" type="B.U.T.">
<competences>
<competence name="Administrer" numero="1" libelle_long="Administrer les réseaux et l’Internet" couleur="c1">
<situations>
<situation>Conception et administration de l’infrastructure du réseau informatique d’une entreprise</situation>
<situation>Installation et administration des services réseau informatique d’une entreprise</situation>
<situation>Déploiement et administration des solutions fixes pour les clients d’un opérateur de télécommunication </situation>
</situations>
<composantes_essentielles>
<composante>en choisissant les solutions et technologies réseaux adaptées</composante>
<composante>en respectant les principes fondamentaux de la sécurité informatique</composante>
<composante>en utilisant une approche rigoureuse pour la résolution des dysfonctionnements </composante>
<composante>en respectant les règles métiers</composante>
<composante>en assurant une veille technologique </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="Assister l’administrateur du réseau" annee="BUT1">
<acs>
<ac code="AC11.01">Maîtriser les lois fondamentales de l’électricité afin d’intervenir sur des équipements de réseaux et télécommunications</ac>
<ac code="AC11.02">Comprendre l'architecture et les fondements des systèmes numériques, les principes du codage de l'information, des communications et de l'Internet</ac>
<ac code="AC11.03">Configurer les fonctions de base du réseau local</ac>
<ac code="AC11.04">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 </ac>
<ac code="AC11.05">Identifier les dysfonctionnements du réseau local et savoir les signaler</ac>
<ac code="AC11.06">Installer un poste client, expliquer la procédure mise en place</ac>
</acs>
</niveau>
<niveau ordre="2" libelle="Administrer un réseau " annee="BUT2">
<acs>
<ac code="AC21.01">Configurer et dépanner le routage dynamique dans un réseau</ac>
<ac code="AC21.02">Configurer et expliquer une politique simple de QoS et les fonctions de base de la sécurité d’un réseau</ac>
<ac code="AC21.03">Déployer des postes clients et des solutions virtualisées adaptées à une situation donnée</ac>
<ac code="AC21.04">Déployer des services réseaux avancés</ac>
<ac code="AC21.05">Identifier les réseaux opérateurs et l’architecture d’Internet</ac>
<ac code="AC21.06">Travailler en équipe pour développer ses compétences professionnelles</ac>
</acs>
</niveau>
<niveau ordre="3" libelle="Concevoir un réseau" annee="BUT3">
<acs>
<ac code="AC31.01">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</ac>
<ac code="AC31.02">Réaliser la documentation technique de ce projet</ac>
<ac code="AC31.03">Réaliser une maquette de démonstration du projet</ac>
<ac code="AC31.04">Défendre/argumenter un projet </ac>
<ac code="AC31.05">Communiquer avec les acteurs du projet</ac>
<ac code="AC31.06">Gérer le projet et les différentes étapes de sa mise en œuvre en respectant les délais </ac>
</acs>
</niveau>
</niveaux>
</competence>
<competence name="Connecter" numero="2" libelle_long="Connecter les entreprises et les usagers " couleur="c2">
<situations>
<situation>Déploiement des supports et systèmes de transmission</situation>
<situation>Mise en service et administration des équipements d’accès fixe ou mobile d’un opérateur de télécommunications </situation>
<situation>Déploiement et administration des accès sans fil pour l'entreprise</situation>
<situation>Déploiement des systèmes de communications </situation>
</situations>
<composantes_essentielles>
<composante>en communiquant avec le client et les différents acteurs impliqués, parfois en anglais </composante>
<composante>en faisant preuve d’une démarche scientifique</composante>
<composante>en choisissant les solutions et technologies adaptées</composante>
<composante>en proposant des solutions respectueuses de l'environnement </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="Découvrir les transmissions et la ToIP" annee="BUT1">
<acs>
<ac code="AC12.01">Mesurer, analyser et commenter les signaux</ac>
<ac code="AC12.02">Caractériser des systèmes de transmissions élémentaires et découvrir la modélisation mathématique de leur fonctionnement </ac>
<ac code="AC12.03">Déployer des supports de transmission</ac>
<ac code="AC12.04">Connecter les systèmes de ToIP</ac>
<ac code="AC12.05">Communiquer avec un tiers (client, collaborateur...) et adapter son discours et sa langue à son interlocuteur</ac>
</acs>
</niveau>
<niveau ordre="2" libelle="Maîtriser les différentes composantes des solutions de connexion des entreprises et des usagers" annee="BUT2">
<acs>
<ac code="AC22.01">Déployer et caractériser des systèmes de transmissions complexes </ac>
<ac code="AC22.02">Mettre en place un accès distant sécurisé</ac>
<ac code="AC22.03">Mettre en place une connexion multi-site via un réseau opérateur</ac>
<ac code="AC22.04">Déployer des réseaux d’accès des opérateurs</ac>
<ac code="AC22.05">Capacité à questionner un cahier des charges RT</ac>
</acs>
</niveau>
<niveau ordre="3" libelle="Déployer une solution de connexion ou de communication sur IP" annee="BUT3">
<acs>
<ac code="AC32.01">Déployer un système de communication pour l’entreprise</ac>
<ac code="AC32.02">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é</ac>
<ac code="AC32.03">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é </ac>
<ac code="AC32.04">Permettre aux collaborateurs de se connecter de manière sécurisée au système d’information de l’entreprise </ac>
<ac code="AC32.05">Collaborer en mode projet en français et en anglais </ac>
</acs>
</niveau>
</niveaux>
</competence>
<competence name="Programmer" numero="3" libelle_long="Créer des outils et applications informatiques pour les R&amp;T " couleur="c3">
<situations>
<situation>Conception, déploiement et maintenance du système d’information d’une entreprise </situation>
<situation>Automatisation du déploiement et de la maintenance des outils logiciels </situation>
<situation>Développement d’outils informatiques à usage interne d'une équipe </situation>
</situations>
<composantes_essentielles>
<composante>en étant à l’écoute des besoins du client</composante>
<composante>en documentant le travail réalisé</composante>
<composante>en utilisant les outils numériques à bon escient</composante>
<composante>en choisissant les outils de développement adaptés </composante>
<composante>en intégrant les problématiques de sécurité </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="S’intégrer dans un service informatique" annee="BUT1">
<acs>
<ac code="AC13.01">Utiliser un système informatique et ses outils</ac>
<ac code="AC13.02">Lire, exécuter, corriger et modifier un programme</ac>
<ac code="AC13.03">Traduire un algorithme, dans un langage et pour un environnement donné</ac>
<ac code="AC13.04">Connaître l’architecture et les technologies d’un site Web</ac>
<ac code="AC13.05">Choisir les mécanismes de gestion de données adaptés au développement de l’outil et argumenter ses choix</ac>
<ac code="AC13.06">S’intégrer dans un environnement propice au développement et au travail collaboratif </ac>
</acs>
</niveau>
<niveau ordre="2" libelle="Développer une application R&amp;T " annee="BUT2">
<acs>
<ac code="AC23.01">Automatiser l’administration système avec des scripts</ac>
<ac code="AC23.02">Développer une application à partir d’un cahier des charges donné, pour le Web ou les périphériques mobiles </ac>
<ac code="AC23.03">Utiliser un protocole réseau pour programmer une application client/serveur</ac>
<ac code="AC23.04">Installer, administrer un système de gestion de données</ac>
<ac code="AC23.05">Accéder à un ensemble de données depuis une application et/ou un site web </ac>
</acs>
</niveau>
<niveau ordre="3" libelle="Piloter un projet de développement d’une application R&amp;T" annee="BUT3">
<acs>
<ac code="AC33.01">Élaborer les spécifications techniques et le cahier des charges d’une application informatique </ac>
<ac code="AC33.02">Mettre en place un environnement de travail collaboratif</ac>
<ac code="AC33.03">Participer à la formation des utilisateurs</ac>
<ac code="AC33.04">Déployer et maintenir une solution informatique </ac>
<ac code="AC33.05">S’informer sur les évolutions et les nouveautés technologiques </ac>
<ac code="AC33.06">Sécuriser l'environnement numérique d'une application </ac>
</acs>
</niveau>
</niveaux>
</competence>
<competence name="Sécuriser" numero="4" libelle_long="Administrer un système d’information sécurisé" couleur="c4">
<situations>
<situation>Analyse de l’existant et étude des besoins de sécurité d’une petite structure </situation>
<situation>Évolution et mise en conformité du système d’information d’une entreprise </situation>
</situations>
<composantes_essentielles>
<composante>en visant un juste compromis entre exigences de sécurité et contraintes d’utilisation </composante>
<composante>en respectant les normes et le cadre juridique</composante>
<composante>en intégrant les dernières technologies</composante>
<composante>en travaillant en équipe</composante>
<composante>en sensibilisant efficacement des utilisateurs </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="Sensibiliser aux vulnérabilités d'un système d'information et aux remédiations possibles " annee="BUT2">
<acs>
<ac code="AC24.01Cyber">Connaître et utiliser les bonnes pratiques et les recommandations de cybersécurité</ac>
<ac code="AC24.02Cyber">Mettre en œuvre les outils fondamentaux de sécurisation d’une infrastructure du réseau </ac>
<ac code="AC24.03Cyber">Sécuriser les services</ac>
<ac code="AC24.04Cyber">Choisir les outils cryptographiques adaptés au besoin fonctionnel du système d’information </ac>
<ac code="AC24.05Cyber">Connaître les différents types d’attaque</ac>
<ac code="AC24.06Cyber">Comprendre des documents techniques en anglais </ac>
</acs>
</niveau>
<niveau ordre="2" libelle="Mettre en œuvre un système d’information sécurisé pour une petite structure " annee="BUT3">
<acs>
<ac code="AC34.01Cyber">Participer activement à une analyse de risque pour définir une politique de sécurité pour une petite structure </ac>
<ac code="AC34.02Cyber">Mettre en œuvre des outils avancés de sécurisation d’une infrastructure du réseau</ac>
<ac code="AC34.03Cyber">Sécuriser les systèmes d’exploitation</ac>
<ac code="AC34.04Cyber">Proposer une architecture sécurisée de système d'information pour une petite structure </ac>
</acs>
</niveau>
</niveaux>
</competence>
<competence name="Orchestrer" numero="5" libelle_long="Coordonner des infrastructures modulaires" couleur="c4">
<situations>
<situation>Industrialisation du déploiement des infrastructures systèmes, réseaux et sécurité en sauvegardant et en restaurant ses configurations</situation>
<situation>Maintenance des outils pour l’intégration et la mise en production du code logiciel</situation>
<situation>Administration d’un cluster de containers </situation>
<situation>Analyse des performances d’un système pour améliorer les processus de production </situation>
</situations>
<composantes_essentielles>
<composante>en respectant un cahier des charges</composante>
<composante>en documentant le travail réalisé</composante>
<composante>en intégrant les problématiques de sécurité</composante>
<composante>en assurant une veille technologique</composante>
<composante>en respectant les pratiques d’équipes et des méthodes de production </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="Assister l’administrateur infrastructure et Cloud " annee="BUT2">
<acs>
<ac code="AC24.01DevCloud">Proposer une solution Cloud adaptée à l’entreprise </ac>
<ac code="AC24.02DevCloud">Virtualiser un environnement</ac>
<ac code="AC24.03DevCloud">Utiliser les services du Cloud</ac>
<ac code="AC24.04DevCloud">Analyser un service Cloud au travers des métriques </ac>
</acs>
</niveau>
<niveau ordre="2" libelle="Administrer une infrastructure Cloud" annee="BUT3">
<acs>
<ac code="AC34.01DevCloud">Concevoir, administrer et superviser une infrastructure Cloud</ac>
<ac code="AC34.02DevCloud">Orchestrer les ressources Cloud</ac>
<ac code="AC34.03DevCloud">Investiguer sur les incidents et les résoudre afin d’améliorer la qualité et la fiabilité des infrastructures </ac>
</acs>
</niveau>
</niveaux>
</competence>
<competence name="Etendre" numero="6" libelle_long="Gérer les infrastructures des réseaux mobiles " couleur="c4">
<situations>
<situation>Gestion des infrastructures d’un opérateur de réseaux mobiles et d’Internet des Objets</situation>
<situation>Gestion des infrastructures de réseaux mobiles dans le contexte industriel, personnel ou médical </situation>
</situations>
<composantes_essentielles>
<composante>en respectant les normes et protocoles en vigueur </composante>
<composante>en intégrant les dernières technologies mobiles </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="Mettre en œuvre les réseaux pour la mobilité " annee="BUT2">
<acs>
<ac code="AC24.01IOM">Comprendre les architectures et spécificités des réseaux dédiés à l'IoT</ac>
<ac code="AC24.02IOM">Mettre en œuvre des systèmes de transmissions pour l’accès à un réseau IoT</ac>
</acs>
</niveau>
<niveau ordre="2" libelle="Raccorder des objets connectés aux réseaux mobiles " annee="BUT3">
<acs>
<ac code="AC34.01IOM">Comprendre les architectures, protocoles et services des réseaux mobiles 4G/5G</ac>
<ac code="AC34.02IOM">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</ac>
<ac code="AC34.03IOM">Mettre en œuvre des réseaux mobiles personnels ou industriels</ac>
</acs>
</niveau>
</niveaux>
</competence>
<competence name="Piloter" numero="7" libelle_long="Mettre en œuvre des projets techniques et réglementaires des R&amp;T dans son activité " couleur="c4">
<situations>
<situation>Adéquation technique des solutions réseaux informatiques et télécoms à la demande client </situation>
<situation>Élaboration de solutions techniques clients adaptées</situation>
<situation>Accompagnement technique de la mise en place des solutions clients </situation>
</situations>
<composantes_essentielles>
<composante>en maîtrisant les enjeux techniques et réglementaires des nouvelles technologies</composante>
<composante>en pilotant un projet technique R&amp;T</composante>
<composante>en faisant preuve de vision stratégique en phase avec le marché des réseaux et des télécommunications </composante>
<composante>en collaborant de façon responsable avec des équipes </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="Mettre en œuvre un projet R&amp;T " annee="BUT2">
<acs>
<ac code="AC24.01PPR">Compréhension d’un cahier des charges technique R&amp;T </ac>
<ac code="AC24.02PPR">Planification des étapes d’un projet technique R&amp;T</ac>
<ac code="AC24.03PPR">Co-animation d’une équipe technique</ac>
<ac code="AC24.04PPR">Proposition de solutions techniques R&amp;T efficientes</ac>
<ac code="AC24.05PPR">Échanges vulgarisés ou techniques avec tous les acteurs d’un projet </ac>
</acs>
</niveau>
<niveau ordre="2" libelle="Opérationnaliser un projet R&amp;T " annee="BUT3">
<acs>
<ac code="AC34.01PPR">Rédaction d'un appel d'offres ou d'un cahier des charges technique R&amp;T</ac>
<ac code="AC34.02PPR">Animation technique d’équipes pluridisciplinaires</ac>
<ac code="AC34.03PPR">Coordination d’équipes sur une partie de projet R&amp;T ou sa totalité</ac>
<ac code="AC34.04PPR">Mise en place de solutions techniques R&amp;T efficientes</ac>
<ac code="AC34.05PPR">Livraison et suivi technique de projet R&amp;T</ac>
</acs>
</niveau>
</niveaux>
</competence>
<competence name="Rapprocher" numero="8" libelle_long="Gérer les infrastructures et les services des réseaux opérateurs " couleur="c4">
<situations>
<situation>Gestion des services d’un ensemble de clients entreprises d’un opérateur </situation>
<situation>Gestion du déploiement de nouvelles infrastructures </situation>
</situations>
<composantes_essentielles>
<composante>en respectant les règles métiers et les délais</composante>
<composante>en assurant une communication optimale avec le client</composante>
<composante>en mettant en place des processus opérationnels de gestion d’incidents </composante>
<composante>en pilotant les acteurs terrain </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="Gérer les infrastructures des réseaux opérateurs " annee="BUT2">
<acs>
<ac code="AC24.01ROM">Administrer les réseaux d’accès fixes et mobiles</ac>
<ac code="AC24.02ROM">Virtualiser des services réseaux</ac>
<ac code="AC24.03ROM">Décrire/comprendre l’architecture et les offres des opérateurs </ac>
<ac code="AC24.04ROM">Gérer le routage/commutation et les interconnexions </ac>
<ac code="AC24.05ROM">Automatiser la gestion des équipements réseaux </ac>
</acs>
</niveau>
<niveau ordre="2" libelle="Administrer les services des opérateurs de télécommunications " annee="BUT3">
<acs>
<ac code="AC34.01ROM">Administrer/superviser les infrastructures et les services télécom</ac>
<ac code="AC34.02ROM">Administrer et déployer des fonctions réseaux virtualisées et programmer le réseau</ac>
</acs>
</niveau>
</niveaux>
</competence>
<competence name="Surveiller" numero="9" libelle_long="Surveiller un système d’information sécurisé" couleur="c5">
<situations>
<situation>Surveillance et analyse du système d’information </situation>
<situation>Audit de sécurité</situation>
<situation>Gestion d’un incident de sécurité </situation>
</situations>
<composantes_essentielles>
<composante>en assurant une veille permanente</composante>
<composante>en réalisant les mises à jour critiques</composante>
<composante>en automatisant des tâches</composante>
<composante>en s’intégrant dans une équipe</composante>
<composante>en surveillant le comportement du réseau</composante>
<composante>en veillant au respect des contrats et à la conformité des obligations du système d'information </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="Prendre en main les outils de surveillance et de test du système d'information " annee="BUT2">
<acs>
<ac code="AC25.01Cyber">Administrer les protections contre les logiciels malveillants </ac>
<ac code="AC25.02Cyber">Prendre en main des outils de test de pénétration réseau/système</ac>
</acs>
</niveau>
<niveau ordre="2" libelle="Mettre en œuvre le système de surveillance d’incidents de sécurité " annee="BUT3">
<acs>
<ac code="AC35.01Cyber">Surveiller l’activité du système d’information</ac>
<ac code="AC35.02Cyber">Appliquer une méthodologie de tests de pénétration</ac>
<ac code="AC35.03Cyber">Réagir face à un incident de sécurité</ac>
<ac code="AC35.04Cyber">Administrer les outils de surveillance du système d’information</ac>
</acs>
</niveau>
</niveaux>
</competence>
<competence name="Développer" numero="10" libelle_long="Accompagner le développement d’applications" couleur="c5">
<situations>
<situation>Déploiement d’une application</situation>
<situation>Intervention sur la chaîne de développement dans une optique DevOps </situation>
<situation>Surveillance de la qualité de la production</situation>
<situation>Mise en place des services réseaux nécessaires au développement </situation>
</situations>
<composantes_essentielles>
<composante>en respectant un cahier des charges</composante>
<composante>en documentant le travail réalisé</composante>
<composante>en respectant les bonnes pratiques de développement et de production </composante>
<composante>en visant l’amélioration continue </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="Développer pour le Cloud " annee="BUT2">
<acs>
<ac code="AC25.01DevCloud">Développer un microservice</ac>
<ac code="AC25.02DevCloud">Mettre en production une application</ac>
<ac code="AC25.03DevCloud">Programmer son réseau par le code</ac>
</acs>
</niveau>
<niveau ordre="2" libelle="S’intégrer dans une équipe DevOps " annee="BUT3">
<acs>
<ac code="AC35.01DevCloud">Adopter les pratiques de pilotage de projet</ac>
<ac code="AC35.02DevCloud">Concevoir, gérer et sécuriser un environnement de microservices </ac>
<ac code="AC35.03DevCloud">Gérer son infrastructure comme du code </ac>
<ac code="AC35.04DevCloud">Gérer une chaîne d’intégration et/ou de déploiement continu </ac>
</acs>
</niveau>
</niveaux>
</competence>
<competence name="Exploiter" numero="11" libelle_long="Mettre en œuvre des applications et des protocoles sécurisés pour l’Internet des Objets " couleur="c5">
<situations>
<situation>Déploiement d’un système IoT de la source capteur aux traitements des données </situation>
<situation>Gestion, administration et sécurisation d’un système IoT </situation>
</situations>
<composantes_essentielles>
<composante>en travaillant au sein d’une équipe pluridisciplinaire</composante>
<composante>en respectant les normes et contraintes opérationnelles </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="Mettre en œuvre des solutions pour l’Internet des Objets " annee="BUT2">
<acs>
<ac code="AC25.01IOM">Intégrer des systèmes électroniques et des systèmes d’exploitation embarqués </ac>
<ac code="AC25.02IOM">Mettre en œuvre des protocoles pour les réseaux de l’IoT</ac>
<ac code="AC25.03IOM">Mettre en œuvre des applications et traiter des données issues des objets connectés </ac>
</acs>
</niveau>
<niveau ordre="2" libelle="Créer des solutions sécurisées pour l’Internet des Objets " annee="BUT3">
<acs>
<ac code="AC35.01IOM">Superviser et analyser le déploiement des réseaux sans-fil </ac>
<ac code="AC35.02IOM">Sécuriser les objets connectés</ac>
<ac code="AC35.03IOM">Créer et innover pour l’IoT </ac>
</acs>
</niveau>
</niveaux>
</competence>
<competence name="Organiser" numero="12" libelle_long="Gérer des activités réseaux et télécommunications en termes organisationnels, relationnels, financiers et commerciaux" couleur="c5">
<situations>
<situation>Communication et stratégie technique en interne et en externe pour des projets R&amp;T </situation>
<situation>Suivi des objectifs opérationnels de projets R&amp;T</situation>
<situation>Pilotage de la relation client </situation>
</situations>
<composantes_essentielles>
<composante>en pilotant avec agilité des solutions techniques</composante>
<composante>en sachant communiquer à l’écrit et à l’oral avec tous les acteurs d’un projet</composante>
<composante>en respectant des contraintes technico-économiques (financières, éthiques, temporelles, contractuelles, qualité) </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="Élaborer un projet technique " annee="BUT2">
<acs>
<ac code="AC25.01PPR">Prise en compte des contraintes d’un pilotage de projet R&amp;T</ac>
<ac code="AC25.02PPR">Planification de solutions techniques R&amp;T efficientes</ac>
<ac code="AC25.03PPR">Prise de conscience des enjeux de la communication dans les relations interpersonnelles </ac>
<ac code="AC25.04PPR">Établissement d’un relationnel de qualité </ac>
</acs>
</niveau>
<niveau ordre="2" libelle="Mettre en place et suivre un projet technique " annee="BUT3">
<acs>
<ac code="AC35.01PPR">Rigueur dans le pilotage d’un projet R&amp;T dans sa globalité</ac>
<ac code="AC35.02PPR">Flexibilité dans la gestion des équipes et des tâches</ac>
<ac code="AC35.03PPR">Prise de responsabilité envers les équipes</ac>
<ac code="AC35.04PPR">Valorisation de solutions déployées, ou d’offres techniques, ou d’offres commerciales </ac>
<ac code="AC35.05PPR">Force de propositions de solutions R&amp;T innovantes responsables</ac>
</acs>
</niveau>
</niveaux>
</competence>
<competence name="Unifier" numero="13" libelle_long="Gérer les communications unifiées et la vidéo sur Internet " couleur="c5">
<situations>
<situation>Déploiement et administration des services de communication </situation>
<situation>Administration des services multimédia </situation>
</situations>
<composantes_essentielles>
<composante>en automatisant la gestion réseau des communications </composante>
<composante>en sécurisant les infrastructures</composante>
<composante>en gérant les interconnexions</composante>
<composante>en assurant une communication optimale avec le client </composante>
<composante>en respectant les règles métiers et les délais </composante>
</composantes_essentielles>
<niveaux>
<niveau ordre="1" libelle="Mettre en oeuvre le système de téléphonie de l’entreprise " annee="BUT2">
<acs>
<ac code="AC25.01ROM">Choisir une architecture et déployer des services de ToIP </ac>
<ac code="AC25.02ROM">Administrer un service de téléphonie pour l’entreprise </ac>
<ac code="AC25.03ROM">Mettre en place une politique de QoS pour les applications </ac>
</acs>
</niveau>
<niveau ordre="2" libelle="Administrer les communications unifiées et les services vidéo de l’entreprise" annee="BUT3">
<acs>
<ac code="AC35.01ROM">Administrer les services multimédias pour une entreprise</ac>
</acs>
</niveau>
</niveaux>
</competence>
</competences>
<parcours>
<parcour numero="1" libelle="Cybersécurité" code="Cyber">
<annee ordre="1">
<competence nom="Administrer" niveau="1"/>
<competence nom="Connecter" niveau="1"/>
<competence nom="Programmer" niveau="1"/>
</annee>
<annee ordre="2">
<competence nom="Administrer" niveau="2"/>
<competence nom="Connecter" niveau="2"/>
<competence nom="Programmer" niveau="2"/>
<competence nom="Sécuriser" niveau="1"/>
<competence nom="Surveiller" niveau="1"/>
</annee>
<annee ordre="3">
<competence nom="Administrer" niveau="3"/>
<competence nom="Connecter" niveau="3"/>
<competence nom="Programmer" niveau="3"/>
<competence nom="Sécuriser" niveau="2"/>
<competence nom="Surveiller" niveau="2"/>
</annee>
</parcour>
<parcour numero="2" libelle="Développement système et cloud" code="DevCloud">
<annee ordre="1">
<competence nom="Administrer" niveau="1"/>
<competence nom="Connecter" niveau="1"/>
<competence nom="Programmer" niveau="1"/>
</annee>
<annee ordre="2">
<competence nom="Administrer" niveau="2"/>
<competence nom="Connecter" niveau="2"/>
<competence nom="Programmer" niveau="2"/>
<competence nom="Orchestrer" niveau="1"/>
<competence nom="Développer" niveau="1"/>
</annee>
<annee ordre="3">
<competence nom="Administrer" niveau="3"/>
<competence nom="Connecter" niveau="3"/>
<competence nom="Programmer" niveau="3"/>
<competence nom="Orchestrer" niveau="2"/>
<competence nom="Développer" niveau="2"/>
</annee>
</parcour>
<parcour numero="3" libelle="Internet des objets et mobilité" code="IOM">
<annee ordre="1">
<competence nom="Administrer" niveau="1"/>
<competence nom="Connecter" niveau="1"/>
<competence nom="Programmer" niveau="1"/>
</annee>
<annee ordre="2">
<competence nom="Administrer" niveau="2"/>
<competence nom="Connecter" niveau="2"/>
<competence nom="Programmer" niveau="2"/>
<competence nom="Etendre" niveau="1"/>
<competence nom="Exploiter" niveau="1"/>
</annee>
<annee ordre="3">
<competence nom="Administrer" niveau="3"/>
<competence nom="Connecter" niveau="3"/>
<competence nom="Programmer" niveau="3"/>
<competence nom="Etendre" niveau="2"/>
<competence nom="Exploiter" niveau="2"/>
</annee>
</parcour>
<parcour numero="4" libelle="Pilotage de projets de réseaux" code="PPR">
<annee ordre="1">
<competence nom="Administrer" niveau="1"/>
<competence nom="Connecter" niveau="1"/>
<competence nom="Programmer" niveau="1"/>
</annee>
<annee ordre="2">
<competence nom="Administrer" niveau="2"/>
<competence nom="Connecter" niveau="2"/>
<competence nom="Programmer" niveau="2"/>
<competence nom="Piloter" niveau="1"/>
<competence nom="Organiser" niveau="1"/>
</annee>
<annee ordre="3">
<competence nom="Administrer" niveau="3"/>
<competence nom="Connecter" niveau="3"/>
<competence nom="Programmer" niveau="3"/>
<competence nom="Piloter" niveau="2"/>
<competence nom="Organiser" niveau="2"/>
</annee>
</parcour>
<parcour numero="5" libelle="Réseaux Opérateurs et Multimédia" code="ROM">
<annee ordre="1">
<competence nom="Administrer" niveau="1"/>
<competence nom="Connecter" niveau="1"/>
<competence nom="Programmer" niveau="1"/>
</annee>
<annee ordre="2">
<competence nom="Administrer" niveau="2"/>
<competence nom="Connecter" niveau="2"/>
<competence nom="Programmer" niveau="2"/>
<competence nom="Rapprocher" niveau="1"/>
<competence nom="Unifier" niveau="1"/>
</annee>
<annee ordre="3">
<competence nom="Administrer" niveau="3"/>
<competence nom="Connecter" niveau="3"/>
<competence nom="Programmer" niveau="3"/>
<competence nom="Rapprocher" niveau="2"/>
<competence nom="Unifier" niveau="2"/>
</annee>
</parcour>
</parcours>
</referentiel_competence>

74
tests/unit/sco_fake_gen.py
View File

@ -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,

65
tests/unit/setup.py
View File

@ -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

30
tests/unit/test_abs_counts.py
View File

@ -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"]

62
tests/unit/test_abs_demijournee.py
View File

@ -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

15
tests/unit/test_but_modules.py
View File

@ -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:

5
tests/unit/test_but_ues.py
View File

@ -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

163
tests/unit/test_formations.py
View File

@ -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"]

87
tests/unit/test_notes_modules.py
View File

@ -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(

33
tests/unit/test_notes_rattrapage.py
View File

@ -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,

4
tests/unit/test_refcomp.py
View File

@ -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

52
tests/unit/test_sco_basic.py
View File

@ -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: