From 079e39ff54415ff9df0df9ac4df32a61f67d71da Mon Sep 17 00:00:00 2001 From: Emmanuel Viennet Date: Fri, 2 Jul 2021 12:34:44 +0200 Subject: [PATCH] =?UTF-8?q?tests=20unitaires=20de=20ScoDoc7=20=C3=A0=20rev?= =?UTF-8?q?oir=20pour=20ScoDoc8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scotests/test_AnnuleAbsencesDatesNoJust.py | 59 +++ scotests/test_CountAbs.py | 108 ++++++ scotests/test_abs_demijournee.py | 117 ++++++ scotests/test_absence.py | 266 ++++++++++++++ scotests/test_absence2.py | 267 ++++++++++++++ scotests/test_api7doc.py | 261 ++++++++++++++ scotests/test_billet.py | 96 +++++ scotests/test_create_etud.py | 47 +++ scotests/test_deleteBilletAbsence.py | 69 ++++ scotests/test_etudiant.py | 135 +++++++ scotests/test_evaluation.py | 257 ++++++++++++++ scotests/test_evaluation_suppress_alln.py | 75 ++++ scotests/test_formation_export_xml.py | 79 +++++ scotests/test_formations.py | 319 +++++++++++++++++ scotests/test_groupes.py | 395 +++++++++++++++++++++ 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 | 173 +++++++++ scotests/test_user.py | 75 ++++ 21 files changed, 3227 insertions(+) create mode 100644 scotests/test_AnnuleAbsencesDatesNoJust.py create mode 100644 scotests/test_CountAbs.py create mode 100644 scotests/test_abs_demijournee.py create mode 100644 scotests/test_absence.py create mode 100644 scotests/test_absence2.py create mode 100644 scotests/test_api7doc.py create mode 100644 scotests/test_billet.py create mode 100644 scotests/test_create_etud.py create mode 100644 scotests/test_deleteBilletAbsence.py create mode 100644 scotests/test_etudiant.py create mode 100644 scotests/test_evaluation.py create mode 100644 scotests/test_evaluation_suppress_alln.py create mode 100644 scotests/test_formation_export_xml.py create mode 100644 scotests/test_formations.py create mode 100644 scotests/test_groupes.py create mode 100644 scotests/test_scenario1_app.py create mode 100644 scotests/test_scenario1_formation.py create mode 100644 scotests/test_scenario2_formation.py create mode 100644 scotests/test_scenario3_formation.py create mode 100644 scotests/test_scenario4_formation.py create mode 100644 scotests/test_user.py diff --git a/scotests/test_AnnuleAbsencesDatesNoJust.py b/scotests/test_AnnuleAbsencesDatesNoJust.py new file mode 100644 index 0000000000..dce5c1b595 --- /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 100644 index 0000000000..25057b5215 --- /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_abs_demijournee.py b/scotests/test_abs_demijournee.py new file mode 100644 index 0000000000..84582a242c --- /dev/null +++ b/scotests/test_abs_demijournee.py @@ -0,0 +1,117 @@ +""" 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 +# 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 + +""" +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 new file mode 100644 index 0000000000..6c2fdd9286 --- /dev/null +++ b/scotests/test_absence.py @@ -0,0 +1,266 @@ +""" 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 + - EtatAbsenceGr + - AddBilletAbsence + - listeBilletsEtud + + """ + + +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'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"] + +_ = 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='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 + +_ = 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 + +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"] + +# --- 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_absence2.py b/scotests/test_absence2.py new file mode 100644 index 0000000000..2cb303cb04 --- /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 100644 index 0000000000..a1d6133ac1 --- /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 100644 index 0000000000..a44f9668b4 --- /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_create_etud.py b/scotests/test_create_etud.py new file mode 100644 index 0000000000..9430538a81 --- /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_deleteBilletAbsence.py b/scotests/test_deleteBilletAbsence.py new file mode 100644 index 0000000000..db605ae052 --- /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_etudiant.py b/scotests/test_etudiant.py new file mode 100644 index 0000000000..cb10fda674 --- /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_evaluation.py b/scotests/test_evaluation.py new file mode 100644 index 0000000000..9b7b19c8af --- /dev/null +++ b/scotests/test_evaluation.py @@ -0,0 +1,257 @@ +""" 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 + +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 +# 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 = 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 + +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 + + +""" +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 new file mode 100644 index 0000000000..89106f03ca --- /dev/null +++ b/scotests/test_evaluation_suppress_alln.py @@ -0,0 +1,75 @@ +""" 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: +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"] + +""" +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_formation_export_xml.py b/scotests/test_formation_export_xml.py new file mode 100644 index 0000000000..5917745137 --- /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:]) diff --git a/scotests/test_formations.py b/scotests/test_formations.py new file mode 100644 index 0000000000..764d00ea9d --- /dev/null +++ b/scotests/test_formations.py @@ -0,0 +1,319 @@ +""" 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 \ No newline at end of file diff --git a/scotests/test_groupes.py b/scotests/test_groupes.py new file mode 100644 index 0000000000..745890f011 --- /dev/null +++ b/scotests/test_groupes.py @@ -0,0 +1,395 @@ +""" 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 é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) +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) + +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 + + +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 #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 +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 + +""" +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. + +""" + + + + + + + + + + + + + + + + diff --git a/scotests/test_scenario1_app.py b/scotests/test_scenario1_app.py new file mode 100644 index 0000000000..1d88e9b1d0 --- /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 100644 index 0000000000..6adf1bd868 --- /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 100644 index 0000000000..b2a1bd63aa --- /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 [ + ("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) \ No newline at end of file diff --git a/scotests/test_scenario3_formation.py b/scotests/test_scenario3_formation.py new file mode 100644 index 0000000000..b814690cbc --- /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 [ + ("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) \ No newline at end of file diff --git a/scotests/test_scenario4_formation.py b/scotests/test_scenario4_formation.py new file mode 100644 index 0000000000..17f9179498 --- /dev/null +++ b/scotests/test_scenario4_formation.py @@ -0,0 +1,173 @@ +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 [ + ("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) \ No newline at end of file diff --git a/scotests/test_user.py b/scotests/test_user.py new file mode 100644 index 0000000000..eb803620d9 --- /dev/null +++ b/scotests/test_user.py @@ -0,0 +1,75 @@ +""" 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 +# 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_user_list_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 ! + +# --- Récupérer user_name à partir de nomplogin + +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