From 65221f247ceee734a342c927ad606d7e134135be Mon Sep 17 00:00:00 2001 From: root Date: Mon, 3 May 2021 13:43:11 +0200 Subject: [PATCH 1/9] =?UTF-8?q?test=20des=20fonctions=20li=C3=A9=20aux=20a?= =?UTF-8?q?bs?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scotests/test_absence.py | 184 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 184 insertions(+) create mode 100755 scotests/test_absence.py diff --git a/scotests/test_absence.py b/scotests/test_absence.py new file mode 100755 index 00000000..7a9bf95d --- /dev/null +++ b/scotests/test_absence.py @@ -0,0 +1,184 @@ +""" creation de 10 étudiants, formation, semestre, ue, module, absences le matin, l'apres midi, la journée compléte et justification +d'absences, supression d'absences, création d'une liste etat absences, creation d'un groupe afin de tester la fonction EtatAbsencesGroupes + +Fonctions de l'API utilisé : + - doSignaleAbsence + - doAnnuleAbsence + - doJustifAbsence + - getAbsSemEtud + - get_partition_groups + - get_partitions_list + - CountAbs + - CountAbsJust + - ListeAbsEtud + - partition_create + - createGroup + - set_group + + """ + + +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_abs +import sco_abs_views +import sco_abs_notification + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants +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"], + 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 +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + +# --- Inscription des étudiants +for etud in etuds: + G.inscrit_etudiant(sem, etud) + + +# --- Saisie absences +etudid = etuds[0]["etudid"] + +_ = sco_abs_views.doSignaleAbsence( + context.Absences, + "15/01/2021", + "15/01/2021", + demijournee=1, + etudid=etudid, + REQUEST=REQUEST, +) + +_ = sco_abs_views.doSignaleAbsence( + context.Absences, + "18/01/2021", + "18/01/2021", + demijournee=0, + etudid=etudid, + REQUEST=REQUEST, +) + +_ = sco_abs_views.doSignaleAbsence( + context.Absences, + "19/01/2021", + "19/01/2021", + demijournee=2, + etudid=etudid, + REQUEST=REQUEST, +) + +_ = sco_abs_views.doSignaleAbsence( + context.Absences, + "22/01/2021", + "22/01/2021", + demijournee=1, + etudid=etudid, + REQUEST=REQUEST, +) + +# --- Justification de certaines absences + +_ = sco_abs_views.doJustifAbsence( + context.Absences, + "15/01/2021", + "15/01/2021", + demijournee=1, + etudid=etudid, + REQUEST=REQUEST, +) + +_ = sco_abs_views.doJustifAbsence( + context.Absences, + "18/01/2021", + "18/01/2021", + demijournee=0, + etudid=etudid, + REQUEST=REQUEST, +) + +_ = sco_abs_views.doJustifAbsence( + context.Absences, + "19/01/2021", + "19/01/2021", + demijournee=2, + etudid=etudid, + REQUEST=REQUEST, +) + +# --- Test + +b = sco_abs.is_work_saturday(context.Absences) +assert b == 0 #samedi ne sont pas compris +a = sco_abs.getAbsSemEtud(context.Absences, sem, etudid) +assert a.CountAbs() == 5 #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) +assert a.CountAbsJust() == 4 #l'étudiant justifie ses abs du 15, 18 et 19 + + +# + vérification à l'aide de ScoDoc WEB : ok! + +# --- Supression d'une absence et d'une justification + +_ = sco_abs_views.doAnnuleAbsence(context.Absences, "19/01/2021", "19/01/2021", 2, etudid=etudid, REQUEST=REQUEST) +a = sco_abs.getAbsSemEtud(context.Absences, sem, etudid) +print(a.CountAbs()) #lors du print cela affiche 5 or cela devrait afficher 3 + +#assert a.CountAbs() == 3 +# + vérification à l'aide de ScoDoc WEB : il y a bien plus que 3 abs, 2 justifiés et 1 non justifié. + + + +# --- supression d'une justification pas encore disponible à l'aide de python. + + +# --- Création d'une liste d'abs + +liste_abs = sco_abs_views.ListeAbsEtud(context.Absences, etudid, format='text', REQUEST=REQUEST) +print(liste_abs) +#toutes les absences figurent (bien evidemment pas celle qui a été supprimé alors pq CountAbs indique toujours le même nombre d'abs) + +# --- Création d'un groupe + +_ = sco_groups.partition_create(context.Scolarite, formsemestre_id=sem["formsemestre_id"], partition_name="Eleve", REQUEST=REQUEST) +li1 = sco_groups.get_partitions_list(context.Scolarite, sem["formsemestre_id"]) +_ = sco_groups.createGroup(context.Scolarite, li1[0]["partition_id"], "Groupe 1", REQUEST=REQUEST) + +# --- Affectation des élèves dans des groupes + +li_grp1 = sco_groups.get_partition_groups(context.Scolarite, li1[0]) +for etud in etuds : + sco_groups.set_group(context.Scolarite, etud["etudid"], li_grp1[0]["group_id"]) + +# --- Test de EtatAbsencesGroupes + +# Fonction introuvable. + From 34e34b188ce3ed381df44ab04c9eeeb72f7107db Mon Sep 17 00:00:00 2001 From: root Date: Mon, 3 May 2021 14:29:40 +0200 Subject: [PATCH 2/9] =?UTF-8?q?test=20bas=C3=A9=20sur=20les=20groupes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scotests/test_groupes.py | 385 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 385 insertions(+) create mode 100755 scotests/test_groupes.py diff --git a/scotests/test_groupes.py b/scotests/test_groupes.py new file mode 100755 index 00000000..8ffa5d60 --- /dev/null +++ b/scotests/test_groupes.py @@ -0,0 +1,385 @@ +""" 1) Création de 20 étudiants, création d’une formation, inscription de 10 étudiants dans un semestre (1ere année), + 10 dans un autre (2eme année), création de module, ue, + matière et affectation des étudiants dans deux groupes : A et B pour chaque semestre. + créer 2 évaluations, + affecter des notes dans chaque évaluation et donner la liste des étudiants inscrits à l’évaluation pour chaque groupe. + Donner la liste des groupes auxquels des étudiants inscrits appartiennent à cette évaluation. + Pour une raison quelquonque un élève souhaite changer de groupe. + Changer le nom d'un groupe et d'une partition (à l'aide de fonction) + + + +- Vérification du bon nombres d’étudiants dans chaque chaque groupe (5) + +- Vérification des noms de la formations (acro = DUTI, titre = DUT Info, titre_officiel = DUT Informatique), + UE (acr = UE11/UE31, titre = UE1S1/UE1S3), modules (code = M1S1/M1S3, titre = mod1/mod2), matières (ue_id=ue1/2[ue_id], titre = mat1/mat2) + +- Vérification des listes de groupes et de partitions + +- Vérification du changement de groupe des étudiants + +- Teste d'autres fonctions de l'API correspondant aux groupes + +Fonctions de l’API utilisé : + - create_formation + - create_ue + - create_module + - create_matiere + - create_formsemestre + - create_moduleimpl + - inscrit_etudiant + - partition_create + - get_default_partition + - createGroupe + - partition_create + - get_partitions_list + - get_partition_groups + - set_group + - get_etud_groups + - change_etud_group_in_partition + - get_group + - group_delete + - get_partition + - get_default_group + - get_default_partition + - get_sem_groups + - get_group_members + - do_evaluation_listeetuds_groups + - do_evaluation_listegroupes + - formsemestre_partition_list + +""" + +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_groups + + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants +etuds = [G.create_etud(code_nip=None) for _ in range(20)] +assert len(etuds) == 20 + +# --- Création d'une formation + +f = G.create_formation( + acronyme="DUTI", + titre="DUT Info", + titre_officiel="DUT Informatique", + ) + +assert f["acronyme"]=="DUTI" +assert f["titre"]=="DUT Info" +assert f["titre_officiel"]=="DUT Informatique" + + +# --- Création d'UE, matière, module pour les premieres années + +ue1 = G.create_ue(formation_id=f["formation_id"], acronyme="UE11", titre="UE1S1") + +mat1 = G.create_matiere(ue_id=ue1["ue_id"], titre="mat1") +mod1 = G.create_module( + matiere_id=mat1["matiere_id"], + code="M1S1", + coefficient=1.0, + titre="mod1", + ue_id=ue1["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +assert ue1["formation_id"] == f["formation_id"] +assert ue1["acronyme"]=="UE11" +assert ue1["titre"]=="UE1S1" + +assert mod1["matiere_id"]==mat1["matiere_id"] +assert mod1["code"]=="M1S1" +assert mod1["titre"]=="mod1" +assert mod1["ue_id"]==ue1["ue_id"] +assert mod1["formation_id"]==f["formation_id"] + +# --- Création d'UE, matière, module pour les deuxieme années + +ue2 = G.create_ue(formation_id=f["formation_id"], acronyme="UE31", titre="UE1S1") + +mat2 = G.create_matiere(ue_id=ue2["ue_id"], titre="mat2") +mod2 = G.create_module( + matiere_id=mat2["matiere_id"], + code="M1S3", + coefficient=1.0, + titre="mod2", + ue_id=ue2["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +# --- Mise place des semestres + +sem1 = G.create_formsemestre( + formation_id=f["formation_id"], + semestre_id=1, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +assert sem1["formation_id"]==f["formation_id"] +assert sem1["semestre_id"]==1 +assert sem1["date_debut"]=="01/09/2020" +assert sem1["date_fin"]=="01/02/2021" + +sem2 = G.create_formsemestre( + formation_id=f["formation_id"], + semestre_id=2, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + + +mi1 = G.create_moduleimpl( + module_id=mod1["module_id"], + formsemestre_id=sem1["formsemestre_id"], + responsable_id="bach", +) + +assert mi1["module_id" ]==mod1["module_id"] +assert mi1["formsemestre_id"]==sem1["formsemestre_id"] +assert mi1["responsable_id"]=="bach" + +mi2 = G.create_moduleimpl( + module_id=mod2["module_id"], + formsemestre_id=sem2["formsemestre_id"], + responsable_id="bach", +) + + +# --- Inscription des étudiants + +for etud in etuds[:10] : + G.inscrit_etudiant(sem1, etud) + +for etud in etuds [10:] : + G.inscrit_etudiant(sem2, etud) + +# --- Création de 2 partitions + +_ = sco_groups.partition_create(context.Scolarite, formsemestre_id=sem1["formsemestre_id"], partition_name="Eleve 1ere annee", REQUEST=REQUEST) +_ = sco_groups.partition_create(context.Scolarite, formsemestre_id=sem2["formsemestre_id"], partition_name="Eleve 2eme annee", REQUEST=REQUEST) + + +li1 = sco_groups.get_partitions_list(context.Scolarite, sem1["formsemestre_id"]) +li2 = sco_groups.get_partitions_list(context.Scolarite, sem2["formsemestre_id"]) + + +# --- Création des groupes + +_ = sco_groups.createGroup(context.Scolarite, li1[0]["partition_id"], "Groupe S1A", REQUEST=REQUEST) +_ = sco_groups.createGroup(context.Scolarite, li1[0]["partition_id"], "Groupe S1B", REQUEST=REQUEST) +_ = sco_groups.createGroup(context.Scolarite, li2[0]["partition_id"], "Groupe S3A", REQUEST=REQUEST) +_ = sco_groups.createGroup(context.Scolarite, li2[0]["partition_id"], "Groupe S3B", REQUEST=REQUEST) +_ = sco_groups.createGroup(context.Scolarite, li2[0]["partition_id"], "Groupe TEST", REQUEST=REQUEST) + +li_grp1 = sco_groups.get_partition_groups(context.Scolarite, li1[0]) +li_grp2 = sco_groups.get_partition_groups(context.Scolarite, li2[0]) +li_grp3 = sco_groups.get_partition_groups(context.Scolarite, li1[1]) #liste groupe defaut + +assert len(li_grp1) == 2 #test de get_partition_groups # 2 +assert len(li_grp2) == 3 #test de get_partition_groups # 3 +assert li_grp1[0]["group_name"] == "Groupe S1A" + + +# --- Affectation des élèves dans les groupes + +for etud in etuds[:5] : + sco_groups.set_group(context.Scolarite, etud["etudid"], li_grp1[0]["group_id"]) + +for etud in etuds[5:10] : + sco_groups.set_group(context.Scolarite, etud["etudid"], li_grp1[1]["group_id"]) + +for etud in etuds[10:15] : + sco_groups.set_group(context.Scolarite, etud["etudid"], li_grp2[0]["group_id"]) + +for etud in etuds[15:] : + sco_groups.set_group(context.Scolarite, etud["etudid"], li_grp2[1]["group_id"]) + +# --- Vérification si les élèves sont bien dans les bons groupes + +for etud in etuds[:5] : + grp = sco_groups.get_etud_groups(context.Scolarite, etud["etudid"], sem1, exclude_default=True) + assert grp[0]["group_name"] == "Groupe S1A" + +for etud in etuds[5:10] : + grp = sco_groups.get_etud_groups(context.Scolarite, etud["etudid"], sem1, exclude_default=True) + assert grp[0]["group_name"] == "Groupe S1B" + +for etud in etuds[10:15] : + grp = sco_groups.get_etud_groups(context.Scolarite, etud["etudid"], sem2, exclude_default=True) + assert grp[0]["group_name"] == "Groupe S3A" + +for etud in etuds[15:] : + grp = sco_groups.get_etud_groups(context.Scolarite, etud["etudid"], sem2, exclude_default=True) + assert grp[0]["group_name"] == "Groupe S3B" + +# --- Création d'une évaluation + +e1 = G.create_evaluation( + moduleimpl_id=mi1["moduleimpl_id"], + jour="01/10/2020", + description="evaluation test", + coefficient=1.0, +) + +e2 = G.create_evaluation( + moduleimpl_id=mi2["moduleimpl_id"], + jour="01/11/2020", + description="evaluation test2", + coefficient=1.0, +) + +# --- Saisie des notes + +for etud in etuds[10:] : + nb_changed, nb_suppress, existing_decisions = G.create_note( + evaluation=e1, etud=etud, note=float(random.randint(0, 20)) + ) + + +for etud in etuds[:10] : + nb_changed, nb_suppress, existing_decisions = G.create_note( + evaluation=e2, etud=etud, note=float(random.randint(0, 20)) + ) + +# --- Liste des étudiants inscrits aux evaluations + +lie1 = sco_groups.do_evaluation_listeetuds_groups(context.Scolarite, e1["evaluation_id"], groups = li_grp1) +lie2 = sco_groups.do_evaluation_listeetuds_groups(context.Scolarite, e2["evaluation_id"], groups = li_grp2) + +for etud in etuds[:10] : + assert etud["etudid"] in lie1 # test de do_evaluation_listeetuds_groups + +for etud in etuds[10:] : + assert etud["etudid"] in lie2 # test de do_evaluation_listeetuds_groups + + +# --- Liste des groupes présents aux évaluation + +lig1 = sco_groups.do_evaluation_listegroupes(context.Scolarite, e1["evaluation_id"], include_default=False) +lig2 = sco_groups.do_evaluation_listegroupes(context.Scolarite, e2["evaluation_id"], include_default=False) + + +assert len(lig1) == 2 +assert len(lig2) == 2 +assert li_grp1[0] and li_grp1[1] in lig1 # test do_evaluation_listegroupes +assert li_grp2[0] and li_grp2[1] in lig2 # test do_evaluation_listegroupes + + + +# --- Changement de groupe d'un élève + +grp1 = sco_groups.get_etud_groups(context.Scolarite, etuds[0]["etudid"], sem1, exclude_default = True) +sco_groups.change_etud_group_in_partition(context.Scolarite, etuds[0]["etudid"], li_grp1[1]["group_id"], li1[0], REQUEST=REQUEST) +grp2 = sco_groups.get_etud_groups(context.Scolarite, etuds[0]["etudid"], sem1, exclude_default = True) +assert grp1 != grp2 +assert grp1[0] == li_grp1[0] # test get_etud_groups +assert grp2[0]["group_name"] == "Groupe S1B" #test du changement de groupe + + +# --- Liste des partitions en format json + +lijson_s1 = sco_groups.formsemestre_partition_list(context.Scolarite, formsemestre_id=sem1["formsemestre_id"], format = "json", REQUEST=REQUEST) +load_lijson_s1 = json.loads(lijson_s1) + +assert len(load_lijson_s1) == 2 # 2 partition (defaut et eleve 1ere annee) +assert load_lijson_s1[0]["formsemestre_id"] == sem1["formsemestre_id"] +assert len(load_lijson_s1[0]["group"]) == 2 # 2 groupes S1A et S1B +assert load_lijson_s1[0]["group"][0]["group_name"] == "Groupe S1A" +assert load_lijson_s1[0]["group"][0]["group_id"] == li_grp1[0]["group_id"] +assert load_lijson_s1[0]["partition_id"] == load_lijson_s1[0]["group"][0]["partition_id"] == li1[0]["partition_id"] +assert load_lijson_s1[0]["partition_name"] == "Eleve 1ere annee" + + + +# --- Vue d'un groupes (liste d'élève en format json ou xml) + + + + + + +# --- Test des fonctions dans sco_groups + +#_ = sco_groups.checkGroupName(li_grp1[0]["group_name"]) +#_ = sco_groups.checkGroupName("Groupe S1B") +#_ = sco_groups.checkGroupName("Groupe S3A") +#_ = sco_groups.checkGroupName("Groupe S3B") + +assert li_grp1[0] == sco_groups.get_group(context.Scolarite, li_grp1[0]["group_id"]) #test get_group + +assert len(li_grp2) == 3 +sco_groups.group_delete(context.Scolarite, li_grp2[2]) +#assert len(li_grp2) == 2 #TESTE DE group_delete, aucun changement sur la console mais se supprime sur scodoc web + # mais pas dans la console comme pour countAbs() + +assert sco_groups.get_partition(context.Scolarite, li1[0]["partition_id"])== li1[0] # test de get_partition +assert sco_groups.get_partition(context.Scolarite, li2[0]["partition_id"])== li2[0] # test de get_partition + + + +li1 = sco_groups.get_partitions_list(context.Scolarite, sem1["formsemestre_id"]) +#assert p1 in li1 #test de get_partitions_list +assert len(li1) == 2 #eleve de 1ere annee + la partition defaut + +li2 = sco_groups.get_partitions_list(context.Scolarite, sem2["formsemestre_id"]) +#assert p2 in li2 #test de get_partitions_list +assert len(li2) == 2 #eleve de 2eme annee + la partition defaut + + +dp1 = sco_groups.get_default_partition(context.Scolarite, sem1["formsemestre_id"]) +dp2 = sco_groups.get_default_partition(context.Scolarite, sem2["formsemestre_id"]) + +assert dp1 in li1 # test si dp1 est bien dans li1 et par consequent teste la fonction get_default_partition +assert dp2 in li2 # test si dp2 est bien dans li1 et par consequent teste la fonction get_default_partition + + +dg1 = sco_groups.get_default_group(context.Scolarite, sem1["formsemestre_id"], REQUEST=REQUEST) +assert li_grp3[0]["group_id"] == dg1 #test de get_default_group + + +sg = sco_groups.get_sem_groups(context.Scolarite, sem1["formsemestre_id"]) +assert len(sg) == 3 #test de get_sem_groups +assert li_grp1[0] and li_grp1[1] in sg +assert li_grp3[0] in sg # test de get_sem_groups + +limembre = sco_groups.get_group_members(context.Scolarite, li_grp1[0]["group_id"]) +assert len(limembre) == 4 # car on a changé de groupe un etudiant de ce groupe donc 5-1=4 + + + +# --- Changement de nom des partitions, groupes + +# Le changement de nom des groupes et des partitions n'est pas possible en python car la fonction est une fonction d'envoie de formulaire. + + + + + + + + + + + + + + + + + + + + + From 699b482c30510c07c30aa3daf2d3f580a91fa069 Mon Sep 17 00:00:00 2001 From: root Date: Mon, 3 May 2021 14:57:58 +0200 Subject: [PATCH 3/9] mini test parametre demijournee --- scotests/test_abs_demijournee.py | 106 +++++++++++++++++++++++++++++++ 1 file changed, 106 insertions(+) create mode 100755 scotests/test_abs_demijournee.py diff --git a/scotests/test_abs_demijournee.py b/scotests/test_abs_demijournee.py new file mode 100755 index 00000000..14c86b45 --- /dev/null +++ b/scotests/test_abs_demijournee.py @@ -0,0 +1,106 @@ +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_abs +import sco_abs_views +import sco_abs_notification + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants +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"], + 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 +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + +# --- Inscription des étudiants +G.inscrit_etudiant(sem, etud) + + +# --- Saisie absences +etudid = etud["etudid"] + +_ = sco_abs_views.doSignaleAbsence( + context.Absences, + "15/01/2021", + "15/01/2021", + demijournee=2, + etudid=etudid, + REQUEST=REQUEST, +) + + +_ = sco_abs_views.doSignaleAbsence( + context.Absences, + "18/01/2021", + "18/01/2021", + demijournee=1, + etudid=etudid, + REQUEST=REQUEST, +) + +_ = sco_abs_views.doSignaleAbsence( + context.Absences, + "19/01/2021", + "19/01/2021", + demijournee=0, + etudid=etudid, + REQUEST=REQUEST, +) + +# --- Justification de certaines absences + +_ = sco_abs_views.doJustifAbsence( + context.Absences, + "18/01/2021", + "18/01/2021", + demijournee=1, + etudid=etudid, + REQUEST=REQUEST, +) + +_ = sco_abs_views.doJustifAbsence( + context.Absences, + "19/01/2021", + "19/01/2021", + demijournee=2, + etudid=etudid, + REQUEST=REQUEST, +) + +# NE JUSTIFIE QUE LE MATIN MALGRES LE PARAMETRE demijournee = 2 + +# --- Test + +a = sco_abs.getAbsSemEtud(context.Absences, sem, etudid) +assert a.CountAbs() == 4 #l'étudiant a été absent le 15 journée compléte (2 abs : 1 matin, 1 apres midi) et le 18 (1 matin), et le 19 (1 apres midi). +assert a.CountAbsJust() == 2 # Justifie abs du matin + abs après midi \ No newline at end of file From 600016d1e0118000c94cc4f9327336316de45e48 Mon Sep 17 00:00:00 2001 From: root Date: Tue, 18 May 2021 11:31:39 +0200 Subject: [PATCH 4/9] ajout de nouveaux tests --- scotests/export_formation1.xml | 205 ++++ scotests/formation_export.json | 1352 +++++++++++++++++++++ scotests/test_absence.py | 50 +- scotests/test_create_etud.py | 47 + scotests/test_etudiant1.py | 98 ++ scotests/test_evaluation.py | 235 ++++ scotests/test_evaluation_suppress_alln.py | 70 ++ scotests/test_formations.py | 321 +++++ scotests/test_groupes.py | 25 +- scotests/test_scenario1_app.py | 117 ++ scotests/test_scenario1_formation.py | 72 ++ scotests/test_scenario2_formation.py | 105 ++ scotests/test_scenario3_formation.py | 135 ++ scotests/test_scenario4_formation.py | 172 +++ scotests/test_user.py | 49 + static/formation_export.json | 1352 +++++++++++++++++++++ 16 files changed, 4395 insertions(+), 10 deletions(-) create mode 100755 scotests/export_formation1.xml create mode 100755 scotests/formation_export.json create mode 100755 scotests/test_create_etud.py create mode 100755 scotests/test_etudiant1.py create mode 100755 scotests/test_evaluation.py create mode 100755 scotests/test_evaluation_suppress_alln.py create mode 100755 scotests/test_formations.py create mode 100755 scotests/test_scenario1_app.py create mode 100755 scotests/test_scenario1_formation.py create mode 100755 scotests/test_scenario2_formation.py create mode 100755 scotests/test_scenario3_formation.py create mode 100755 scotests/test_scenario4_formation.py create mode 100755 scotests/test_user.py create mode 100755 static/formation_export.json diff --git a/scotests/export_formation1.xml b/scotests/export_formation1.xml new file mode 100755 index 00000000..8baf7a6b --- /dev/null +++ b/scotests/export_formation1.xml @@ -0,0 +1,205 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/scotests/formation_export.json b/scotests/formation_export.json new file mode 100755 index 00000000..1c13dc0b --- /dev/null +++ b/scotests/formation_export.json @@ -0,0 +1,1352 @@ +{ + "acronyme": "DUT Info", + "code_specialite": "", + "type_parcours": 100, + "titre_officiel": "DUT Informatique", + "formation_code": "FCOD2", + "version": 1, + "ue": [ + { + "acronyme": "UE11", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architecture mat\u00e9rielle - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M1101", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 30.0, + "abbrev": "", + "numero": 1, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction aux syst\u00e8mes informatiques", + "heures_td": 20.0 + } + ], + "numero": 1 + }, + { + "titre": "Algorithmique - Programmation - Langages", + "module": [ + { + "coefficient": 2.0, + "code": "M1102", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 30.0, + "abbrev": "Algorithmique", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction \u00e0 l\u2019algorithmique et \u00e0 la programmation", + "heures_td": 20.0 + } + ], + "numero": 2 + }, + { + "titre": "Algorithmique - Programmation - Langages Avanc\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M1103", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "Structure de donn\u00e9es", + "numero": 3, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Structure de donn\u00e9es et algorithmes fondamentaux", + "heures_td": 15.0 + } + ], + "numero": 3 + }, + { + "titre": "Syst\u00e8mes de gestion de bases de donn\u00e9es", + "module": [ + { + "coefficient": 3.0, + "code": "M1104", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 25.0, + "abbrev": "BDD", + "numero": 4, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction aux bases de donn\u00e9es", + "heures_td": 25.0 + } + ], + "numero": 4 + }, + { + "titre": "Web - Internet - Mobilit\u00e9 Expression - Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M1105", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 25.0, + "abbrev": "CDIN", + "numero": 5, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Conception de documents et d\u2019interfaces num\u00e9riques", + "heures_td": 20.0 + } + ], + "numero": 5 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M1106", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "Projet", + "numero": 6, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 : d\u00e9couverte", + "heures_td": 0.0 + } + ], + "numero": 6 + } + ], + "ue_code": "UE11", + "numero": 1, + "titre": "Base de l'informatique", + "type": 0 + }, + { + "acronyme": "UE21", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architecture mat\u00e9rielle - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M2101", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Architecture et Programmation des m\u00e9canismes de base d\u2019un syst\u00e8me informatique", + "heures_td": 10.0 + } + ], + "numero": 1 + }, + { + "titre": "Architecture mat\u00e9rielle - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux avanc\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M2102", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Architecture des r\u00e9seaux", + "heures_td": 10.0 + } + ], + "numero": 2 + }, + { + "titre": "Algorithmique - Programmation - Langages Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M2103", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 30.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Bases de la programmation orient\u00e9e objet", + "heures_td": 20.0 + } + ], + "numero": 3 + }, + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M2104", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "COO", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Bases de la conception orient\u00e9e objet", + "heures_td": 15.0 + } + ], + "numero": 4 + }, + { + "titre": "Interface homme-machine", + "module": [ + { + "coefficient": 2.0, + "code": "M2105", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction aux interfaces homme-machine", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Syst\u00e8mes de gestion de bases de donn\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M2106", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Programmation et administration des bases de donn\u00e9es", + "heures_td": 15.0 + } + ], + "numero": 6 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M2107", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 : Description et planification de projet", + "heures_td": 0.0 + } + ], + "numero": 7 + } + ], + "ue_code": "UE21", + "numero": 1, + "titre": "Informatique approfondie", + "type": 0 + }, + { + "acronyme": "UE31", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M3101", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 16.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Principes des syst\u00e8mes d\u2019exploitation", + "heures_td": 14.0 + } + ], + "numero": 1 + }, + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation, R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M3102", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Services r\u00e9seaux", + "heures_td": 10.0 + } + ], + "numero": 2 + }, + { + "titre": "Algorithmique - Programmation - Langages avanc\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M3103", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Algorithmique avanc\u00e9e", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Web - Internet - Mobilit\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M3104", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 16.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Programmation Web c\u00f4t\u00e9 serveur", + "heures_td": 14.0 + } + ], + "numero": 4 + }, + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 16.0, + "code": "M3105", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 14.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Conception et programmation objet avanc\u00e9es", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Syst\u00e8mes de gestion de bases de donn\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M3106C", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Bases de donn\u00e9es avanc\u00e9es", + "heures_td": 10.0 + } + ], + "numero": 6 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS1", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 16 + } + ], + "ue_code": "UCOD5", + "numero": 1, + "titre": "Informatique avanc\u00e9e", + "type": 0 + }, + { + "acronyme": "UE41", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M4101C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Administration syst\u00e8me et r\u00e9seau", + "heures_td": 10.0 + } + ], + "numero": 1 + }, + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation \u2013 R\u00e9seaux Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M4102C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Programmation r\u00e9partie", + "heures_td": 10.0 + } + ], + "numero": 2 + }, + { + "titre": "Web \u2013 Internet - Mobilit\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M4103C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Programmation Web \u2013 client riche", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Web - Internet - Mobilit\u00e9 - Mobile", + "module": [ + { + "coefficient": 3.0, + "code": "M4104C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Conception et d\u00e9veloppement d\u2019applications mobiles", + "heures_td": 10.0 + } + ], + "numero": 4 + }, + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M4105C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Compl\u00e9ments d\u2019informatique en vue d\u2019une insertion imm\u00e9diate", + "heures_td": 10.0 + } + ], + "numero": 5 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M4106", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 \u2013 Compl\u00e9ments", + "heures_td": 0.0 + } + ], + "numero": 6 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS1", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 16 + } + ], + "ue_code": "UCOD8", + "numero": 1, + "titre": "Compl\u00e9ments en informatique", + "type": 0 + }, + { + "acronyme": "UE12", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M1201", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 17.0, + "abbrev": "", + "numero": 1, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Math\u00e9matiques discr\u00e8tes", + "heures_td": 18.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques avanc\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M1202", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 6.0, + "module_type": 0, + "titre": "Alg\u00e8bre lin\u00e9aire", + "heures_td": 12.0 + } + ], + "numero": 2 + }, + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M1203", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Environnement \u00e9conomique", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Organisation", + "module": [ + { + "coefficient": 1.0, + "code": "M1204", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Fonctionnement des organisations", + "heures_td": 20.0 + } + ], + "numero": 4 + }, + { + "titre": "Expression - Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M1205", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Fondamentaux de la communication", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M1206", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Anglais et Informatique", + "heures_td": 15.0 + } + ], + "numero": 6 + }, + { + "titre": "PPP Expression - Communication", + "module": [ + { + "coefficient": 1.0, + "code": "M1207", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Conna\u00eetre le monde professionnel", + "heures_td": 10.0 + } + ], + "numero": 7 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 17 + } + ], + "ue_code": "UE12", + "numero": 2, + "titre": "Bases de culture scientifique, sociale et humaine", + "type": 0 + }, + { + "acronyme": "UE22", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M2201", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 18.0, + "abbrev": "", + "numero": 10, + "heures_cours": 11.0, + "module_type": 0, + "titre": "Graphes et langages", + "heures_td": 16.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques avanc\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M2202", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Analyse et m\u00e9thodes num\u00e9riques", + "heures_td": 12.0 + } + ], + "numero": 2 + }, + { + "titre": "\u00c9conomie - Gestion - Droit - Organisation", + "module": [ + { + "coefficient": 2.0, + "code": "M2203", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 12.0, + "module_type": 0, + "titre": "Environnement comptable, financier, juridique et social", + "heures_td": 18.0 + } + ], + "numero": 3 + }, + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M2204", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Gestion de projet informatique", + "heures_td": 12.0 + } + ], + "numero": 4 + }, + { + "titre": "Expression - Communication", + "module": [ + { + "coefficient": 1.0, + "code": "M2205", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communication, information et argumentation", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M2206", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 22.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communiquer en anglais", + "heures_td": 23.0 + } + ], + "numero": 6 + }, + { + "titre": "PPP", + "module": [ + { + "coefficient": 1.0, + "code": "M2207", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "PPP - Identifier ses comp\u00e9tences", + "heures_td": 10.0 + } + ], + "numero": 7 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 17 + } + ], + "ue_code": "UCOD4", + "numero": 2, + "titre": "Approfondissements en culture scientifique, sociale et humaine", + "type": 0 + }, + { + "acronyme": "UE32", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M3201", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 14.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Probabilit\u00e9s et statistique", + "heures_td": 16.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques avanc\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M3202C", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 14.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Mod\u00e9lisations math\u00e9matiques", + "heures_td": 16.0 + } + ], + "numero": 2 + }, + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M3203", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Droit des technologies de l\u2019information et de la communication", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Gestion", + "module": [ + { + "coefficient": 2.0, + "code": "M3204", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Gestion des syst\u00e8mes d\u2019information", + "heures_td": 15.0 + } + ], + "numero": 4 + }, + { + "titre": "Expression - Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M3205", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communication professionnelle", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M3206", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 22.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Collaborer en anglais", + "heures_td": 23.0 + } + ], + "numero": 6 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 16 + } + ], + "ue_code": "UCOD6", + "numero": 2, + "titre": "Culture scientifique, sociale et humaine avanc\u00e9es", + "type": 0 + }, + { + "acronyme": "UE33", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications \u00c9conomie - gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M3301", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 24.0, + "abbrev": "", + "numero": 10, + "heures_cours": 14.0, + "module_type": 0, + "titre": "M\u00e9thodologie de la production d\u2019applications", + "heures_td": 22.0 + } + ], + "numero": 1 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M3302", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 - Mise en situation professionnelle", + "heures_td": 0.0 + } + ], + "numero": 2 + }, + { + "titre": "PPP", + "module": [ + { + "coefficient": 2.0, + "code": "M3303", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "PPP - Pr\u00e9ciser son projet", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 13 + } + ], + "ue_code": "UCOD7", + "numero": 2, + "titre": "M\u00e9thodologie et projets", + "type": 0 + }, + { + "acronyme": "UE42", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M4201C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Ateliers de cr\u00e9ation d\u2019entreprise", + "heures_td": 12.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M4202C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Introduction \u00e0 la recherche op\u00e9rationnelle et aide \u00e0 la d\u00e9cision", + "heures_td": 12.0 + } + ], + "numero": 2 + }, + { + "titre": "Expression \u2013 Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M4203", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communication dans les organisations", + "heures_td": 15.0 + } + ], + "numero": 3 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M4204", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Travailler en anglais", + "heures_td": 15.0 + } + ], + "numero": 4 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 14 + } + ], + "ue_code": "UCOD9", + "numero": 2, + "titre": "Compl\u00e9ments de culture scientifique, sociale et humaine", + "type": 0 + }, + { + "acronyme": "UE43", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "STAGE", + "module": [ + { + "coefficient": 12.0, + "code": "M4301", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Stage professionnel", + "heures_td": 0.0 + } + ], + "numero": 1 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS3", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 11 + } + ], + "ue_code": "UCOD10", + "numero": 3, + "titre": "Mise en situation professionnelle", + "type": 0 + } + ], + "titre": "DUT Informatique", + "formation_id": "FORM234" +} \ No newline at end of file diff --git a/scotests/test_absence.py b/scotests/test_absence.py index 7a9bf95d..5a9ba1a3 100755 --- a/scotests/test_absence.py +++ b/scotests/test_absence.py @@ -28,6 +28,7 @@ import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error import sco_abs import sco_abs_views import sco_abs_notification +import ZAbsences G = sco_fake_gen.ScoFake(context.Notes) G.verbose = False @@ -66,6 +67,14 @@ mi = G.create_moduleimpl( for etud in etuds: G.inscrit_etudiant(sem, etud) +#--- Création d'une évaluation +e = G.create_evaluation( + moduleimpl_id=mi["moduleimpl_id"], + jour="22/01/2021", + description="evaluation test", + coefficient=1.0, +) + # --- Saisie absences etudid = etuds[0]["etudid"] @@ -162,9 +171,21 @@ print(a.CountAbs()) #lors du print cela affiche 5 or cela devrait afficher 3 # --- Création d'une liste d'abs -liste_abs = sco_abs_views.ListeAbsEtud(context.Absences, etudid, format='text', REQUEST=REQUEST) -print(liste_abs) -#toutes les absences figurent (bien evidemment pas celle qui a été supprimé alors pq CountAbs indique toujours le même nombre d'abs) +liste_abs = sco_abs_views.ListeAbsEtud(context.Absences, etudid, format='json', absjust_only=1, REQUEST=REQUEST) +liste_abs2 = sco_abs_views.ListeAbsEtud(context.Absences, etudid, format='json', REQUEST=REQUEST) + +load_liste_abs = json.loads(liste_abs) +load_liste_abs2 = json.loads(liste_abs2) + +assert len(load_liste_abs2) == 1 +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"] + + +# absjust_only -> seulement les abs justifiés + # --- Création d'un groupe @@ -180,5 +201,26 @@ for etud in etuds : # --- Test de EtatAbsencesGroupes -# Fonction introuvable. +grp1_abs = context.Absences.EtatAbsencesGr(group_ids=[li_grp1[0]["group_id"]], debut="01/01/2021", fin ="30/06/2021", format="json", REQUEST=REQUEST) +load_grp1_abs = json.loads(grp1_abs) + +assert len(load_grp1_abs) == 10 + +tab_id=[] #tab des id present dans load_grp1_abs +for un_etud in load_grp1_abs : + tab_id.append(un_etud["etudid"]) + +for etud in etuds : #verification si tous les etudiants sont present dans la liste du groupe d'absence + assert etud["etudid"] in tab_id + + +for un_etud in load_grp1_abs : + if un_etud["etudid"] == etudid : + assert un_etud["nbabs"] == "3" + assert un_etud["nbjustifs_noabs"] == "2" + assert un_etud["nbabsjust"] == "2" + assert un_etud["nbabsnonjust"] == "1" + assert un_etud["nomprenom"] == etuds[0]["nomprenom"] + + diff --git a/scotests/test_create_etud.py b/scotests/test_create_etud.py new file mode 100755 index 00000000..9430538a --- /dev/null +++ b/scotests/test_create_etud.py @@ -0,0 +1,47 @@ +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error + + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'un étudiant + +etud = G.create_etud( + code_nip="", + nom="Poire", + prenom="Kevin", + code_ine="", + civilite="M", + etape="TST1", + email="test1@localhost", + emailperso="perso1@localhost", + date_naissance="01/05/2001", + lieu_naissance="Stains", + dept_naissance="93", + domicile="11, rue du test", + codepostaldomicile="93430", + villedomicile="Villetaneuse", + paysdomicile="France", + telephone="0102030405", + typeadresse="domicile", + boursier=None, + description="etudiant test", + ) + +print(etud) +print(" ") + +info = context.Scolarite.etud_info(etud["etudid"], format = "json", REQUEST=REQUEST) +load_info = json.loads(info) +print(load_info) + +#malgrè l'entrée de donnée dans les paramètres la fonction ne les prend pas en compte. Sauf pour date_naissance, +#dept_naissance, nom et prenom, lieu_naissance et civilite la fonction crée aussi un code nip et ine donc pas de pb +#pour ca. + +print(" ") +print(etud["telephone"]) +print(etud["domicile"]) +print(etud["emailperso"]) \ No newline at end of file diff --git a/scotests/test_etudiant1.py b/scotests/test_etudiant1.py new file mode 100755 index 00000000..cf2b4334 --- /dev/null +++ b/scotests/test_etudiant1.py @@ -0,0 +1,98 @@ +""" 3) Création d’étudiants, formation etc… Au cours de l’année un étudiant déménage et souhaite changer +ses informations personnelles. Un autre étudiant lui à changer de téléphone portable ainsi que d’adresse e-mail. +Changer les données + +Vérifier si les changements se sont effectués + +Fonctions de l’API utilisé : +- create_formation +- create_ue +- create_module +- create_matiere +- create_formsemestre +- create_moduleimpl +- inscrit_etudiant +- etuds_info +- getEtudInfo +- identite_edit + + """ + + +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour éviter les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import scolars + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants + +etud = G.create_etud( + code_nip="", + nom="Poire", + prenom="Kevin", + code_ine="", + civilite="M", + etape="TST1", + email="test1@localhost", + emailperso="perso1@localhost", + date_naissance="01/05/2001", + lieu_naissance="Stains", + dept_naissance="93", + domicile="11, rue du test", + codepostaldomicile="93430", + villedomicile="Villetaneuse", + paysdomicile="France", + telephone="0102030405", + typeadresse="domicile", + boursier=None, + description="etudiant test", + ) + +# --- 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"], + 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 +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + + +# --- Inscription de l'étudiant + +G.inscrit_etudiant(sem, etud) + +print(etud) + +info = context.Scolarite.etud_info(etud["etudid"], format = "json", REQUEST=REQUEST) +load_info = json.loads(info) +print(load_info) + +# --- Modification des données + +scolars.adresse_edit(context.Scolarite, args = {"domicile" : "9 rue du moulin"}) \ No newline at end of file diff --git a/scotests/test_evaluation.py b/scotests/test_evaluation.py new file mode 100755 index 00000000..084fc6b0 --- /dev/null +++ b/scotests/test_evaluation.py @@ -0,0 +1,235 @@ +""" Création d'une formation, d'élève de 2 ue dans un semestre et de 6 évaluations par 3 fonction différentes : +create_eval, evaluation_create et do_evaluation_create. Saisir les notes des évaluations, lister ces evaluations, +supprimer et modifier une evaluation """ + +import sys +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_moduleimpl +import sco_liste_notes +import sco_evaluations +import sco_undo_notes +import sco_abs_views +import sco_saisie_notes + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants +etuds = [G.create_etud(code_nip=None) for _ in range(10)] + +# --- Création d'une formation et de deux UE +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"], + 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 +) + +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"], + code="TSM2", + coefficient=1.0, + titre="module test2", + ue_id=ue2["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + +mi2 = G.create_moduleimpl( + module_id=mod2["module_id"], + formsemestre_id=sem["formsemestre_id"], + responsable_id="bach", +) + + +# --- Inscription des étudiants +for etud in etuds: + G.inscrit_etudiant(sem, etud) + +# --- Création des évaluations + +#création d'éval avec create_evaluation +e = G.create_evaluation( + moduleimpl_id=mi["moduleimpl_id"], + jour="7/01/2021", + description="evaluation test 1", + coefficient=1.0, +) + +e2 = G.create_evaluation( + moduleimpl_id=mi2["moduleimpl_id"], + jour="11/01/2021", + description="evaluation test 2", + coefficient=1.0, +) + + + +#création d'éval avec evaluation_create +#e3 = context.Notes.evaluation_create(mi["moduleimpl_id"], REQUEST) +#e4 = context.Notes.evaluation_create(mi2["moduleimpl_id"], REQUEST) # rien ne se passe + +#création d'éval avec do_evaluation_create ! WARNING : retourne l'id de l'éval ! +e5 = context.Notes.do_evaluation_create( + moduleimpl_id=mi["moduleimpl_id"], + jour="01/02/2021", + heure_debut="9h0", + heure_fin="11h0", + description="evaluation test 5", + note_max="20.0", + coefficient="1", + REQUEST=REQUEST + ) + +e6 = context.Notes.do_evaluation_create( + moduleimpl_id=mi2["moduleimpl_id"], + jour="01/02/2021", + heure_debut="13h0", + heure_fin="15h0", + description="evaluation test 6", + note_max="20.0", + coefficient="1", + REQUEST=REQUEST + ) + + + +# --- Liste des évaluations dans le semestre + +lie = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem["formsemestre_id"]) +assert len(lie) == 4 +""" print(lie[0]) +print(" ") +print(lie[1]) +print(" ") +print(lie[2]) +print(" ") +print(lie[3]) """ + +eval5 = context.Notes.do_evaluation_list({"evaluation_id" : e5})[0] +eval6 = context.Notes.do_evaluation_list({"evaluation_id" : e6})[0] + +# --- Saisie des absences aux évaluations + +_ = sco_abs_views.doSignaleAbsence( + context.Absences, + "7/01/2021", + "7/01/2021", + demijournee=1, + etudid=etuds[0]["etudid"], + REQUEST=REQUEST, +) + +_ = sco_abs_views.doSignaleAbsence( + context.Absences, + "01/02/2021", + "01/02/2021", + demijournee=1, + etudid=etuds[1]["etudid"], + REQUEST=REQUEST, +) + +_ = sco_abs_views.doJustifAbsence( + context.Absences, + "01/02/2021", + "01/02/2021", + demijournee=1, + etudid=etuds[1]["etudid"], + REQUEST=REQUEST, +) + +# --- Saisie des notes + +evals = [e,e2,eval5,eval6] + +for eval in evals : + for etud in etuds: + nb_changed, nb_suppress, existing_decisions = G.create_note( + evaluation=eval, etud=etud, note=float(random.randint(0, 20)) + ) + +# --- Check abs + +check = sco_liste_notes.evaluation_check_absences(context.Notes, evaluation_id=e["evaluation_id"]) + +check2 = sco_liste_notes.evaluation_check_absences(context.Notes, evaluation_id=e2["evaluation_id"]) + +# --- Liste de note d'une évaluation + +#lien = context.Notes.do_evaluation_listnotes(REQUEST=REQUEST) +#print (lien) pb avec les arguments. + + +cal = sco_evaluations.formsemestre_evaluations_cal(context.Notes, formsemestre_id=sem["formsemestre_id"], REQUEST=REQUEST) +#html + +delai = sco_evaluations.formsemestre_evaluations_delai_correction(context.Notes, formsemestre_id=sem["formsemestre_id"], format="json", REQUEST=REQUEST) +#html + +lio = sco_undo_notes.evaluation_list_operations(context.Notes, evaluation_id=e["evaluation_id"], REQUEST=REQUEST) +#html + + +# --- Supression de toutes les notes d'une évaluations + +etat = sco_evaluations.do_evaluation_etat(context.Notes, e2["evaluation_id"]) +assert etat["evalcomplete"] +sco_saisie_notes.evaluation_suppress_alln(context.Notes, e2["evaluation_id"], REQUEST=REQUEST) +etat2 = sco_evaluations.do_evaluation_etat(context.Notes, e2["evaluation_id"]) + +#assert not etat2["evalcomplete"] rien ne se passe... + +# --- Modification d'une évaluation + +context.Notes.do_evaluation_edit(REQUEST=REQUEST, args={"evaluation_id" : e5, "coefficient": 2.0 , +"description" : "modification", "note_max" : 20, +"heure_debut" : "8h0", "heure_fin" : "10h0", "jour" : "03/02/2021"}) +new_eval5 = context.Notes.do_evaluation_list({"evaluation_id" : e5})[0] + +assert new_eval5["description"] == "modification" +assert new_eval5["jour"] == "03/02/2021" +assert new_eval5["heure_debut"] == "08h00" +assert new_eval5["heure_fin"] == "10h00" +assert new_eval5["coefficient"] == 2.0 + +# --- Supression d'une évaluation + +e7 = G.create_evaluation( + moduleimpl_id=mi["moduleimpl_id"], + jour="7/01/2021", + description="evaluation test 7", + coefficient=1.0, +) + +lie = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem["formsemestre_id"]) +assert len(lie) == 5 + +#context.Notes.evaluation_delete(REQUEST=REQUEST, evaluation_id=e7) rien ne se passe +sco_evaluations.do_evaluation_delete(context.Notes, REQUEST=REQUEST, evaluation_id=e7["evaluation_id"]) +lie2 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem["formsemestre_id"]) +assert len(lie2) == 4 diff --git a/scotests/test_evaluation_suppress_alln.py b/scotests/test_evaluation_suppress_alln.py new file mode 100755 index 00000000..5e140020 --- /dev/null +++ b/scotests/test_evaluation_suppress_alln.py @@ -0,0 +1,70 @@ +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_saisie_notes +import sco_evaluations + + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants +etuds = [G.create_etud(code_nip=None) for _ in range(10)] + +# --- Création d'une formation et de deux UE +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"], + 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 +) + + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + +# --- Inscription des étudiants +for etud in etuds: + G.inscrit_etudiant(sem, etud) + +# --- Création d'une évaluation +e = G.create_evaluation( + moduleimpl_id=mi["moduleimpl_id"], + jour="7/01/2021", + description="evaluation test 1", + coefficient=1.0, +) + +# --- Saisie des notes +for etud in etuds: + nb_changed, nb_suppress, existing_decisions = G.create_note( + evaluation=e, etud=etud, note=float(random.randint(0, 20)) + ) + +etat = sco_evaluations.do_evaluation_etat(context.Notes, e["evaluation_id"]) +assert etat["evalcomplete"] + +# --- Suppression des notes +sco_saisie_notes.evaluation_suppress_alln(context.Notes, e["evaluation_id"], REQUEST=REQUEST) +etat = sco_evaluations.do_evaluation_etat(context.Notes, e["evaluation_id"]) +assert not etat["evalcomplete"] + diff --git a/scotests/test_formations.py b/scotests/test_formations.py new file mode 100755 index 00000000..a3feb82d --- /dev/null +++ b/scotests/test_formations.py @@ -0,0 +1,321 @@ +""" Créer 2 formations, une test et une normale. Créer 2 semestres dans la formation normale et un +dans la formation test, créer 2 semestres dans la formation normale (un test et un normal), +2 ue (un test et un normal), 2 modules (un test et un normal) et 2 matieres (test et normal). + Et dans la formations test, un semestre, un module, un ue et une matiere. + Afficher la liste de tout ca puis supprimer les ue, mod, mat et sem test ainsi + que la formation test. Afficher la liste des UE, formations et modules restante. + + Vérification : + + - Les listes initiales comprennent bien tout les éléments créés avec les bon noms etc + - La supression s'est bien effectué au niveau de scodoc web et en python + - Vérifier que les fonctions listes font bien la mise à jour après supression + +Fonction de l'API utilisé : + +- create_formation +- create_ue +- create_matiere +- create_module +- create_formsemestre +- create_moduleimpl +- formation_list +- formation_export +- formsemestre_list +- do_moduleimpl_list +- do_module_impl_with_module_list +- do_formsemestre_delete +- do_module_list +- do_module_delete +- do_matiere_list +- do_matiere_delete +- do_ue_list +- do_ue_delete +- do_formation_delete + + + """ + + +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_formsemestre_status +import ZNotes +import sco_formations +import sco_moduleimpl +import sco_edit_ue +import sco_edit_matiere +import sco_edit_module +import sco_formsemestre_edit + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création de formations + +f = 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"], + 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 +) + +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"], + 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 +) + +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"], + 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 +) + + +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"], + 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 +) + +# --- Création et implémentation des semestres + +sem1 = G.create_formsemestre( + formation_id=f["formation_id"], + semestre_id=1, + date_debut="01/01/2021", + date_fin="30/06/2021", +) + +sem2 = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + +mi2 = G.create_moduleimpl( + module_id=mod2["module_id"], + formsemestre_id=sem1["formsemestre_id"], + responsable_id="bach", +) + +mit = G.create_moduleimpl( + module_id=modt["module_id"], + formsemestre_id=sem2["formsemestre_id"], + responsable_id="bach", +) + +semt = G.create_formsemestre( + formation_id=f2["formation_id"], + 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"], + responsable_id="bach", +) + +# --- Affichier la liste des formations + +lif = context.Notes.formation_list(format="json", REQUEST=REQUEST, formation_id=f["formation_id"]) + +load_lif = json.loads(lif) +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]["titre"] == f["titre"] + +lif2 = context.Notes.formation_list(format = 'json', REQUEST=REQUEST) + +load_lif2 = json.loads(lif2) +assert len(load_lif2) == 2 +assert load_lif2[0] == load_lif[0] +assert load_lif2[1]["titre"] == f2["titre"] + + +# --- Export de formation_id + +exp = sco_formations.formation_export(context.Notes, formation_id=f["formation_id"], format="json", REQUEST=REQUEST) + +load_exp = json.loads(exp) + +assert load_exp["acronyme"] == "F1" +assert load_exp["titre_officiel"] == "Titre officiel 1" +assert load_exp["titre"] == "Formation 1" +assert load_exp["formation_code"] == f["formation_code"] +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_code"] == f["formation_code"] + + +# --- Liste des semestres + +li_sem1 = context.Notes.formsemestre_list(formsemestre_id=sem1["formsemestre_id"], format = "json", REQUEST=REQUEST) +load_li_sem1 = json.loads(li_sem1) #uniquement le semestre 1 dans la liste + +assert len(load_li_sem1) == 1 +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 = context.Notes.formsemestre_list(formation_id=f["formation_id"], format = "json", REQUEST=REQUEST) +load_li_semf = json.loads(li_semf) + +assert load_li_sem1[0] in load_li_semf +assert len(load_li_semf) == 2 +assert load_li_semf[1]["semestre_id"] == sem2["semestre_id"] + + +li_sem = context.Notes.formsemestre_list(format = "json", REQUEST=REQUEST) +load_li_sem = json.loads(li_sem) + +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.do_moduleimpl_list(context.Notes, formsemestre_id=sem1["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem1 = json.loads(lim_sem1) + + +assert len(load_lim_sem1) == 2 +assert mod["module_id"] == load_lim_sem1[0]["module_id"] or load_lim_sem1[1]["module_id"] +assert mod2["module_id"] == load_lim_sem1[0]["module_id"] or load_lim_sem1[1]["module_id"] + +lim_modid = sco_moduleimpl.do_moduleimpl_list(context.Notes, module_id=mod["module_id"], REQUEST=REQUEST) +load_lim_modid = json.loads(lim_modid) #Liste avec seulement mod + +assert len(load_lim_modid) == 1 + +lim_modimpl_id = sco_moduleimpl.do_moduleimpl_list(context.Notes, moduleimpl_id=mi["moduleimpl_id"], REQUEST=REQUEST) +print(lim_modimpl_id) + +# ---- Test de do_moduleimpl_withmodule_list + +assert lim_modid == lim_modimpl_id #doit etre le meme resultat + +liimp_sem1 = sco_moduleimpl.do_moduleimpl_withmodule_list(context.Notes, formsemestre_id=sem1["formsemestre_id"], REQUEST=REQUEST) +load_liimp_sem1 = json.loads(liimp_sem1) + +assert len(load_liimp_sem1) == 2 +assert mod["module_id"] == load_liimp_sem1[0]["module_id"] or load_liimp_sem1[1]["module_id"] or load_liim_sem1[2]["module_id"] +assert mod2["module_id"] == load_liimp_sem1[0]["module_id"] or load_liimp_sem1[1]["module_id"] or load_liim_sem1[2]["module_id"] +assert modt["module_id"] == load_liimp_sem1[0]["module_id"] or load_liimp_sem1[1]["module_id"] or load_liim_sem1[2]["module_id"] + +liimp_modid = sco_moduleimpl.do_moduleimpl_withmodule_list(context.Notes, module_id=mod["module_id"], REQUEST=REQUEST) + +load_liimp_modid = json.loads(liimp_modid) +assert len(load_liimp_modid) == 1 + +liimp_modimplid = sco_moduleimpl.do_moduleimpl_withmodule_list(context.Notes, moduleimpl_id=mi["moduleimpl_id"], REQUEST=REQUEST) + +assert liimp_modid == liimp_modimplid + + +# --- Suppression du module, matiere et ue test du semestre 2 + +#on doit d'abbord supprimer le semestre + +#sco_formsemestre_edit.formsemestre_delete(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) +#sco_formsemestre_edit.formsemestre_delete2(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) + +# RIEN NE SE PASSE AVEC CES FONCTIONS + +sco_formsemestre_edit.do_formsemestre_delete(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) + +#sco_edit_module.module_delete(context.Notes, module_id=modt["module_id"], REQUEST=REQUEST) +#sco_edit_matiere.matiere_delete(context.Notes, matiere_id=matt["matiere_id"], REQUEST=REQUEST) +#sco_edit_ue.ue_delete(context.Notes, ue_id=uet["ue_id"], REQUEST=REQUEST) + +# RIEN NE SE PASSE AVEC CES FONCTIONS + + +li_module = context.Notes.do_module_list() +assert len(li_module) == 4 +context.Notes.do_module_delete(oid=modt["module_id"], REQUEST=REQUEST) #on supprime le semestre +#sco_formsemestre_edit.formsemestre_delete_moduleimpls(context.Notes, formsemestre_id=sem2["formsemestre_id"], module_ids_to_del=[modt["module_id"]]) +#deuxieme methode de supression d'un module +li_module2 = context.Notes.do_module_list() + +assert len(li_module2) == 3 #verification de la suppression du module + +lim_sem2 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem2 = json.loads(lim_sem2) + +assert len(load_lim_sem2) == 0 #deuxieme vérification si le module s'est bien sup + + +li_mat = context.Notes.do_matiere_list() +assert len(li_mat) == 4 +context.Notes.do_matiere_delete(oid=matt["matiere_id"], REQUEST=REQUEST) #on supprime la matiere +li_mat2 = context.Notes.do_matiere_list() +assert len(li_mat2) == 3 #verification de la suppression de la matiere + + +li_ue = context.Notes.do_ue_list() +assert len(li_ue) == 4 +sco_edit_ue.ue_delete(context.Notes, ue_id=uet["ue_id"], REQUEST=REQUEST) +li_ue2 = context.Notes.do_ue_list() +#assert len(li_ue) == 3 #verification de la suppression de l'UE #comment supprimer un ue? + + +# --- Suppression d'une formation + + +#Il faut d'abbord supprimer le semestre aussi. + +sco_formsemestre_edit.do_formsemestre_delete(context.Notes, formsemestre_id=semt["formsemestre_id"], REQUEST=REQUEST) + + +context.Notes.do_formation_delete(oid=f2["formation_id"], REQUEST=REQUEST) +lif3 = context.Notes.formation_list(format = 'json', REQUEST=REQUEST) + +load_lif3 = json.loads(lif3) +assert len(load_lif3) == 1 + + diff --git a/scotests/test_groupes.py b/scotests/test_groupes.py index 8ffa5d60..142faf4e 100755 --- a/scotests/test_groupes.py +++ b/scotests/test_groupes.py @@ -53,11 +53,12 @@ Fonctions de l’API utilisé : import random # La variable context est définie par le script de lancement -# l'affecte ainsi pour évietr les warnins pylint: +# l'affecte ainsi pour éviter les warnins pylint: context = context # pylint: disable=undefined-variable REQUEST = REQUEST # pylint: disable=undefined-variable import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error import sco_groups +import sco_groups_view G = sco_fake_gen.ScoFake(context.Notes) @@ -303,19 +304,31 @@ assert load_lijson_s1[0]["partition_name"] == "Eleve 1ere annee" -# --- Vue d'un groupes (liste d'élève en format json ou xml) +# --- Vue d'un groupes (liste d'élève en format json) +vue_g1 = sco_groups_view.groups_view(context.Scolarite, group_ids = [li_grp1[0]["group_id"]], format = "json", REQUEST=REQUEST) +load_vue_g1 = json.loads(vue_g1) +assert len(load_vue_g1) == 4 +assert load_vue_g1[0][li1[0]["partition_id"]] == li_grp1[0]["group_name"] +vue_sem = sco_groups_view.groups_view(context.Scolarite, formsemestre_id=sem1["formsemestre_id"], format = "json", REQUEST=REQUEST) +load_vue_sem = json.loads(vue_sem) +assert len(load_vue_sem) == 10 +tab=[] +val=False +for etud in etuds[:10] : + for i in range(len(load_vue_sem)) : + if etud["prenom"] == load_vue_sem[i]["prenom"] and etud["nom_disp"]==load_vue_sem[i]["nom_disp"] : + val = True + tab.append(val) + +assert not False in tab #tout mes etudiants sont present dans vue_sem. # --- Test des fonctions dans sco_groups -#_ = sco_groups.checkGroupName(li_grp1[0]["group_name"]) -#_ = sco_groups.checkGroupName("Groupe S1B") -#_ = sco_groups.checkGroupName("Groupe S3A") -#_ = sco_groups.checkGroupName("Groupe S3B") assert li_grp1[0] == sco_groups.get_group(context.Scolarite, li_grp1[0]["group_id"]) #test get_group diff --git a/scotests/test_scenario1_app.py b/scotests/test_scenario1_app.py new file mode 100755 index 00000000..1d88e9b1 --- /dev/null +++ b/scotests/test_scenario1_app.py @@ -0,0 +1,117 @@ +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants +etuds = [G.create_etud(code_nip=None) for _ in range(10)] + +# --- Création de l'utilisateur responsable du semestres, des modules etc.... + +arg = {"passwd": "scodocpass", "user_name" : "unutil", "roles" :"Ens,RespPe"} +user = context.Users.create_user(args=arg, REQUEST=REQUEST) +print(user) + +# --- Création formation et de deux UE +f = G.create_formation(acronyme="") +ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") +mat11 = G.create_matiere(ue_id=ue["ue_id"], titre="matière test") +mod11 = G.create_module( + matiere_id=mat11["matiere_id"], + code="TSM11", + coefficient=1.0, + titre="module test11", + ue_id=ue["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +mat12 = G.create_matiere(ue_id=ue["ue_id"], titre="matière test12") +mod12 = G.create_module( + matiere_id=mat12["matiere_id"], + code="TSM12", + coefficient=1.0, + titre="module test12", + ue_id=ue["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + + +ue2 = G.create_ue(formation_id=f["formation_id"], acronyme="TST2", titre="ue test2") +mat21 = G.create_matiere(ue_id=ue2["ue_id"], titre="matière test21") +mod21 = G.create_module( + matiere_id=mat21["matiere_id"], + code="TSM21", + coefficient=1.0, + titre="module test21", + ue_id=ue2["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +mat22 = G.create_matiere(ue_id=ue2["ue_id"], titre="matière test22") +mod22 = G.create_module( + matiere_id=mat22["matiere_id"], + code="TSM22", + coefficient=1.0, + titre="module test22", + ue_id=ue2["ue_id"], # faiblesse de l'API + formation_id=f["formation_id"], # faiblesse de l'API +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["formation_id"], + semestre_id=1, + date_debut="01/01/2021", + date_fin="30/06/2021", +) + +mods = [] +for module_id, formsemestre_id, responsable_id in [ + (mod11["module_id"], sem["formsemestre_id"], "bach"), + (mod12["module_id"], sem["formsemestre_id"], "bach"), + (mod21["module_id"], sem["formsemestre_id"], "bach"), + (mod22["module_id"], sem["formsemestre_id"], "bach") +] : + mi = G.create_moduleimpl(module_id=module_id, formsemestre_id=formsemestre_id, responsable_id=responsable_id) + mods.append(mi) + + +# --- Inscription des étudiants +for etud in etuds: + G.inscrit_etudiant(sem, etud) + + +# --- Création d'évaluations (2 par modules) + +evals=[] + +for moduleimpl_id, jour, description, coefficient in [ + (mods[0]["moduleimpl_id"], "01/02/2021", "e1", 1.0), + (mods[0]["moduleimpl_id"], "02/02/2021", "e2", 1.0), + (mods[1]["moduleimpl_id"], "03/02/2021", "e3", 1.0), + (mods[1]["moduleimpl_id"], "04/02/2021", "e4", 1.0), + (mods[2]["moduleimpl_id"], "05/02/2021", "e5", 1.0), + (mods[2]["moduleimpl_id"], "06/02/2021", "e6", 1.0), + (mods[3]["moduleimpl_id"], "07/02/2021", "e7", 1.0), + (mods[3]["moduleimpl_id"], "08/02/2021", "e8", 1.0), +] : + e = G.create_evaluation(moduleimpl_id=moduleimpl_id, jour=jour, description=description, coefficient=coefficient) + evals.append(e) + + +# --- Saisie des notes aléatoires + +for eval in evals : + for etud in etuds: + nb_changed, nb_suppress, existing_decisions = G.create_note( + evaluation=eval, etud=etud, note=float(random.randint(0, 20)) + ) + + + + diff --git a/scotests/test_scenario1_formation.py b/scotests/test_scenario1_formation.py new file mode 100755 index 00000000..6adf1bd8 --- /dev/null +++ b/scotests/test_scenario1_formation.py @@ -0,0 +1,72 @@ +import sco_formations +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_moduleimpl + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +file = open("scotests/export_formation1.xml") +doc = file.read() +file.close() + + +# --- Création de la formation + +f = sco_formations.formation_import_xml(REQUEST=REQUEST, doc=doc, context=context.Notes) + +# --- Création des semestres + +sem1 = G.create_formsemestre( + formation_id=f[0], + semestre_id=1, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem3 = G.create_formsemestre( + formation_id=f[0], + semestre_id=3, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem2 = G.create_formsemestre( + formation_id=f[0], + semestre_id=2, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + +sem4 = G.create_formsemestre( + formation_id=f[0], + semestre_id=4, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + + +# --- Implémentation des modules + +li_module = context.Notes.do_module_list() +mods_imp = [] +for mod in li_module : + if mod["semestre_id"] == 1 : + formsemestre_id = sem1["formsemestre_id"] + elif mod["semestre_id"] == 2 : + formsemestre_id = sem2["formsemestre_id"] + elif mod["semestre_id"] == 3 : + formsemestre_id = sem3["formsemestre_id"] + else : + formsemestre_id = sem4["formsemestre_id"] + + mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=formsemestre_id, + responsable_id="bach", + ) + mods_imp.append(mi) \ No newline at end of file diff --git a/scotests/test_scenario2_formation.py b/scotests/test_scenario2_formation.py new file mode 100755 index 00000000..4a77544a --- /dev/null +++ b/scotests/test_scenario2_formation.py @@ -0,0 +1,105 @@ +import sco_formations +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_moduleimpl + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +file = open("scotests/export_formation1.xml") +doc = file.read() +file.close() + + +# --- Création de la formation + +f = sco_formations.formation_import_xml(REQUEST=REQUEST, doc=doc, context=context.Notes) + +# --- Création des semestres + +sem1 = G.create_formsemestre( + formation_id=f[0], + semestre_id=1, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem3 = G.create_formsemestre( + formation_id=f[0], + semestre_id=3, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem2 = G.create_formsemestre( + formation_id=f[0], + semestre_id=2, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + +sem4 = G.create_formsemestre( + formation_id=f[0], + semestre_id=4, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + + +# --- Implémentation des modules + +li_module = context.Notes.do_module_list() +mods_imp = [] +for mod in li_module : + if mod["semestre_id"] == 1 : + formsemestre_id = sem1["formsemestre_id"] + elif mod["semestre_id"] == 2 : + formsemestre_id = sem2["formsemestre_id"] + elif mod["semestre_id"] == 3 : + formsemestre_id = sem3["formsemestre_id"] + else : + formsemestre_id = sem4["formsemestre_id"] + + mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=formsemestre_id, + responsable_id="bach", + ) + mods_imp.append(mi) + +# --- Création des étudiants + +etuds=[] +for nom, prenom in [ + ("Semestre1", "EtudiantNumero1"), + ("Semestre1", "EtudiantNumero2"), + ("Semestre2", "EtudiantNumero3"), + ("Semestre2", "EtudiantNumero4"), + ("Semestre3", "EtudiantNumero5"), + ("Semestre3", "EtudiantNumero6"), + ("Semestre4", "EtudiantNumero7"), + ("Semestre4", "EtudiantNumero8") +] : + etud = G.create_etud( + nom=nom, + prenom=prenom, + ) + etuds.append(etud) + +# --- Inscription des étudiants + +for etud in etuds[0:2]: + G.inscrit_etudiant(sem1, etud) + +for etud in etuds[2:4]: + G.inscrit_etudiant(sem2, etud) + +for etud in etuds[4:6]: + G.inscrit_etudiant(sem3, etud) + +for etud in etuds[6:]: + G.inscrit_etudiant(sem4, etud) \ No newline at end of file diff --git a/scotests/test_scenario3_formation.py b/scotests/test_scenario3_formation.py new file mode 100755 index 00000000..83f6b212 --- /dev/null +++ b/scotests/test_scenario3_formation.py @@ -0,0 +1,135 @@ +import sco_formations +import json +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_moduleimpl + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +file = open("scotests/export_formation1.xml") +doc = file.read() +file.close() + + +# --- Création de la formation + +f = sco_formations.formation_import_xml(REQUEST=REQUEST, doc=doc, context=context.Notes) + +# --- Création des semestres + +sem1 = G.create_formsemestre( + formation_id=f[0], + semestre_id=1, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem3 = G.create_formsemestre( + formation_id=f[0], + semestre_id=3, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem2 = G.create_formsemestre( + formation_id=f[0], + semestre_id=2, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + +sem4 = G.create_formsemestre( + formation_id=f[0], + semestre_id=4, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + + +# --- Implémentation des modules + +li_module = context.Notes.do_module_list() +mods_imp = [] +for mod in li_module : + if mod["semestre_id"] == 1 : + formsemestre_id = sem1["formsemestre_id"] + elif mod["semestre_id"] == 2 : + formsemestre_id = sem2["formsemestre_id"] + elif mod["semestre_id"] == 3 : + formsemestre_id = sem3["formsemestre_id"] + else : + formsemestre_id = sem4["formsemestre_id"] + + mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=formsemestre_id, + responsable_id="bach", + ) + mods_imp.append(mi) + +# --- Création des étudiants + +etuds=[] +for nom, prenom in [ + ("Semestre1", "EtudiantNumero1"), + ("Semestre1", "EtudiantNumero2"), + ("Semestre2", "EtudiantNumero3"), + ("Semestre2", "EtudiantNumero4"), + ("Semestre3", "EtudiantNumero5"), + ("Semestre3", "EtudiantNumero6"), + ("Semestre4", "EtudiantNumero7"), + ("Semestre4", "EtudiantNumero8") +] : + etud = G.create_etud( + nom=nom, + prenom=prenom, + ) + etuds.append(etud) + +# --- Inscription des étudiants + +for etud in etuds[0:2]: + G.inscrit_etudiant(sem1, etud) + +for etud in etuds[2:4]: + G.inscrit_etudiant(sem2, etud) + +for etud in etuds[4:6]: + G.inscrit_etudiant(sem3, etud) + +for etud in etuds[6:]: + G.inscrit_etudiant(sem4, etud) + +# --- Création d'une évaluation pour chaque UE + +lim_sem1 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem1["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem1 = json.loads(lim_sem1) + +lim_sem2 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem2 = json.loads(lim_sem2) + +lim_sem3 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem3["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem3 = json.loads(lim_sem3) + +lim_sem4 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem4["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem4 = json.loads(lim_sem4) + + +for moduleimpl_id, jour, description, coefficient in [ + (load_lim_sem1[1]["moduleimpl_id"], "02/09/2020", "InterroTestSemestre1", 1.0), + (load_lim_sem1[2]["moduleimpl_id"], "03/09/2020", "InterroTestSemestre1", 1.0), + (load_lim_sem2[1]["moduleimpl_id"], "03/02/2021", "InterroTestSemestre2", 1.0), + (load_lim_sem2[8]["moduleimpl_id"], "04/02/2021", "InterroTestSemestre2", 1.0), + (load_lim_sem3[3]["moduleimpl_id"], "02/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem3[9]["moduleimpl_id"], "03/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem3[15]["moduleimpl_id"], "04/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem4[3]["moduleimpl_id"], "03/02/2021", "InterroTestSemestre4", 1.0), + (load_lim_sem4[9]["moduleimpl_id"], "04/02/2021", "InterroTestSemestre4", 1.0), + (load_lim_sem4[13]["moduleimpl_id"], "05/02/2021", "InterroTestSemestre4", 1.0), +] : + e = G.create_evaluation(moduleimpl_id=moduleimpl_id, jour=jour, description=description, coefficient=coefficient) \ No newline at end of file diff --git a/scotests/test_scenario4_formation.py b/scotests/test_scenario4_formation.py new file mode 100755 index 00000000..b690022a --- /dev/null +++ b/scotests/test_scenario4_formation.py @@ -0,0 +1,172 @@ +import sco_formations +import json +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_moduleimpl + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +file = open("scotests/export_formation1.xml") +doc = file.read() +file.close() + + +# --- Création de la formation + +f = sco_formations.formation_import_xml(REQUEST=REQUEST, doc=doc, context=context.Notes) + +# --- Création des semestres + +sem1 = G.create_formsemestre( + formation_id=f[0], + semestre_id=1, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem3 = G.create_formsemestre( + formation_id=f[0], + semestre_id=3, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem2 = G.create_formsemestre( + formation_id=f[0], + semestre_id=2, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + +sem4 = G.create_formsemestre( + formation_id=f[0], + semestre_id=4, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + + +# --- Implémentation des modules + +li_module = context.Notes.do_module_list() +mods_imp = [] +for mod in li_module : + if mod["semestre_id"] == 1 : + formsemestre_id = sem1["formsemestre_id"] + elif mod["semestre_id"] == 2 : + formsemestre_id = sem2["formsemestre_id"] + elif mod["semestre_id"] == 3 : + formsemestre_id = sem3["formsemestre_id"] + else : + formsemestre_id = sem4["formsemestre_id"] + + mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=formsemestre_id, + responsable_id="bach", + ) + mods_imp.append(mi) + +# --- Création des étudiants + +etuds=[] +for nom, prenom in [ + ("Semestre1", "EtudiantNumero1"), + ("Semestre1", "EtudiantNumero2"), + ("Semestre2", "EtudiantNumero3"), + ("Semestre2", "EtudiantNumero4"), + ("Semestre3", "EtudiantNumero5"), + ("Semestre3", "EtudiantNumero6"), + ("Semestre4", "EtudiantNumero7"), + ("Semestre4", "EtudiantNumero8") +] : + etud = G.create_etud( + nom=nom, + prenom=prenom, + ) + etuds.append(etud) + +# --- Inscription des étudiants + +for etud in etuds[0:2]: + G.inscrit_etudiant(sem1, etud) + +for etud in etuds[2:4]: + G.inscrit_etudiant(sem2, etud) + +for etud in etuds[4:6]: + G.inscrit_etudiant(sem3, etud) + +for etud in etuds[6:]: + G.inscrit_etudiant(sem4, etud) + +# --- Création d'une évaluation pour chaque UE + +lim_sem1 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem1["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem1 = json.loads(lim_sem1) + +lim_sem2 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem2 = json.loads(lim_sem2) + +lim_sem3 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem3["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem3 = json.loads(lim_sem3) + +lim_sem4 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem4["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem4 = json.loads(lim_sem4) + + +for moduleimpl_id, jour, description, coefficient in [ + (load_lim_sem1[1]["moduleimpl_id"], "02/09/2020", "InterroTestSemestre1", 1.0), + (load_lim_sem1[2]["moduleimpl_id"], "03/09/2020", "InterroTestSemestre1", 1.0), + (load_lim_sem2[1]["moduleimpl_id"], "03/02/2021", "InterroTestSemestre2", 1.0), + (load_lim_sem2[8]["moduleimpl_id"], "04/02/2021", "InterroTestSemestre2", 1.0), + (load_lim_sem3[3]["moduleimpl_id"], "02/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem3[9]["moduleimpl_id"], "03/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem3[15]["moduleimpl_id"], "04/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem4[3]["moduleimpl_id"], "03/02/2021", "InterroTestSemestre4", 1.0), + (load_lim_sem4[9]["moduleimpl_id"], "04/02/2021", "InterroTestSemestre4", 1.0), + (load_lim_sem4[13]["moduleimpl_id"], "05/02/2021", "InterroTestSemestre4", 1.0), +] : + e = G.create_evaluation(moduleimpl_id=moduleimpl_id, jour=jour, description=description, coefficient=coefficient) + + +# --- Saisie des notes des étudiants (un élève a 12, un autre a 7 pour chaque semestre) + +lie1 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem1["formsemestre_id"]) +lie2 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem2["formsemestre_id"]) +lie3 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem3["formsemestre_id"]) +lie4 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem4["formsemestre_id"]) + +for eval in lie1 : + for etud in etuds[:2] : + if etud == etuds[0] : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=12.0) + else : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=7.0) + +for eval in lie2 : + for etud in etuds[2:4] : + if etud == etuds[2] : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=12.0) + else : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=7.0) + + +for eval in lie3 : + for etud in etuds[4:6] : + if etud == etuds[4] : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=12.0) + else : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=7.0) + +for eval in lie4 : + for etud in etuds[6:] : + if etud == etuds[6] : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=12.0) + else : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=7.0) \ No newline at end of file diff --git a/scotests/test_user.py b/scotests/test_user.py new file mode 100755 index 00000000..00b47817 --- /dev/null +++ b/scotests/test_user.py @@ -0,0 +1,49 @@ +""" Créer un utilisateur, récupérer ses infos, + lister les utilisateurs, modifier le mdp, modfifier l'utilisateur (si possible), + changer d'admin, tester d'autre fonctionalités liés aux users """ + +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import ZScoUsers +import ZScoDoc +import ZScolar + + +nomdept = raw_input("Quel est le nom de votre département test? ATTENTION A NE PAS VOUS TROMPER : ") + +# --- Création d'un utilisateur + +arg = {"passwd": "scodocpass", "user_name" : "unutil", "nom" : "unnom", "prenom":"unprenom", "email": "unemail@mail.fr", "roles" :"Ens"+nomdept+",RespPe"+nomdept} +#user1 = context.Users.create_user(args=arg, REQUEST=REQUEST) +user_info1 = context.Users.user_info(user_name="unutil") + +assert user_info1["email"] == arg["email"] +assert user_info1["user_name"] == arg["user_name"] +assert user_info1["nom"] == "unnom" +assert user_info1["prenom"] == "unprenom" +assert user_info1["roles"] == arg["roles"] + + +# --- Récupération de la liste des Users + +liste_xml = context.Users.get_userlist_xml(REQUEST=REQUEST) + +liste_user = context.Users.get_userlist() +len_liu1 = len(liste_user) + +assert user_info1 in liste_user #le nouvel utilisateur est bien dans la liste ! + +# --- Changement du mot de passe de l'utilisateur + +#context.Users.change_password(user_name="unutil", password=) + +context.Users.do_change_password(user_name="unutil", password="scodocpass2") +#vérification du mdp changé directement sur scodoc web car je ne trouve pas comment récupérer le mdp en python +#Vérification : ok! + + + diff --git a/static/formation_export.json b/static/formation_export.json new file mode 100755 index 00000000..1c13dc0b --- /dev/null +++ b/static/formation_export.json @@ -0,0 +1,1352 @@ +{ + "acronyme": "DUT Info", + "code_specialite": "", + "type_parcours": 100, + "titre_officiel": "DUT Informatique", + "formation_code": "FCOD2", + "version": 1, + "ue": [ + { + "acronyme": "UE11", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architecture mat\u00e9rielle - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M1101", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 30.0, + "abbrev": "", + "numero": 1, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction aux syst\u00e8mes informatiques", + "heures_td": 20.0 + } + ], + "numero": 1 + }, + { + "titre": "Algorithmique - Programmation - Langages", + "module": [ + { + "coefficient": 2.0, + "code": "M1102", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 30.0, + "abbrev": "Algorithmique", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction \u00e0 l\u2019algorithmique et \u00e0 la programmation", + "heures_td": 20.0 + } + ], + "numero": 2 + }, + { + "titre": "Algorithmique - Programmation - Langages Avanc\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M1103", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "Structure de donn\u00e9es", + "numero": 3, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Structure de donn\u00e9es et algorithmes fondamentaux", + "heures_td": 15.0 + } + ], + "numero": 3 + }, + { + "titre": "Syst\u00e8mes de gestion de bases de donn\u00e9es", + "module": [ + { + "coefficient": 3.0, + "code": "M1104", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 25.0, + "abbrev": "BDD", + "numero": 4, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction aux bases de donn\u00e9es", + "heures_td": 25.0 + } + ], + "numero": 4 + }, + { + "titre": "Web - Internet - Mobilit\u00e9 Expression - Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M1105", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 25.0, + "abbrev": "CDIN", + "numero": 5, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Conception de documents et d\u2019interfaces num\u00e9riques", + "heures_td": 20.0 + } + ], + "numero": 5 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M1106", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "Projet", + "numero": 6, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 : d\u00e9couverte", + "heures_td": 0.0 + } + ], + "numero": 6 + } + ], + "ue_code": "UE11", + "numero": 1, + "titre": "Base de l'informatique", + "type": 0 + }, + { + "acronyme": "UE21", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architecture mat\u00e9rielle - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M2101", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Architecture et Programmation des m\u00e9canismes de base d\u2019un syst\u00e8me informatique", + "heures_td": 10.0 + } + ], + "numero": 1 + }, + { + "titre": "Architecture mat\u00e9rielle - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux avanc\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M2102", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Architecture des r\u00e9seaux", + "heures_td": 10.0 + } + ], + "numero": 2 + }, + { + "titre": "Algorithmique - Programmation - Langages Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M2103", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 30.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Bases de la programmation orient\u00e9e objet", + "heures_td": 20.0 + } + ], + "numero": 3 + }, + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M2104", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "COO", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Bases de la conception orient\u00e9e objet", + "heures_td": 15.0 + } + ], + "numero": 4 + }, + { + "titre": "Interface homme-machine", + "module": [ + { + "coefficient": 2.0, + "code": "M2105", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Introduction aux interfaces homme-machine", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Syst\u00e8mes de gestion de bases de donn\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M2106", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 20.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Programmation et administration des bases de donn\u00e9es", + "heures_td": 15.0 + } + ], + "numero": 6 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M2107", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 : Description et planification de projet", + "heures_td": 0.0 + } + ], + "numero": 7 + } + ], + "ue_code": "UE21", + "numero": 1, + "titre": "Informatique approfondie", + "type": 0 + }, + { + "acronyme": "UE31", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M3101", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 16.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Principes des syst\u00e8mes d\u2019exploitation", + "heures_td": 14.0 + } + ], + "numero": 1 + }, + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation, R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M3102", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Services r\u00e9seaux", + "heures_td": 10.0 + } + ], + "numero": 2 + }, + { + "titre": "Algorithmique - Programmation - Langages avanc\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M3103", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Algorithmique avanc\u00e9e", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Web - Internet - Mobilit\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M3104", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 16.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Programmation Web c\u00f4t\u00e9 serveur", + "heures_td": 14.0 + } + ], + "numero": 4 + }, + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 16.0, + "code": "M3105", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 14.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Conception et programmation objet avanc\u00e9es", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Syst\u00e8mes de gestion de bases de donn\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M3106C", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Bases de donn\u00e9es avanc\u00e9es", + "heures_td": 10.0 + } + ], + "numero": 6 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS1", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 16 + } + ], + "ue_code": "UCOD5", + "numero": 1, + "titre": "Informatique avanc\u00e9e", + "type": 0 + }, + { + "acronyme": "UE41", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation - R\u00e9seaux", + "module": [ + { + "coefficient": 2.0, + "code": "M4101C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Administration syst\u00e8me et r\u00e9seau", + "heures_td": 10.0 + } + ], + "numero": 1 + }, + { + "titre": "Architectures mat\u00e9rielles - Syst\u00e8mes d\u2019exploitation \u2013 R\u00e9seaux Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M4102C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Programmation r\u00e9partie", + "heures_td": 10.0 + } + ], + "numero": 2 + }, + { + "titre": "Web \u2013 Internet - Mobilit\u00e9", + "module": [ + { + "coefficient": 2.0, + "code": "M4103C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Programmation Web \u2013 client riche", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Web - Internet - Mobilit\u00e9 - Mobile", + "module": [ + { + "coefficient": 3.0, + "code": "M4104C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Conception et d\u00e9veloppement d\u2019applications mobiles", + "heures_td": 10.0 + } + ], + "numero": 4 + }, + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M4105C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Compl\u00e9ments d\u2019informatique en vue d\u2019une insertion imm\u00e9diate", + "heures_td": 10.0 + } + ], + "numero": 5 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M4106", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 \u2013 Compl\u00e9ments", + "heures_td": 0.0 + } + ], + "numero": 6 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS1", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 16 + } + ], + "ue_code": "UCOD8", + "numero": 1, + "titre": "Compl\u00e9ments en informatique", + "type": 0 + }, + { + "acronyme": "UE12", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M1201", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 17.0, + "abbrev": "", + "numero": 1, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Math\u00e9matiques discr\u00e8tes", + "heures_td": 18.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques avanc\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M1202", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 12.0, + "abbrev": "", + "numero": 10, + "heures_cours": 6.0, + "module_type": 0, + "titre": "Alg\u00e8bre lin\u00e9aire", + "heures_td": 12.0 + } + ], + "numero": 2 + }, + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M1203", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Environnement \u00e9conomique", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Organisation", + "module": [ + { + "coefficient": 1.0, + "code": "M1204", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Fonctionnement des organisations", + "heures_td": 20.0 + } + ], + "numero": 4 + }, + { + "titre": "Expression - Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M1205", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Fondamentaux de la communication", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M1206", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Anglais et Informatique", + "heures_td": 15.0 + } + ], + "numero": 6 + }, + { + "titre": "PPP Expression - Communication", + "module": [ + { + "coefficient": 1.0, + "code": "M1207", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Conna\u00eetre le monde professionnel", + "heures_td": 10.0 + } + ], + "numero": 7 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 1, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 17 + } + ], + "ue_code": "UE12", + "numero": 2, + "titre": "Bases de culture scientifique, sociale et humaine", + "type": 0 + }, + { + "acronyme": "UE22", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M2201", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 18.0, + "abbrev": "", + "numero": 10, + "heures_cours": 11.0, + "module_type": 0, + "titre": "Graphes et langages", + "heures_td": 16.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques avanc\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M2202", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Analyse et m\u00e9thodes num\u00e9riques", + "heures_td": 12.0 + } + ], + "numero": 2 + }, + { + "titre": "\u00c9conomie - Gestion - Droit - Organisation", + "module": [ + { + "coefficient": 2.0, + "code": "M2203", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 12.0, + "module_type": 0, + "titre": "Environnement comptable, financier, juridique et social", + "heures_td": 18.0 + } + ], + "numero": 3 + }, + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit Analyse, conception et d\u00e9veloppement d\u2019applications", + "module": [ + { + "coefficient": 2.0, + "code": "M2204", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Gestion de projet informatique", + "heures_td": 12.0 + } + ], + "numero": 4 + }, + { + "titre": "Expression - Communication", + "module": [ + { + "coefficient": 1.0, + "code": "M2205", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communication, information et argumentation", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M2206", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 22.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communiquer en anglais", + "heures_td": 23.0 + } + ], + "numero": 6 + }, + { + "titre": "PPP", + "module": [ + { + "coefficient": 1.0, + "code": "M2207", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "PPP - Identifier ses comp\u00e9tences", + "heures_td": 10.0 + } + ], + "numero": 7 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 2, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 17 + } + ], + "ue_code": "UCOD4", + "numero": 2, + "titre": "Approfondissements en culture scientifique, sociale et humaine", + "type": 0 + }, + { + "acronyme": "UE32", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M3201", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 14.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Probabilit\u00e9s et statistique", + "heures_td": 16.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques avanc\u00e9es", + "module": [ + { + "coefficient": 2.0, + "code": "M3202C", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 14.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Mod\u00e9lisations math\u00e9matiques", + "heures_td": 16.0 + } + ], + "numero": 2 + }, + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M3203", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 10.0, + "module_type": 0, + "titre": "Droit des technologies de l\u2019information et de la communication", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Gestion", + "module": [ + { + "coefficient": 2.0, + "code": "M3204", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 15.0, + "module_type": 0, + "titre": "Gestion des syst\u00e8mes d\u2019information", + "heures_td": 15.0 + } + ], + "numero": 4 + }, + { + "titre": "Expression - Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M3205", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communication professionnelle", + "heures_td": 15.0 + } + ], + "numero": 5 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M3206", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 22.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Collaborer en anglais", + "heures_td": 23.0 + } + ], + "numero": 6 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 16 + } + ], + "ue_code": "UCOD6", + "numero": 2, + "titre": "Culture scientifique, sociale et humaine avanc\u00e9es", + "type": 0 + }, + { + "acronyme": "UE33", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "Analyse, conception et d\u00e9veloppement d\u2019applications \u00c9conomie - gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M3301", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 24.0, + "abbrev": "", + "numero": 10, + "heures_cours": 14.0, + "module_type": 0, + "titre": "M\u00e9thodologie de la production d\u2019applications", + "heures_td": 22.0 + } + ], + "numero": 1 + }, + { + "titre": "Projets tutor\u00e9s", + "module": [ + { + "coefficient": 3.0, + "code": "M3302", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Projet tutor\u00e9 - Mise en situation professionnelle", + "heures_td": 0.0 + } + ], + "numero": 2 + }, + { + "titre": "PPP", + "module": [ + { + "coefficient": 2.0, + "code": "M3303", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "PPP - Pr\u00e9ciser son projet", + "heures_td": 10.0 + } + ], + "numero": 3 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 3, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 13 + } + ], + "ue_code": "UCOD7", + "numero": 2, + "titre": "M\u00e9thodologie et projets", + "type": 0 + }, + { + "acronyme": "UE42", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "\u00c9conomie - Gestion - Organisation - Droit", + "module": [ + { + "coefficient": 2.0, + "code": "M4201C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Ateliers de cr\u00e9ation d\u2019entreprise", + "heures_td": 12.0 + } + ], + "numero": 1 + }, + { + "titre": "Math\u00e9matiques", + "module": [ + { + "coefficient": 2.0, + "code": "M4202C", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 10.0, + "abbrev": "", + "numero": 10, + "heures_cours": 8.0, + "module_type": 0, + "titre": "Introduction \u00e0 la recherche op\u00e9rationnelle et aide \u00e0 la d\u00e9cision", + "heures_td": 12.0 + } + ], + "numero": 2 + }, + { + "titre": "Expression \u2013 Communication", + "module": [ + { + "coefficient": 2.0, + "code": "M4203", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Communication dans les organisations", + "heures_td": 15.0 + } + ], + "numero": 3 + }, + { + "titre": "Anglais", + "module": [ + { + "coefficient": 2.0, + "code": "M4204", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 15.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Travailler en anglais", + "heures_td": 15.0 + } + ], + "numero": 4 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS2", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 14 + } + ], + "ue_code": "UCOD9", + "numero": 2, + "titre": "Compl\u00e9ments de culture scientifique, sociale et humaine", + "type": 0 + }, + { + "acronyme": "UE43", + "coefficient": 0.0, + "is_external": 0, + "code_apogee": "", + "matiere": [ + { + "titre": "STAGE", + "module": [ + { + "coefficient": 12.0, + "code": "M4301", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 10, + "heures_cours": 0.0, + "module_type": 0, + "titre": "Stage professionnel", + "heures_td": 0.0 + } + ], + "numero": 1 + }, + { + "titre": "Malus", + "module": [ + { + "coefficient": 0.0, + "code": "MALUS3", + "semestre_id": 4, + "code_apogee": "", + "ects": "", + "heures_tp": 0.0, + "abbrev": "", + "numero": 0, + "heures_cours": 0.0, + "module_type": 1, + "titre": "", + "heures_td": 0.0 + } + ], + "numero": 11 + } + ], + "ue_code": "UCOD10", + "numero": 3, + "titre": "Mise en situation professionnelle", + "type": 0 + } + ], + "titre": "DUT Informatique", + "formation_id": "FORM234" +} \ No newline at end of file From 01820b5a9112cf34712720d08083fa698d72baef Mon Sep 17 00:00:00 2001 From: root Date: Wed, 9 Jun 2021 19:21:58 +0200 Subject: [PATCH 5/9] ajout des commentaires --- scotests/test_abs_demijournee.py | 13 +++- scotests/test_absence.py | 48 +++++++++++-- scotests/test_etudiant1.py | 85 ++++++++++++++++------- scotests/test_evaluation.py | 30 ++++++-- scotests/test_evaluation_suppress_alln.py | 5 ++ scotests/test_formations.py | 4 +- scotests/test_groupes.py | 15 ++-- scotests/test_scenario4_formation.py | 1 + scotests/test_user.py | 29 ++++++-- 9 files changed, 178 insertions(+), 52 deletions(-) diff --git a/scotests/test_abs_demijournee.py b/scotests/test_abs_demijournee.py index 14c86b45..84582a24 100755 --- a/scotests/test_abs_demijournee.py +++ b/scotests/test_abs_demijournee.py @@ -1,3 +1,6 @@ +""" Parametre demijournee ne fonctionne pas lorsque demijournee = 2 +Créer et justifier des absences en utilisant le parametre demijournee +""" import random # La variable context est définie par le script de lancement @@ -103,4 +106,12 @@ _ = sco_abs_views.doJustifAbsence( a = sco_abs.getAbsSemEtud(context.Absences, sem, etudid) assert a.CountAbs() == 4 #l'étudiant a été absent le 15 journée compléte (2 abs : 1 matin, 1 apres midi) et le 18 (1 matin), et le 19 (1 apres midi). -assert a.CountAbsJust() == 2 # Justifie abs du matin + abs après midi \ No newline at end of file +assert a.CountAbsJust() == 2 # Justifie abs du matin + abs après midi + +""" +Commentaire : + +Pb : le 2 ne peut pas être pris en tant que int car string dans la fonction +-----> Pb regler + +""" \ No newline at end of file diff --git a/scotests/test_absence.py b/scotests/test_absence.py index 5a9ba1a3..6c2fdd92 100755 --- a/scotests/test_absence.py +++ b/scotests/test_absence.py @@ -1,5 +1,6 @@ -""" creation de 10 étudiants, formation, semestre, ue, module, absences le matin, l'apres midi, la journée compléte et justification -d'absences, supression d'absences, création d'une liste etat absences, creation d'un groupe afin de tester la fonction EtatAbsencesGroupes +""" creation de 10 étudiants, formation, semestre, ue, module, absences le matin, l'apres midi, la journée compléte +et justification d'absences, supression d'absences, création d'une liste etat absences, creation d'un groupe afin +de tester la fonction EtatAbsencesGroupes Fonctions de l'API utilisé : - doSignaleAbsence @@ -14,6 +15,9 @@ Fonctions de l'API utilisé : - partition_create - createGroup - set_group + - EtatAbsenceGr + - AddBilletAbsence + - listeBilletsEtud """ @@ -182,8 +186,6 @@ 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"] - - # absjust_only -> seulement les abs justifiés @@ -222,5 +224,43 @@ for un_etud in load_grp1_abs : assert un_etud["nbabsnonjust"] == "1" assert un_etud["nomprenom"] == etuds[0]["nomprenom"] +# --- Création de billets + +b1 = context.Absences.AddBilletAbsence( + begin="2021-01-22 00:00", + end="2021-01-22 23:59", + etudid=etudid, + description = "abs du 22", + justified=False, + code_nip=etuds[0]["code_nip"], + code_ine=etuds[0]["code_ine"], + REQUEST=REQUEST, + ) + +b2 = context.Absences.AddBilletAbsence( + begin="2021-01-15 00:00", + end="2021-01-15 23:59", + etudid=etudid, + description = "abs du 15", + code_nip=etuds[0]["code_nip"], + code_ine=etuds[0]["code_ine"], + REQUEST=REQUEST, + ) +li_bi = context.Absences.listeBilletsEtud(etudid=etudid, REQUEST=REQUEST, format="json") +load_li_bi = json.loads(li_bi) + +assert len(load_li_bi) == 2 +assert load_li_bi[1]["description"] == "abs du 22" + +""" +Commentaire : + +Parametre demijournee ne prend pas en compte les strings ---> pb régler. + +La suppression de justification ne peut pas se faire directement en interractif à l'aide de python. + +La fonction CountAbs ne met pas à jour le nombre après supression des absences. ---> (cf : test_CountAbs.py) + +""" \ No newline at end of file diff --git a/scotests/test_etudiant1.py b/scotests/test_etudiant1.py index cf2b4334..cb10fda6 100755 --- a/scotests/test_etudiant1.py +++ b/scotests/test_etudiant1.py @@ -1,20 +1,13 @@ -""" 3) Création d’étudiants, formation etc… Au cours de l’année un étudiant déménage et souhaite changer -ses informations personnelles. Un autre étudiant lui à changer de téléphone portable ainsi que d’adresse e-mail. -Changer les données - -Vérifier si les changements se sont effectués +""" Création de 2 étudiants, un qui demissionne, un autre defaillant + annuler demission et annuler défaillance Fonctions de l’API utilisé : -- create_formation -- create_ue -- create_module -- create_matiere -- create_formsemestre -- create_moduleimpl -- inscrit_etudiant -- etuds_info -- getEtudInfo -- identite_edit +- doDemEtudiant +- doDefEtudiant +- doCancelDem +- doCancelDef +- etud_info +- search_etud_in_dept +- fillEtudsInfo """ @@ -27,13 +20,14 @@ context = context # pylint: disable=undefined-variable REQUEST = REQUEST # pylint: disable=undefined-variable import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error import scolars +import sco_find_etud G = sco_fake_gen.ScoFake(context.Notes) G.verbose = False # --- Création d'étudiants -etud = G.create_etud( +etud1 = G.create_etud( code_nip="", nom="Poire", prenom="Kevin", @@ -55,6 +49,8 @@ etud = G.create_etud( description="etudiant test", ) +etud2 = G.create_etud() + # --- Création d'une formation f = G.create_formation(acronyme="") ue = G.create_ue(formation_id=f["formation_id"], acronyme="TST1", titre="ue test") @@ -82,17 +78,58 @@ mi = G.create_moduleimpl( responsable_id="bach", ) +# --- Inscription des étudiants -# --- Inscription de l'étudiant +G.inscrit_etudiant(sem, etud1) +G.inscrit_etudiant(sem, etud2) -G.inscrit_etudiant(sem, etud) +# --- Etud_info -print(etud) - -info = context.Scolarite.etud_info(etud["etudid"], format = "json", REQUEST=REQUEST) +info = context.Scolarite.etud_info(etud1["etudid"], format = "json", REQUEST=REQUEST) load_info = json.loads(info) -print(load_info) -# --- Modification des données -scolars.adresse_edit(context.Scolarite, args = {"domicile" : "9 rue du moulin"}) \ No newline at end of file +# --- Démission étudiant + +context.doDemEtudiant(etud1["etudid"], sem["formsemestre_id"], event_date="01/01/2021") + +bul = sco_bulletins.formsemestre_bulletinetud_dict(context.Notes, sem["formsemestre_id"], etud1["etudid"]) +assert bul["moy_gen"] == "NA" +assert bul["ins"][0]["etat"] == "D" + +# --- Défaillance d'un étudiant + +context.doDefEtudiant(etud2["etudid"], sem["formsemestre_id"], event_date="01/01/2021") + +bul = sco_bulletins.formsemestre_bulletinetud_dict(context.Notes, sem["formsemestre_id"], etud1["etudid"]) +assert bul["moy_gen"] == "NA" +assert bul["ins"][0]["etat"] == "D" + +# --- Annuler démission + +context.Scolarite.doCancelDem(etud1["etudid"], sem["formsemestre_id"], REQUEST=REQUEST) +bul = sco_bulletins.formsemestre_bulletinetud_dict(context.Notes, sem["formsemestre_id"], etud1["etudid"]) +print(bul["ins"][0]["etat"]) +#assert bul["ins"][0]["etat"] == "I" + +# --- Annuler défaillance + +context.Scolarite.doCancelDef(etud2["etudid"], sem["formsemestre_id"], REQUEST=REQUEST) +bul = sco_bulletins.formsemestre_bulletinetud_dict(context.Notes, sem["formsemestre_id"], etud1["etudid"]) +print(bul["ins"][0]["etat"]) +#assert bul["ins"][0]["etat"] == "I" + +# --- Fonctions retournant HTML + +find = sco_find_etud.search_etud_in_dept(context.Scolarite, expnom="Poire", REQUEST=REQUEST) + +_ = context.Scolarite.fillEtudsInfo(etuds=[etud1]) + +""" +Commentaire : + +L'etat ne se met pas à jour après l'annulation de la démission ou de la défaillance. + +etud_info ne donne pas toutes les infos de l'étudiant voir mini test create_etud. + +""" \ No newline at end of file diff --git a/scotests/test_evaluation.py b/scotests/test_evaluation.py index 084fc6b0..9b7b19c8 100755 --- a/scotests/test_evaluation.py +++ b/scotests/test_evaluation.py @@ -1,6 +1,21 @@ """ Création d'une formation, d'élève de 2 ue dans un semestre et de 6 évaluations par 3 fonction différentes : create_eval, evaluation_create et do_evaluation_create. Saisir les notes des évaluations, lister ces evaluations, -supprimer et modifier une evaluation """ +supprimer et modifier une evaluation + +Fonction de l'API utilisé : + - create_evaluation + - evaluation_create + - do_evaluation_create + - do_evaluation_list_in_formsemestre + - do_evaluation_list + - create_note + - check_absences + - do_evaluation_etat + - evaluation_supress_alln + - do_evaluation_edit + - do_evaluation_delete + + """ import sys import random @@ -181,9 +196,7 @@ check2 = sco_liste_notes.evaluation_check_absences(context.Notes, evaluation_id= # --- Liste de note d'une évaluation -#lien = context.Notes.do_evaluation_listnotes(REQUEST=REQUEST) -#print (lien) pb avec les arguments. - +#lien = sco_liste_notes.do_evaluation_listenotes(context=context.Notes, REQUEST=REQUEST) cal = sco_evaluations.formsemestre_evaluations_cal(context.Notes, formsemestre_id=sem["formsemestre_id"], REQUEST=REQUEST) #html @@ -233,3 +246,12 @@ assert len(lie) == 5 sco_evaluations.do_evaluation_delete(context.Notes, REQUEST=REQUEST, evaluation_id=e7["evaluation_id"]) lie2 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem["formsemestre_id"]) assert len(lie2) == 4 + + +""" +Commentaire : + +Plusieurs fonction retourne de l'HTML, les notes ne se suppriment pas malgre l'utilisation de la fonction +evaluation_supress_alln (voir mini test). evaluation_delete ---> rien ne se passe. + +""" \ No newline at end of file diff --git a/scotests/test_evaluation_suppress_alln.py b/scotests/test_evaluation_suppress_alln.py index 5e140020..89106f03 100755 --- a/scotests/test_evaluation_suppress_alln.py +++ b/scotests/test_evaluation_suppress_alln.py @@ -1,3 +1,5 @@ +""" Création d'une évaluation, saisie des notes et supressions de toutes les notes """ + import random # La variable context est définie par le script de lancement # l'affecte ainsi pour évietr les warnins pylint: @@ -68,3 +70,6 @@ sco_saisie_notes.evaluation_suppress_alln(context.Notes, e["evaluation_id"], REQ etat = sco_evaluations.do_evaluation_etat(context.Notes, e["evaluation_id"]) assert not etat["evalcomplete"] +""" +Commentaire : Les notes ne se suppriment pas et l'etat ne change donc pas +""" \ No newline at end of file diff --git a/scotests/test_formations.py b/scotests/test_formations.py index a3feb82d..764d00ea 100755 --- a/scotests/test_formations.py +++ b/scotests/test_formations.py @@ -316,6 +316,4 @@ context.Notes.do_formation_delete(oid=f2["formation_id"], REQUEST=REQUEST) lif3 = context.Notes.formation_list(format = 'json', REQUEST=REQUEST) load_lif3 = json.loads(lif3) -assert len(load_lif3) == 1 - - +assert len(load_lif3) == 1 \ No newline at end of file diff --git a/scotests/test_groupes.py b/scotests/test_groupes.py index 142faf4e..745890f0 100755 --- a/scotests/test_groupes.py +++ b/scotests/test_groupes.py @@ -334,7 +334,7 @@ assert li_grp1[0] == sco_groups.get_group(context.Scolarite, li_grp1[0]["group_i assert len(li_grp2) == 3 sco_groups.group_delete(context.Scolarite, li_grp2[2]) -#assert len(li_grp2) == 2 #TESTE DE group_delete, aucun changement sur la console mais se supprime sur scodoc web +#assert len(li_grp2) == 2 #TEST DE group_delete, aucun changement sur la console mais se supprime sur scodoc web # mais pas dans la console comme pour countAbs() assert sco_groups.get_partition(context.Scolarite, li1[0]["partition_id"])== li1[0] # test de get_partition @@ -370,16 +370,13 @@ assert li_grp3[0] in sg # test de get_sem_groups limembre = sco_groups.get_group_members(context.Scolarite, li_grp1[0]["group_id"]) assert len(limembre) == 4 # car on a changé de groupe un etudiant de ce groupe donc 5-1=4 +""" +Commentaire : +Meme probleme que pour les groupes, lorsque l'on supprime un groupe il est toujours présent dans la liste de groupe +mais pas dans scodoc web. -# --- Changement de nom des partitions, groupes - -# Le changement de nom des groupes et des partitions n'est pas possible en python car la fonction est une fonction d'envoie de formulaire. - - - - - +""" diff --git a/scotests/test_scenario4_formation.py b/scotests/test_scenario4_formation.py index b690022a..7b753afc 100755 --- a/scotests/test_scenario4_formation.py +++ b/scotests/test_scenario4_formation.py @@ -16,6 +16,7 @@ doc = file.read() file.close() + # --- Création de la formation f = sco_formations.formation_import_xml(REQUEST=REQUEST, doc=doc, context=context.Notes) diff --git a/scotests/test_user.py b/scotests/test_user.py index 00b47817..88e6b11c 100755 --- a/scotests/test_user.py +++ b/scotests/test_user.py @@ -1,6 +1,4 @@ -""" Créer un utilisateur, récupérer ses infos, - lister les utilisateurs, modifier le mdp, modfifier l'utilisateur (si possible), - changer d'admin, tester d'autre fonctionalités liés aux users """ +""" Créer un utilisateur, recupérer ses infos, changer son mdp, le supprimer """ import random # La variable context est définie par le script de lancement @@ -12,12 +10,12 @@ import ZScoUsers import ZScoDoc import ZScolar - nomdept = raw_input("Quel est le nom de votre département test? ATTENTION A NE PAS VOUS TROMPER : ") # --- Création d'un utilisateur -arg = {"passwd": "scodocpass", "user_name" : "unutil", "nom" : "unnom", "prenom":"unprenom", "email": "unemail@mail.fr", "roles" :"Ens"+nomdept+",RespPe"+nomdept} +arg = {"passwd": "scodocpass", "user_name" : "unutil", "nom" : "unnom", "prenom":"unprenom", + "email": "unemail@mail.fr", "roles" :"Ens"+nomdept+",RespPe"+nomdept} #user1 = context.Users.create_user(args=arg, REQUEST=REQUEST) user_info1 = context.Users.user_info(user_name="unutil") @@ -31,19 +29,36 @@ assert user_info1["roles"] == arg["roles"] # --- Récupération de la liste des Users liste_xml = context.Users.get_userlist_xml(REQUEST=REQUEST) +print(liste_xml) liste_user = context.Users.get_userlist() len_liu1 = len(liste_user) assert user_info1 in liste_user #le nouvel utilisateur est bien dans la liste ! -# --- Changement du mot de passe de l'utilisateur +# --- Récupérer user_name à partir de nomplogin -#context.Users.change_password(user_name="unutil", password=) +user_name1 = context.Users.get_user_name_from_nomplogin(nomplogin=user_info1["nomplogin"]) +assert user_name1 == "unutil" + +# --- Changement du mot de passe de l'utilisateur context.Users.do_change_password(user_name="unutil", password="scodocpass2") #vérification du mdp changé directement sur scodoc web car je ne trouve pas comment récupérer le mdp en python #Vérification : ok! +# --- Supression d'un utilisateur +#context.Users.delete_user_form(REQUEST=REQUEST, user_name="unutil") +# --- Test de la récupération de l'URL + +url = context.Users.UsersURL() +assert url == "ScoDoc/"+nomdept+"/Scolarite/Users" + +""" +Commentaire : + +La supression d'un utilisateur ne fonctionne pas car nécessite l'envoie d'un formulaire. + +""" \ No newline at end of file From 2c7d55713a0329c7551e49929d8084b84162108d Mon Sep 17 00:00:00 2001 From: root Date: Wed, 9 Jun 2021 19:27:12 +0200 Subject: [PATCH 6/9] ajout de nouveaux tests --- scotests/test_AnnuleAbsencesDatesNoJust.py | 59 +++++ scotests/test_CountAbs.py | 108 +++++++++ scotests/test_absence2.py | 267 +++++++++++++++++++++ scotests/test_api7doc.py | 261 ++++++++++++++++++++ scotests/test_billet.py | 96 ++++++++ scotests/test_deleteBilletAbsence.py | 69 ++++++ scotests/test_edit.py | 46 ++++ scotests/test_etudiant.py | 135 +++++++++++ scotests/test_formation_export_xml.py | 79 ++++++ 9 files changed, 1120 insertions(+) create mode 100755 scotests/test_AnnuleAbsencesDatesNoJust.py create mode 100755 scotests/test_CountAbs.py create mode 100755 scotests/test_absence2.py create mode 100755 scotests/test_api7doc.py create mode 100755 scotests/test_billet.py create mode 100755 scotests/test_deleteBilletAbsence.py create mode 100755 scotests/test_edit.py create mode 100755 scotests/test_etudiant.py create mode 100755 scotests/test_formation_export_xml.py diff --git a/scotests/test_AnnuleAbsencesDatesNoJust.py b/scotests/test_AnnuleAbsencesDatesNoJust.py new file mode 100755 index 00000000..dce5c1b5 --- /dev/null +++ b/scotests/test_AnnuleAbsencesDatesNoJust.py @@ -0,0 +1,59 @@ +# -*- mode: python -*- +# -*- coding: utf-8 - + +""" Création d'une absence et utilisation de AnnuleAbsenceDatesNoJust """ +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_abs_views + + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- 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"], + 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 +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + +# --- Création d'un étudiant +etud = G.create_etud(code_nip=None) +G.inscrit_etudiant(sem, etud) +etudid=etud["etudid"] + +# --- Création d'une absence +sco_abs_views.doSignaleAbsence(context.Absences, datedebut="22/01/2021", datefin="22/01/2021", demijournee=2, etudid=etudid, REQUEST=REQUEST) + +# --- Annulation d'absence +context.Absences.AnnuleAbsencesDatesNoJust(etudid, dates="22/01/2021", REQUEST=REQUEST) + +""" Erreur : File "/opt/scodoc/Products/ScoDoc/ZAbsences.py", line 323, in AnnuleAbsencesDatesNoJust + vars(), +psycopg2.DataError: invalid input syntax for type date: "2" +LINE 1: ...es where etudid='EID1' and (not estjust) and jour='2' and mo... """ \ No newline at end of file diff --git a/scotests/test_CountAbs.py b/scotests/test_CountAbs.py new file mode 100755 index 00000000..25057b52 --- /dev/null +++ b/scotests/test_CountAbs.py @@ -0,0 +1,108 @@ +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_abs +import sco_abs_views +import sco_abs_notification +import ZAbsences + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants +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"], + 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 +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + +# --- Inscription des étudiants +G.inscrit_etudiant(sem, etud) + +# --- Saisie absences +etudid = etud["etudid"] + +for debut, fin, demijournee in [ + ("15/01/2021", "15/01/2021", 1), + ("18/01/2021", "18/01/2021", 0), + ("19/01/2021", "19/01/2021", 2), + ("22/01/2021", "22/01/2021", 1) +] : + sco_abs_views.doSignaleAbsence(context.Absences, datedebut=debut, datefin=fin, demijournee=demijournee, etudid=etudid, REQUEST=REQUEST) + + +# --- Justification de certaines absences + +for debut, fin, demijournee in [ + ("15/01/2021", "15/01/2021", 1), + ("18/01/2021", "18/01/2021", 0), + ("19/01/2021", "19/01/2021", 2) +] : + sco_abs_views.doJustifAbsence(context.Absences, datedebut=debut, datefin=fin, demijournee=demijournee, etudid=etudid, REQUEST=REQUEST) + + +# --- Utilisation de CountAbs() de sco_abs + +a = sco_abs.getAbsSemEtud(context.Absences, sem, etudid) +nb_abs = a.CountAbs() +nb_absj = a.CountAbsJust() + +# --- Utilisation de CountAbs() de ZAbsences + +nb_abs2 = context.Absences.CountAbs(etudid=etudid, debut="01/01/2021", fin="06/30/2021") +nb_absj2 = context.Absences.CountAbsJust(etudid=etudid, debut="01/01/2021", fin="06/30/2021") + +assert nb_abs == nb_abs2 == 5 +assert nb_absj == nb_absj2 == 4 + +# --- Supression d'absence + +_ = sco_abs_views.doAnnuleAbsence(context.Absences, "19/01/2021", "19/01/2021", 2, etudid=etudid, REQUEST=REQUEST) +b = sco_abs.getAbsSemEtud(context.Absences, sem, etudid) + +# --- Vérification + +new_nbabs = b.CountAbs() +new_nbabs2 = context.Absences.CountAbs(etudid=etudid, debut="01/01/2021", fin="06/30/2021") + +print(new_nbabs) +print(new_nbabs2) + +assert new_nbabs == new_nbabs2 + + +""" +Commentaire : + +CountAbs de ZAbsence ----> OK +CountAbs de sco_abs_view ----> bug + +Peut être du au fait que la fonction getAbsSemEtud ne se met pas à jour par rapport aux absences supprimés. +""" \ No newline at end of file diff --git a/scotests/test_absence2.py b/scotests/test_absence2.py new file mode 100755 index 00000000..2cb303cb --- /dev/null +++ b/scotests/test_absence2.py @@ -0,0 +1,267 @@ +# -*- mode: python -*- +# -*- coding: utf-8 - + +"""" +Creation de 10 étudiants, formation, semestre, ue, module, absences le matin, l'apres midi, la journée compléte +et justification d'absences, supression d'absences, création de listes d'absences, création de billet +et creation d'un groupe. + +Fonction de l'API utilisé : + - doSignaleAbsence + - doJustifAbsence + - AddBilletAbs + - XMLgetBilletAbsence + - listeBilletEtud + - ListeAbsJust + - CountAbsJust + - ListAbsNonJust + - ListJustifs + - ListeAbsJour + - ListAbsInRange + +Fonction renvoyant du code HTML : + - EtatAbsences + - SignaleAbsenceGrSemestre + - SignaleAbsenceGrHebdo + - EtatAbsenceDate + - AddBilletAbsenceForm + - AnnuleAbsenceEtud + - ProcessBilletAbsenceForm + - JustifAbsenceEtud + - doAnnuleJustif + +""" + +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_abs +import sco_abs_views +import sco_abs_notification +import ZAbsences + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants +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"], + 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 +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + +# --- Inscription des étudiants +for etud in etuds: + G.inscrit_etudiant(sem, etud) + +# --- Création d'un groupe + +_ = sco_groups.partition_create(context.Scolarite, formsemestre_id=sem["formsemestre_id"], partition_name="Eleve", REQUEST=REQUEST) +li1 = sco_groups.get_partitions_list(context.Scolarite, sem["formsemestre_id"]) +_ = sco_groups.createGroup(context.Scolarite, li1[0]["partition_id"], "Groupe 1", REQUEST=REQUEST) + +# --- Affectation des élèves dans des groupes + +li_grp1 = sco_groups.get_partition_groups(context.Scolarite, li1[0]) +for etud in etuds : + sco_groups.set_group(context.Scolarite, etud["etudid"], li_grp1[0]["group_id"]) + +# --- Saisie absences +etudid = etuds[0]["etudid"] + +for debut, fin, demijournee in [ + ("15/01/2021", "15/01/2021", 1), + ("18/01/2021", "18/01/2021", 0), + ("19/01/2021", "19/01/2021", 2), + ("22/01/2021", "22/01/2021", 1) +] : + sco_abs_views.doSignaleAbsence(context.Absences, datedebut=debut, datefin=fin, demijournee=demijournee, etudid=etudid, REQUEST=REQUEST) + +_ = sco_abs_views.doSignaleAbsence( + context.Absences, + "22/01/2021", + "22/01/2021", + demijournee=1, + etudid=etuds[1]["etudid"], + REQUEST=REQUEST, +) + +# --- Justification de certaines absences + +for debut, fin, demijournee in [ + ("15/01/2021", "15/01/2021", 1), + ("18/01/2021", "18/01/2021", 0), + ("19/01/2021", "19/01/2021", 2) +] : + sco_abs_views.doJustifAbsence(context.Absences, datedebut=debut, datefin=fin, demijournee=demijournee, etudid=etudid, REQUEST=REQUEST) + +# --- Test + +_ = context.Absences.doSignaleAbsenceGrSemestre( + dates="2021-01-13,2021-01-25", + etudids= etuds[5]["etudid"]+","+etuds[6]["etudid"], + destination="", + REQUEST=REQUEST + ) # <----- rien ne se passe (pb parametre ?) + +# --- Création de billets + +b1 = context.Absences.AddBilletAbsence( + begin="2021-01-22 00:00", + end="2021-01-22 23:59", + etudid=etudid, + description = "abs du 22", + justified=False, + code_nip=etuds[0]["code_nip"], + code_ine=etuds[0]["code_ine"], + REQUEST=REQUEST, + ) + +b2 = context.Absences.AddBilletAbsence( + begin="2021-01-15 00:00", + end="2021-01-15 23:59", + etudid=etudid, + description = "abs du 15", + code_nip=etuds[0]["code_nip"], + code_ine=etuds[0]["code_ine"], + REQUEST=REQUEST, + ) + +# --- XMLgetBilletEtud + +xml_bi = context.Absences.XMLgetBilletsEtud(etudid=etudid, REQUEST=REQUEST) +print(1) +print(xml_bi) +print(1) + +# --- Supression de billet +li_bi = context.Absences.listeBilletsEtud(etudid=etudid, REQUEST=REQUEST, format="json") +load_li_bi = json.loads(li_bi) + +#_ = context.Absences.deleteBilletAbsence(load_li_bi[1]["billet_id"], REQUEST=REQUEST) + +li_bi2 = context.Absences.listeBilletsEtud(etudid=etudid, REQUEST=REQUEST, format="json") +load_li_bi2 = json.loads(li_bi) + +#assert len(load_li_bi2) == 1 +#assert load_li_bi2[0]["description"] == "abs du 22" + +# --- Créaton de listes + +li_abs_just = context.Absences.ListeAbsJust(etudid = etudid, datedebut="01/01/2021") +nb_abs_just = context.Absences.CountAbsJust(etudid, debut="01/01/2021", fin="06/30/2021") +assert len(li_abs_just) == nb_abs_just +assert li_abs_just[0]["etudid"] == etudid +assert li_abs_just[0]["matin"] == True +assert li_abs_just[0]["jour"] == datetime.date(2021, 1, 15) +assert li_abs_just[2]["jour"] == datetime.date(2021, 1, 19) +assert li_abs_just[2]["matin"] == False + + +li_abs_njust = context.Absences.ListeAbsNonJust(etudid=etudid, datedebut="01/01/2021") +nb_abs = context.Absences.CountAbs(etudid, debut="01/01/2021", fin="06/30/2021") +assert len(li_abs_njust) == nb_abs - nb_abs_just +assert li_abs_njust[0]["matin"] == True +assert li_abs_njust[0]["etudid"] == etudid +assert li_abs_njust[0]["jour"] == datetime.date(2021, 1, 22) + + +li_just = context.Absences.ListeJustifs(etudid=etudid, datedebut="01/01/2021") +assert len(li_just) == 4 +li_just2 = context.Absences.ListeJustifs(etudid=etudid, datedebut="01/01/2021", datefin="01/18/2021") +assert len(li_just2) == 2 + + +li_jour = context.Absences.ListeAbsJour(date="01/22/2021") +assert len(li_jour) == 2 +li_jour2 = context.Absences.ListeAbsJour(date="01/18/2021") +assert len(li_jour2) == 1 + + +li_range = context.Absences.ListAbsInRange(etudid, debut="01/01/2021", fin="06/01/2021") +assert len(li_range) == 5 + +#li_xml = context.Absences.XMLgetAbsEtud(beg_date="01/01/2021", end_date="01/06/2021", REQUEST=REQUEST) +#print(li_xml) need etudid + +# --- Annulation d'absence + +#context.Absences.AnnuleAbsencesDatesNoJust(etudid, dates="22/01/2021", REQUEST=REQUEST) + + +# --- Fonction renvoyant du code HTML + +etat_abs = context.Absences.EtatAbsences(REQUEST=REQUEST) + +#cal_abs = sco_abs_views.CalAbs(context.Absences, REQUEST=REQUEST) #<--- retourne html + need etudid : how? + +sag = context.Absences.SignaleAbsenceGrSemestre( + datedebut="15/01/2021", + datefin="22/01/2021", + group_ids=[li_grp1[0]["group_id"]], + REQUEST=REQUEST, + ) + +sagh = context.Absences.SignaleAbsenceGrHebdo( + datelundi="18/01/2021", group_ids=[li_grp1[0]["group_id"]], destination="", REQUEST=REQUEST + ) + +grp_abs_d = context.Absences.EtatAbsencesDate(group_ids=[li_grp1[0]["group_id"]], date="22/01/2021", REQUEST=REQUEST) + +billet_form = context.Absences.AddBilletAbsenceForm(etudid=etudid, REQUEST=REQUEST) + +#an_abs = AnnuleAbsenceEtud(context.Absences, REQUEST=REQUEST) #<- retourne html + need etudid : how? + +#proc = context.Absences.ProcessBilletAbsenceForm(billet_id=load_li_bi[0]["billet_id"], REQUEST=REQUEST) #error + +#just_form = sco_abs_views.JustifAbsenceEtud(context.Absences, REQUEST=REQUEST) + +#delete_just = sco_abs_views.doAnnuleJustif(context.Absences, datedebut0="22/01/2021", datefin0="22/01/2021", demijournee=2, REQUEST=REQUEST) + + +""" +Commentaire : + +Certaines fonctions ont besoin de l'id de l'étudiant mais n'ont pas ce parametre comment le récupérer ? +(CalAbs, SignaleAbsenceEtud, AnnuleAbsenceEtud, JustifAbsenceEtud, doAnnuleJustif, XMLgetAbsEtud) + +D'autres fonctions renvoient du HTML -> comment les tester en python? + +doSignaleAbsenceGrSemestre -> ne fonctionne pas (pb au niveau de l'écriture des parametres au lancement + de la fonction?) + +XMLgetBilletsEtud, deleteBilletAbsence -> fonction get ne retourne rien et delete ne supprime rien + (lancer fichier test_billet) + +AnnuleAbsencesDatesNoJust -> error line 323, jour='2' (2 doit être un int et non un string?) + +""" + + diff --git a/scotests/test_api7doc.py b/scotests/test_api7doc.py new file mode 100755 index 00000000..a1d6133a --- /dev/null +++ b/scotests/test_api7doc.py @@ -0,0 +1,261 @@ +import sco_formations +import json +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_moduleimpl +import sco_groups_view +import sco_abs_views + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +file = open("scotests/export_formation1.xml") +doc = file.read() +file.close() + +# --- Création de la formation + +f = sco_formations.formation_import_xml(REQUEST=REQUEST, doc=doc, context=context.Notes) + +# --- Création des semestres + +sem1 = G.create_formsemestre( + formation_id=f[0], + semestre_id=1, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem3 = G.create_formsemestre( + formation_id=f[0], + semestre_id=3, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem2 = G.create_formsemestre( + formation_id=f[0], + semestre_id=2, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + +sem4 = G.create_formsemestre( + formation_id=f[0], + semestre_id=4, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + + +# --- Implémentation des modules + +li_module = context.Notes.do_module_list() +mods_imp = [] +for mod in li_module : + if mod["semestre_id"] == 1 : + formsemestre_id = sem1["formsemestre_id"] + elif mod["semestre_id"] == 2 : + formsemestre_id = sem2["formsemestre_id"] + elif mod["semestre_id"] == 3 : + formsemestre_id = sem3["formsemestre_id"] + else : + formsemestre_id = sem4["formsemestre_id"] + + mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=formsemestre_id, + responsable_id="bach", + ) + mods_imp.append(mi) + +# --- Création des étudiants + +etuds=[] +for nom, prenom in [ + ("Semestre11", "EtudiantNumero1"), + ("Semestre12", "EtudiantNumero2"), + ("Semestre23", "EtudiantNumero3"), + ("Semestre24", "EtudiantNumero4"), + ("Semestre35", "EtudiantNumero5"), + ("Semestre36", "EtudiantNumero6"), + ("Semestre47", "EtudiantNumero7"), + ("Semestre48", "EtudiantNumero8") +] : + etud = G.create_etud( + nom=nom, + prenom=prenom, + ) + etuds.append(etud) + +# --- Inscription des étudiants + +for etud in etuds[0:2]: + G.inscrit_etudiant(sem1, etud) + +for etud in etuds[2:4]: + G.inscrit_etudiant(sem2, etud) + +for etud in etuds[4:6]: + G.inscrit_etudiant(sem3, etud) + +for etud in etuds[6:]: + G.inscrit_etudiant(sem4, etud) + +# --- Création d'une évaluation pour chaque UE + +lim_sem1 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem1["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem1 = json.loads(lim_sem1) + +lim_sem2 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem2["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem2 = json.loads(lim_sem2) + +lim_sem3 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem3["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem3 = json.loads(lim_sem3) + +lim_sem4 = sco_moduleimpl.do_moduleimpl_list(context.Notes, formsemestre_id=sem4["formsemestre_id"], REQUEST=REQUEST) +load_lim_sem4 = json.loads(lim_sem4) + + +for moduleimpl_id, jour, description, coefficient in [ + (load_lim_sem1[1]["moduleimpl_id"], "02/09/2020", "InterroTestSemestre1", 1.0), + (load_lim_sem1[2]["moduleimpl_id"], "03/09/2020", "InterroTestSemestre1", 1.0), + (load_lim_sem2[1]["moduleimpl_id"], "03/02/2021", "InterroTestSemestre2", 1.0), + (load_lim_sem2[8]["moduleimpl_id"], "04/02/2021", "InterroTestSemestre2", 1.0), + (load_lim_sem3[3]["moduleimpl_id"], "02/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem3[9]["moduleimpl_id"], "03/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem3[15]["moduleimpl_id"], "04/09/2020", "InterroTestSemestre3", 1.0), + (load_lim_sem4[3]["moduleimpl_id"], "03/02/2021", "InterroTestSemestre4", 1.0), + (load_lim_sem4[9]["moduleimpl_id"], "04/02/2021", "InterroTestSemestre4", 1.0), + (load_lim_sem4[13]["moduleimpl_id"], "05/02/2021", "InterroTestSemestre4", 1.0), +] : + e = G.create_evaluation(moduleimpl_id=moduleimpl_id, jour=jour, description=description, coefficient=coefficient) + + +# --- Saisie des notes des étudiants (un élève a 12, un autre a 7 pour chaque semestre) + +lie1 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem1["formsemestre_id"]) +lie2 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem2["formsemestre_id"]) +lie3 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem3["formsemestre_id"]) +lie4 = context.Notes.do_evaluation_list_in_formsemestre(formsemestre_id=sem4["formsemestre_id"]) + +for eval in lie1 : + for etud in etuds[:2] : + if etud == etuds[0] : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=12.0) + else : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=7.0) + +for eval in lie2 : + for etud in etuds[2:4] : + if etud == etuds[2] : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=12.0) + else : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=7.0) + + +for eval in lie3 : + for etud in etuds[4:6] : + if etud == etuds[4] : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=12.0) + else : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=7.0) + +for eval in lie4 : + for etud in etuds[6:] : + if etud == etuds[6] : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=12.0) + else : + nb_changed, nb_suppress, existing_decisions = G.create_note(evaluation=eval, etud=etud, note=7.0) + +# --- Département + +li_dep = context.ScoDoc.list_depts(format="json", REQUEST=REQUEST) +print(li_dep) + +# --- Formation + +lif = context.Notes.formation_list(format="json", REQUEST=REQUEST, formation_id=f[0]) +load_lif = json.loads(lif) +assert len(load_lif) == 1 +assert load_lif[0]["formation_id"] == f[0] + +exp = sco_formations.formation_export(context.Notes, formation_id=f[0], format="json", REQUEST=REQUEST) +load_exp = json.loads(exp) +assert load_exp["acronyme"] == "DUT Info" +assert load_exp["titre_officiel"] == "DUT Informatique" +assert load_exp["formation_code"] == "FCOD2" + +# --- Semestre + +li_sem = context.Notes.formsemestre_list(formation_id=f[0], format = "json", REQUEST=REQUEST) +load_li_sem = json.loads(li_sem) +assert len(load_li_sem) == 4 + +# --- Création des groupes + +_ = sco_groups.partition_create(context.Scolarite, formsemestre_id=sem1["formsemestre_id"], partition_name="Eleve 1ere annee", REQUEST=REQUEST) + +li1 = sco_groups.get_partitions_list(context.Scolarite, sem1["formsemestre_id"]) + +_ = sco_groups.createGroup(context.Scolarite, li1[0]["partition_id"], "Groupe S1A", REQUEST=REQUEST) + +li_grp1 = sco_groups.get_partition_groups(context.Scolarite, li1[0]) + +for etud in etuds[0:2] : + sco_groups.set_group(context.Scolarite, etud["etudid"], li_grp1[0]["group_id"]) + + +# --- Groupes + +li_part = sco_groups.formsemestre_partition_list(context.Scolarite, formsemestre_id=sem1["formsemestre_id"], format = "json", REQUEST=REQUEST) +load_li_part = json.loads(li_part) +assert len(load_li_part) == 2 # 2 partition (defaut et eleve 1ere annee) +assert load_li_part[0]["formsemestre_id"] == sem1["formsemestre_id"] +assert len(load_li_part[0]["group"]) == 1 # 2 groupes S1A +assert load_li_part[0]["group"][0]["group_name"] == "Groupe S1A" +assert load_li_part[0]["group"][0]["group_id"] == li_grp1[0]["group_id"] +assert load_li_part[0]["partition_id"] == load_li_part[0]["group"][0]["partition_id"] == li1[0]["partition_id"] +assert load_li_part[0]["partition_name"] == "Eleve 1ere annee" + +vue_g1 = sco_groups_view.groups_view(context.Scolarite, group_ids = [li_grp1[0]["group_id"]], format = "json", REQUEST=REQUEST) +load_vue_g1 = json.loads(vue_g1) +assert len(load_vue_g1) == 2 +assert load_vue_g1[0][li1[0]["partition_id"]] == li_grp1[0]["group_name"] + + +# --- Etudiant + +etudi = context.Scolarite.etud_info(etudid=etuds[0]["etudid"], format="json", REQUEST=REQUEST) +load_etudi = json.loads(etudi) +assert load_etudi["prenom"] == "Etudiantnumero1" +assert load_etudi["nom"] == "SEMESTRE11" +assert load_etudi["etudid"] == etuds[0]["etudid"] + +# --- Absences + +for debut, fin, demijournee in [ + ("18/01/2021", "18/01/2021", 1), + ("19/01/2021", "19/01/2021", 0), +] : + sco_abs_views.doSignaleAbsence(context.Absences, datedebut=debut, datefin=fin, demijournee=demijournee, etudid=etuds[0]["etudid"], REQUEST=REQUEST) + +nb_abs = context.Absences.CountAbs(etuds[0]["etudid"], debut="09/01/2020", fin="02/01/2021") +assert nb_abs == 2 + +liste_abs = sco_abs_views.ListeAbsEtud(context.Absences, etuds[0]["etudid"], format='json', REQUEST=REQUEST) +load_liste_abs = json.loads(liste_abs) +assert len(load_liste_abs) == 2 + +_ = sco_abs_views.doAnnuleAbsence(context.Absences, "15/01/2021", "15/01/2021", 1, etudid=etuds[0]["etudid"], REQUEST=REQUEST) + +# --- Module + +#Voir test dans test_formation. + + + diff --git a/scotests/test_billet.py b/scotests/test_billet.py new file mode 100755 index 00000000..a44f9668 --- /dev/null +++ b/scotests/test_billet.py @@ -0,0 +1,96 @@ +# -*- mode: python -*- +# -*- coding: utf-8 - + +""" Création de billet, utilisation de XMLgetBilletsEtud et suppression de billet """ +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_abs_views + + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- 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"], + 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 +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + +# --- Création d'un étudiant +etud = G.create_etud(code_nip=None) +G.inscrit_etudiant(sem, etud) +etudid=etud["etudid"] + +# --- Création d'une absence +sco_abs_views.doSignaleAbsence(context.Absences, datedebut="22/01/2021", datefin="22/01/2021", demijournee=2, etudid=etudid, REQUEST=REQUEST) + +# --- Création d'un billet +b1 = context.Absences.AddBilletAbsence( + begin="2021-01-22 00:00", + end="2021-01-22 23:59", + etudid=etudid, + description = "abs du 22", + justified=False, + code_nip=etud["code_nip"], + code_ine=etud["code_ine"], + REQUEST=REQUEST, + ) + +# --- XMLgetBilletEtud + +xml_bi = context.Absences.XMLgetBilletsEtud(etudid=etudid, REQUEST=REQUEST) +print(1) +print(xml_bi) +print(1) + + +# --- Suppression d'un billet +li_bi = context.Absences.listeBilletsEtud(etudid=etudid, REQUEST=REQUEST, format="json") +load_li_bi = json.loads(li_bi) + +_ = context.Absences.deleteBilletAbsence(load_li_bi[0]["billet_id"], REQUEST=REQUEST) + +li_bi2 = context.Absences.listeBilletsEtud(etudid=etudid, REQUEST=REQUEST, format="json") +load_li_bi2 = json.loads(li_bi) + +assert len(load_li_bi2) == 0 + +""" +Commentaire : + +XMLgetBilletsEtud retourne une chaine vide + +deleteBilletsEtud : erreur +File "/opt/scodoc/Products/ScoDoc/ZAbsences.py", line 1809, in deleteBilletAbsence + parameters={"billet_id": billet_id}, + File "/opt/scodoc/Products/ScoDoc/ZScolar.py", line 2664, in confirmDialog + return self.sco_header(REQUEST) + "\n".join(H) + self.sco_footer(REQUEST) +UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3 in position 223: ordinal not in range(128) + +""" \ No newline at end of file diff --git a/scotests/test_deleteBilletAbsence.py b/scotests/test_deleteBilletAbsence.py new file mode 100755 index 00000000..db605ae0 --- /dev/null +++ b/scotests/test_deleteBilletAbsence.py @@ -0,0 +1,69 @@ +# -*- mode: python -*- +# -*- coding: utf-8 - +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_abs_views + + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- 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"], + 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 +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + +# --- Création d'un étudiant +etud = G.create_etud(code_nip=None) +G.inscrit_etudiant(sem, etud) +etudid=etud["etudid"] + +# --- Création d'une absence +sco_abs_views.doSignaleAbsence(context.Absences, datedebut="22/01/2021", datefin="22/01/2021", demijournee=2, etudid=etudid, REQUEST=REQUEST) + +# --- Création d'un billet +b1 = context.Absences.AddBilletAbsence( + begin="2021-01-22 00:00", + end="2021-01-22 23:59", + etudid=etudid, + description = "abs du 22", + justified=False, + code_nip=etuds[0]["code_nip"], + code_ine=etuds[0]["code_ine"], + REQUEST=REQUEST, + ) + +# --- Suppression d'un billet +_ = context.Absences.deleteBilletAbsence(load_li_bi[1]["billet_id"], REQUEST=REQUEST) + +li_bi = context.Absences.listeBilletsEtud(etudid=etudid, REQUEST=REQUEST, format="json") +load_li_bi = json.loads(li_bi) + +assert len(load_li_bi) == 0 \ No newline at end of file diff --git a/scotests/test_edit.py b/scotests/test_edit.py new file mode 100755 index 00000000..ede25281 --- /dev/null +++ b/scotests/test_edit.py @@ -0,0 +1,46 @@ +# -*- mode: python -*- +# -*- coding: utf-8 - + +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- 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"], + 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 +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + +# --- Modification d'un module + +context.Notes.do_module_edit({"module_id":mod["module_id"], "code": "MOD1", "titre" : "module modifie"}) +print(mod) + diff --git a/scotests/test_etudiant.py b/scotests/test_etudiant.py new file mode 100755 index 00000000..cb10fda6 --- /dev/null +++ b/scotests/test_etudiant.py @@ -0,0 +1,135 @@ +""" Création de 2 étudiants, un qui demissionne, un autre defaillant + annuler demission et annuler défaillance + +Fonctions de l’API utilisé : +- doDemEtudiant +- doDefEtudiant +- doCancelDem +- doCancelDef +- etud_info +- search_etud_in_dept +- fillEtudsInfo + + """ + + +import random + +# La variable context est définie par le script de lancement +# l'affecte ainsi pour éviter les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import scolars +import sco_find_etud + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +# --- Création d'étudiants + +etud1 = G.create_etud( + code_nip="", + nom="Poire", + prenom="Kevin", + code_ine="", + civilite="M", + etape="TST1", + email="test1@localhost", + emailperso="perso1@localhost", + date_naissance="01/05/2001", + lieu_naissance="Stains", + dept_naissance="93", + domicile="11, rue du test", + codepostaldomicile="93430", + villedomicile="Villetaneuse", + paysdomicile="France", + telephone="0102030405", + typeadresse="domicile", + boursier=None, + description="etudiant test", + ) + +etud2 = G.create_etud() + +# --- 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"], + 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 +) + +# --- Mise place d'un semestre +sem = G.create_formsemestre( + formation_id=f["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"], + responsable_id="bach", +) + +# --- Inscription des étudiants + +G.inscrit_etudiant(sem, etud1) +G.inscrit_etudiant(sem, etud2) + +# --- Etud_info + +info = context.Scolarite.etud_info(etud1["etudid"], format = "json", REQUEST=REQUEST) +load_info = json.loads(info) + + +# --- Démission étudiant + +context.doDemEtudiant(etud1["etudid"], sem["formsemestre_id"], event_date="01/01/2021") + +bul = sco_bulletins.formsemestre_bulletinetud_dict(context.Notes, sem["formsemestre_id"], etud1["etudid"]) +assert bul["moy_gen"] == "NA" +assert bul["ins"][0]["etat"] == "D" + +# --- Défaillance d'un étudiant + +context.doDefEtudiant(etud2["etudid"], sem["formsemestre_id"], event_date="01/01/2021") + +bul = sco_bulletins.formsemestre_bulletinetud_dict(context.Notes, sem["formsemestre_id"], etud1["etudid"]) +assert bul["moy_gen"] == "NA" +assert bul["ins"][0]["etat"] == "D" + +# --- Annuler démission + +context.Scolarite.doCancelDem(etud1["etudid"], sem["formsemestre_id"], REQUEST=REQUEST) +bul = sco_bulletins.formsemestre_bulletinetud_dict(context.Notes, sem["formsemestre_id"], etud1["etudid"]) +print(bul["ins"][0]["etat"]) +#assert bul["ins"][0]["etat"] == "I" + +# --- Annuler défaillance + +context.Scolarite.doCancelDef(etud2["etudid"], sem["formsemestre_id"], REQUEST=REQUEST) +bul = sco_bulletins.formsemestre_bulletinetud_dict(context.Notes, sem["formsemestre_id"], etud1["etudid"]) +print(bul["ins"][0]["etat"]) +#assert bul["ins"][0]["etat"] == "I" + +# --- Fonctions retournant HTML + +find = sco_find_etud.search_etud_in_dept(context.Scolarite, expnom="Poire", REQUEST=REQUEST) + +_ = context.Scolarite.fillEtudsInfo(etuds=[etud1]) + +""" +Commentaire : + +L'etat ne se met pas à jour après l'annulation de la démission ou de la défaillance. + +etud_info ne donne pas toutes les infos de l'étudiant voir mini test create_etud. + +""" \ No newline at end of file diff --git a/scotests/test_formation_export_xml.py b/scotests/test_formation_export_xml.py new file mode 100755 index 00000000..59177451 --- /dev/null +++ b/scotests/test_formation_export_xml.py @@ -0,0 +1,79 @@ +import sco_formations +import random +# La variable context est définie par le script de lancement +# l'affecte ainsi pour évietr les warnins pylint: +context = context # pylint: disable=undefined-variable +REQUEST = REQUEST # pylint: disable=undefined-variable +import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error +import sco_moduleimpl + +G = sco_fake_gen.ScoFake(context.Notes) +G.verbose = False + +file = open("scotests/export_formation1.xml") +doc = file.read() +file.close() + +print(doc) +print("\n \n \n") +# --- Création de la formation + +f = sco_formations.formation_import_xml(REQUEST=REQUEST, doc=doc, context=context.Notes) + + +# --- Création des semestres + +sem1 = G.create_formsemestre( + formation_id=f[0], + semestre_id=1, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem3 = G.create_formsemestre( + formation_id=f[0], + semestre_id=3, + date_debut="01/09/2020", + date_fin="01/02/2021", +) + +sem2 = G.create_formsemestre( + formation_id=f[0], + semestre_id=2, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + +sem4 = G.create_formsemestre( + formation_id=f[0], + semestre_id=4, + date_debut="02/02/2021", + date_fin="01/06/2021", +) + + +# --- Implémentation des modules + +li_module = context.Notes.do_module_list() +mods_imp = [] +for mod in li_module : + if mod["semestre_id"] == 1 : + formsemestre_id = sem1["formsemestre_id"] + elif mod["semestre_id"] == 2 : + formsemestre_id = sem2["formsemestre_id"] + elif mod["semestre_id"] == 3 : + formsemestre_id = sem3["formsemestre_id"] + else : + formsemestre_id = sem4["formsemestre_id"] + + mi = G.create_moduleimpl( + module_id=mod["module_id"], + formsemestre_id=formsemestre_id, + responsable_id="bach", + ) + mods_imp.append(mi) + +# --- Test de export_formation format xml + +form_exp = context.Notes.formation_export(formation_id=f[0], format="xml", REQUEST=REQUEST) +print(form_exp[39:]) From 11618196b363163dfa111261bcc5b25c8dc14587 Mon Sep 17 00:00:00 2001 From: Fares Amer Date: Thu, 10 Jun 2021 16:06:15 +0200 Subject: [PATCH 7/9] Supprimer 'scotests/test_edit.py' --- scotests/test_edit.py | 46 ------------------------------------------- 1 file changed, 46 deletions(-) delete mode 100755 scotests/test_edit.py diff --git a/scotests/test_edit.py b/scotests/test_edit.py deleted file mode 100755 index ede25281..00000000 --- a/scotests/test_edit.py +++ /dev/null @@ -1,46 +0,0 @@ -# -*- mode: python -*- -# -*- coding: utf-8 - - -import random - -# La variable context est définie par le script de lancement -# l'affecte ainsi pour évietr les warnins pylint: -context = context # pylint: disable=undefined-variable -REQUEST = REQUEST # pylint: disable=undefined-variable -import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error - -G = sco_fake_gen.ScoFake(context.Notes) -G.verbose = False - -# --- 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"], - 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 -) - -# --- Mise place d'un semestre -sem = G.create_formsemestre( - formation_id=f["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"], - responsable_id="bach", -) - -# --- Modification d'un module - -context.Notes.do_module_edit({"module_id":mod["module_id"], "code": "MOD1", "titre" : "module modifie"}) -print(mod) - From b89277a9a8150c9c35f4d1cafe223b83a9dcce70 Mon Sep 17 00:00:00 2001 From: Fares Amer Date: Thu, 10 Jun 2021 16:06:32 +0200 Subject: [PATCH 8/9] Supprimer 'scotests/test_etudiant1.py' --- scotests/test_etudiant1.py | 135 ------------------------------------- 1 file changed, 135 deletions(-) delete mode 100755 scotests/test_etudiant1.py diff --git a/scotests/test_etudiant1.py b/scotests/test_etudiant1.py deleted file mode 100755 index cb10fda6..00000000 --- a/scotests/test_etudiant1.py +++ /dev/null @@ -1,135 +0,0 @@ -""" Création de 2 étudiants, un qui demissionne, un autre defaillant + annuler demission et annuler défaillance - -Fonctions de l’API utilisé : -- doDemEtudiant -- doDefEtudiant -- doCancelDem -- doCancelDef -- etud_info -- search_etud_in_dept -- fillEtudsInfo - - """ - - -import random - -# La variable context est définie par le script de lancement -# l'affecte ainsi pour éviter les warnins pylint: -context = context # pylint: disable=undefined-variable -REQUEST = REQUEST # pylint: disable=undefined-variable -import scotests.sco_fake_gen as sco_fake_gen # pylint: disable=import-error -import scolars -import sco_find_etud - -G = sco_fake_gen.ScoFake(context.Notes) -G.verbose = False - -# --- Création d'étudiants - -etud1 = G.create_etud( - code_nip="", - nom="Poire", - prenom="Kevin", - code_ine="", - civilite="M", - etape="TST1", - email="test1@localhost", - emailperso="perso1@localhost", - date_naissance="01/05/2001", - lieu_naissance="Stains", - dept_naissance="93", - domicile="11, rue du test", - codepostaldomicile="93430", - villedomicile="Villetaneuse", - paysdomicile="France", - telephone="0102030405", - typeadresse="domicile", - boursier=None, - description="etudiant test", - ) - -etud2 = G.create_etud() - -# --- 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"], - 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 -) - -# --- Mise place d'un semestre -sem = G.create_formsemestre( - formation_id=f["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"], - responsable_id="bach", -) - -# --- Inscription des étudiants - -G.inscrit_etudiant(sem, etud1) -G.inscrit_etudiant(sem, etud2) - -# --- Etud_info - -info = context.Scolarite.etud_info(etud1["etudid"], format = "json", REQUEST=REQUEST) -load_info = json.loads(info) - - -# --- Démission étudiant - -context.doDemEtudiant(etud1["etudid"], sem["formsemestre_id"], event_date="01/01/2021") - -bul = sco_bulletins.formsemestre_bulletinetud_dict(context.Notes, sem["formsemestre_id"], etud1["etudid"]) -assert bul["moy_gen"] == "NA" -assert bul["ins"][0]["etat"] == "D" - -# --- Défaillance d'un étudiant - -context.doDefEtudiant(etud2["etudid"], sem["formsemestre_id"], event_date="01/01/2021") - -bul = sco_bulletins.formsemestre_bulletinetud_dict(context.Notes, sem["formsemestre_id"], etud1["etudid"]) -assert bul["moy_gen"] == "NA" -assert bul["ins"][0]["etat"] == "D" - -# --- Annuler démission - -context.Scolarite.doCancelDem(etud1["etudid"], sem["formsemestre_id"], REQUEST=REQUEST) -bul = sco_bulletins.formsemestre_bulletinetud_dict(context.Notes, sem["formsemestre_id"], etud1["etudid"]) -print(bul["ins"][0]["etat"]) -#assert bul["ins"][0]["etat"] == "I" - -# --- Annuler défaillance - -context.Scolarite.doCancelDef(etud2["etudid"], sem["formsemestre_id"], REQUEST=REQUEST) -bul = sco_bulletins.formsemestre_bulletinetud_dict(context.Notes, sem["formsemestre_id"], etud1["etudid"]) -print(bul["ins"][0]["etat"]) -#assert bul["ins"][0]["etat"] == "I" - -# --- Fonctions retournant HTML - -find = sco_find_etud.search_etud_in_dept(context.Scolarite, expnom="Poire", REQUEST=REQUEST) - -_ = context.Scolarite.fillEtudsInfo(etuds=[etud1]) - -""" -Commentaire : - -L'etat ne se met pas à jour après l'annulation de la démission ou de la défaillance. - -etud_info ne donne pas toutes les infos de l'étudiant voir mini test create_etud. - -""" \ No newline at end of file From 401bbf103d2290fe5bbb427f92ceadca896d63ec Mon Sep 17 00:00:00 2001 From: root Date: Thu, 10 Jun 2021 16:10:02 +0200 Subject: [PATCH 9/9] =?UTF-8?q?unicit=C3=A9=20des=20noms=20etudiants?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scotests/test_scenario2_formation.py | 16 ++++++++-------- scotests/test_scenario3_formation.py | 16 ++++++++-------- scotests/test_scenario4_formation.py | 16 ++++++++-------- 3 files changed, 24 insertions(+), 24 deletions(-) diff --git a/scotests/test_scenario2_formation.py b/scotests/test_scenario2_formation.py index 4a77544a..b2a1bd63 100755 --- a/scotests/test_scenario2_formation.py +++ b/scotests/test_scenario2_formation.py @@ -75,14 +75,14 @@ for mod in li_module : etuds=[] for nom, prenom in [ - ("Semestre1", "EtudiantNumero1"), - ("Semestre1", "EtudiantNumero2"), - ("Semestre2", "EtudiantNumero3"), - ("Semestre2", "EtudiantNumero4"), - ("Semestre3", "EtudiantNumero5"), - ("Semestre3", "EtudiantNumero6"), - ("Semestre4", "EtudiantNumero7"), - ("Semestre4", "EtudiantNumero8") + ("Semestre11", "EtudiantNumero1"), + ("Semestre12", "EtudiantNumero2"), + ("Semestre23", "EtudiantNumero3"), + ("Semestre24", "EtudiantNumero4"), + ("Semestre35", "EtudiantNumero5"), + ("Semestre36", "EtudiantNumero6"), + ("Semestre47", "EtudiantNumero7"), + ("Semestre48", "EtudiantNumero8") ] : etud = G.create_etud( nom=nom, diff --git a/scotests/test_scenario3_formation.py b/scotests/test_scenario3_formation.py index 83f6b212..b814690c 100755 --- a/scotests/test_scenario3_formation.py +++ b/scotests/test_scenario3_formation.py @@ -76,14 +76,14 @@ for mod in li_module : etuds=[] for nom, prenom in [ - ("Semestre1", "EtudiantNumero1"), - ("Semestre1", "EtudiantNumero2"), - ("Semestre2", "EtudiantNumero3"), - ("Semestre2", "EtudiantNumero4"), - ("Semestre3", "EtudiantNumero5"), - ("Semestre3", "EtudiantNumero6"), - ("Semestre4", "EtudiantNumero7"), - ("Semestre4", "EtudiantNumero8") + ("Semestre11", "EtudiantNumero1"), + ("Semestre12", "EtudiantNumero2"), + ("Semestre23", "EtudiantNumero3"), + ("Semestre24", "EtudiantNumero4"), + ("Semestre35", "EtudiantNumero5"), + ("Semestre36", "EtudiantNumero6"), + ("Semestre47", "EtudiantNumero7"), + ("Semestre48", "EtudiantNumero8") ] : etud = G.create_etud( nom=nom, diff --git a/scotests/test_scenario4_formation.py b/scotests/test_scenario4_formation.py index 7b753afc..17f91794 100755 --- a/scotests/test_scenario4_formation.py +++ b/scotests/test_scenario4_formation.py @@ -77,14 +77,14 @@ for mod in li_module : etuds=[] for nom, prenom in [ - ("Semestre1", "EtudiantNumero1"), - ("Semestre1", "EtudiantNumero2"), - ("Semestre2", "EtudiantNumero3"), - ("Semestre2", "EtudiantNumero4"), - ("Semestre3", "EtudiantNumero5"), - ("Semestre3", "EtudiantNumero6"), - ("Semestre4", "EtudiantNumero7"), - ("Semestre4", "EtudiantNumero8") + ("Semestre11", "EtudiantNumero1"), + ("Semestre12", "EtudiantNumero2"), + ("Semestre23", "EtudiantNumero3"), + ("Semestre24", "EtudiantNumero4"), + ("Semestre35", "EtudiantNumero5"), + ("Semestre36", "EtudiantNumero6"), + ("Semestre47", "EtudiantNumero7"), + ("Semestre48", "EtudiantNumero8") ] : etud = G.create_etud( nom=nom,