forked from ScoDoc/ScoDoc
348 lines
11 KiB
Python
348 lines
11 KiB
Python
# -*- mode: python -*-
|
|
# -*- coding: utf-8 -*-
|
|
|
|
""" Test creation/edition/import/export formations
|
|
"""
|
|
|
|
# test écrit par Fares Amer, mai 2021 et porté sur ScoDoc 8 en juillet 2021
|
|
|
|
# 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 bons
|
|
# 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 suppression
|
|
#
|
|
# Fonction de l'API utilisé :
|
|
#
|
|
# - create_formation
|
|
# - create_ue
|
|
# - create_matiere
|
|
# - create_module
|
|
# - create_formsemestre
|
|
# - create_moduleimpl
|
|
# - formation_export
|
|
# - formsemestre_list
|
|
# - do_module_impl_with_module_list
|
|
# - do_formsemestre_delete
|
|
# - Module.delete
|
|
# - ue_list
|
|
# - do_ue_delete
|
|
# - do_formation_delete
|
|
|
|
import json
|
|
import os
|
|
|
|
import pytest
|
|
|
|
from app import db
|
|
from app.formations import (
|
|
edit_formation,
|
|
edit_module,
|
|
edit_ue,
|
|
formation_io,
|
|
)
|
|
from app.models import Formation, Matiere, Module, ModuleImpl, UniteEns
|
|
from app.scodoc import sco_formsemestre
|
|
from app.scodoc import sco_exceptions
|
|
from app.scodoc import sco_formsemestre_edit
|
|
from app.scodoc import sco_moduleimpl
|
|
from app.views import notes
|
|
|
|
from tests.conftest import RESOURCES_DIR
|
|
from tests.unit import sco_fake_gen
|
|
|
|
|
|
def test_formations(test_client):
|
|
"""Test création/édition/import/export formations"""
|
|
G = sco_fake_gen.ScoFake(verbose=False)
|
|
|
|
# --- Création de formations
|
|
|
|
formation_id = G.create_formation(
|
|
acronyme="F1", titre="Formation 1", titre_officiel="Titre officiel 1"
|
|
)
|
|
# --- Objet Formation
|
|
formation = db.session.get(Formation, formation_id)
|
|
assert isinstance(formation, Formation)
|
|
assert formation.acronyme == "F1"
|
|
assert formation.titre == "Formation 1"
|
|
assert formation.titre_officiel == "Titre officiel 1"
|
|
assert formation.dept_id
|
|
f_dict = formation.to_dict()
|
|
assert isinstance(f_dict, dict)
|
|
fields = {
|
|
"acronyme",
|
|
"titre_officiel",
|
|
"commentaire",
|
|
"departement",
|
|
"formation_id",
|
|
"type_parcours",
|
|
"code_specialite",
|
|
"referentiel_competence_id",
|
|
"id",
|
|
"version",
|
|
"formation_code",
|
|
"dept_id",
|
|
"titre",
|
|
}
|
|
assert set(f_dict.keys()) == fields
|
|
f_dict = formation.to_dict(with_departement=False)
|
|
assert set(f_dict.keys()) == fields - {"departement"}
|
|
|
|
# Création des UEs, matières, modules
|
|
ue_id = G.create_ue(formation_id=formation_id, acronyme="TST1", titre="ue test")
|
|
matiere_id = G.create_matiere(ue_id=ue_id, titre="matière test")
|
|
module_id = G.create_module(
|
|
matiere_id=matiere_id,
|
|
code="TSM1",
|
|
coefficient=1.0,
|
|
titre="module test",
|
|
)
|
|
|
|
ue_id2 = G.create_ue(formation_id=formation_id, acronyme="TST2", titre="ue test2")
|
|
matiere_id2 = G.create_matiere(ue_id=ue_id2, titre="matière test2")
|
|
module_id2 = G.create_module(
|
|
matiere_id=matiere_id2,
|
|
code="TSM2",
|
|
coefficient=1.0,
|
|
titre="module test",
|
|
)
|
|
|
|
uet_id = G.create_ue(formation_id=formation_id, acronyme="TSTt", titre="ue testt")
|
|
matiere_id3 = G.create_matiere(ue_id=uet_id, titre="matière testt")
|
|
module_id_t = G.create_module(
|
|
matiere_id=matiere_id3,
|
|
code="TSMt",
|
|
coefficient=1.0,
|
|
titre="module test",
|
|
)
|
|
|
|
formation_id2 = G.create_formation(acronyme="", titre="Formation test")
|
|
assert db.session.get(Formation, formation_id2)
|
|
ue3 = G.create_ue(formation_id=formation_id2, acronyme="TST3", titre="ue test3")
|
|
matiere_id4 = G.create_matiere(ue_id=ue3, titre="matière test3")
|
|
module_id3 = G.create_module(
|
|
matiere_id=matiere_id4,
|
|
code="TSM3",
|
|
coefficient=1.0,
|
|
titre="module test3",
|
|
)
|
|
|
|
# --- Création et implémentation des semestres
|
|
|
|
formsemestre_id1 = G.create_formsemestre(
|
|
formation_id=formation_id,
|
|
semestre_id=1,
|
|
date_debut="01/01/2021",
|
|
date_fin="30/06/2021",
|
|
)
|
|
|
|
formsemestre_id2 = G.create_formsemestre(
|
|
formation_id=formation_id,
|
|
semestre_id=2,
|
|
date_debut="01/09/2020",
|
|
date_fin="31/12/2020",
|
|
)
|
|
|
|
moduleimpl_id = G.create_moduleimpl(
|
|
module_id=module_id,
|
|
formsemestre_id=formsemestre_id1,
|
|
)
|
|
|
|
_ = G.create_moduleimpl(
|
|
module_id=module_id2,
|
|
formsemestre_id=formsemestre_id1,
|
|
)
|
|
|
|
_ = G.create_moduleimpl(
|
|
module_id=module_id_t,
|
|
formsemestre_id=formsemestre_id2,
|
|
)
|
|
|
|
formsemestre_idt = G.create_formsemestre(
|
|
formation_id=formation_id2,
|
|
semestre_id=3,
|
|
date_debut="01/01/2021",
|
|
date_fin="30/06/2021",
|
|
)
|
|
|
|
mi3 = G.create_moduleimpl(
|
|
module_id=module_id3,
|
|
formsemestre_id=formsemestre_idt,
|
|
)
|
|
|
|
# --- Export de formation vers JSON
|
|
exp = formation_io.formation_export(
|
|
formation_id=formation_id, fmt="json", export_ids=True
|
|
).get_data(as_text=True)
|
|
assert isinstance(exp, str)
|
|
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"] == formation.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"] == formation_id
|
|
|
|
# --- Liste des semestres
|
|
|
|
li_sem1 = notes.formsemestre_list(
|
|
formsemestre_id=formsemestre_id1, fmt="json"
|
|
).get_data(as_text=True)
|
|
assert isinstance(li_sem1, str)
|
|
load_li_sem1 = json.loads(li_sem1) # uniquement le semestre 1 dans la liste
|
|
|
|
assert len(load_li_sem1) == 1
|
|
sem1 = sco_formsemestre.get_formsemestre(formsemestre_id1)
|
|
assert load_li_sem1[0]["date_fin"] == sem1["date_fin"]
|
|
assert load_li_sem1[0]["semestre_id"] == sem1["semestre_id"]
|
|
assert load_li_sem1[0]["formation_id"] == sem1["formation_id"]
|
|
|
|
li_semf = notes.formsemestre_list(
|
|
formation_id=formation_id,
|
|
fmt="json",
|
|
).get_data(as_text=True)
|
|
assert isinstance(li_semf, str)
|
|
load_li_semf = json.loads(li_semf)
|
|
|
|
assert load_li_sem1[0] in load_li_semf
|
|
assert len(load_li_semf) == 2
|
|
sem2 = sco_formsemestre.get_formsemestre(formsemestre_id2)
|
|
assert load_li_semf[1]["semestre_id"] == sem2["semestre_id"]
|
|
|
|
li_sem = notes.formsemestre_list(fmt="json").get_data(as_text=True)
|
|
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
|
|
|
|
# --- Liste des modules
|
|
|
|
lim_sem1 = (
|
|
db.session.query(ModuleImpl)
|
|
.filter_by(formsemestre_id=sem1["formsemestre_id"])
|
|
.all()
|
|
)
|
|
assert len(lim_sem1) == 2
|
|
assert module_id in (lim_sem1[0].module_id, lim_sem1[1].module_id)
|
|
assert module_id2 in (lim_sem1[0].module_id, lim_sem1[1].module_id)
|
|
|
|
lim_modid = db.session.query(ModuleImpl).filter_by(module_id=module_id).all()
|
|
assert len(lim_modid) == 1
|
|
|
|
# --- Suppression du module, matiere et ue test du semestre 2
|
|
|
|
# on doit d'abord supprimer le semestre:
|
|
|
|
sco_formsemestre_edit.do_formsemestre_delete(
|
|
formsemestre_id=sem2["formsemestre_id"]
|
|
)
|
|
|
|
li_module = Module.query.all()
|
|
assert len(li_module) == 4
|
|
# Suppression impossible car utilisé dans le semestre formsemestre_idt:
|
|
module3 = db.session.get(ModuleImpl, mi3).module
|
|
with pytest.raises(sco_exceptions.ScoNonEmptyFormationObject):
|
|
edit_module.module_delete(module_id=module3.id)
|
|
|
|
sco_formsemestre_edit.do_formsemestre_delete(formsemestre_idt)
|
|
|
|
li_module2_before = Module.query.all()
|
|
|
|
module3.delete()
|
|
module_t = db.session.get(Module, module_id_t)
|
|
module_t.delete()
|
|
|
|
# deuxieme methode de supression d'un module
|
|
li_module2_after = Module.query.all()
|
|
|
|
assert (
|
|
len(li_module2_after) == len(li_module2_before) - 2
|
|
) # verification de la suppression
|
|
|
|
lim_sem2 = (
|
|
db.session.query(ModuleImpl)
|
|
.filter_by(formsemestre_id=sem2["formsemestre_id"])
|
|
.all()
|
|
)
|
|
assert len(lim_sem2) == 0 # deuxieme vérification si le module s'est bien sup
|
|
|
|
li_mat = Matiere.query.all()
|
|
assert len(li_mat) == 4
|
|
assert matiere_id3 in [m.matiere_id for m in li_mat]
|
|
matiere = db.session.get(Matiere, matiere_id3)
|
|
matiere.delete() # on supprime la matiere
|
|
li_mat2 = Matiere.query.all()
|
|
assert len(li_mat2) == 3 # verification de la suppression de la matiere
|
|
|
|
assert UniteEns.query.count() == 4
|
|
edit_ue.ue_delete(ue_id=uet_id, dialog_confirmed=True)
|
|
assert UniteEns.query.count() == 3 # verification de la suppression de l'UE
|
|
|
|
# --- Suppression d'une formation
|
|
|
|
edit_formation.do_formation_delete(formation_id=formation_id2)
|
|
formation = db.session.get(Formation, formation_id2)
|
|
assert formation is None
|
|
|
|
|
|
def test_import_formation(test_client, filename="formation-exemple-1.xml"):
|
|
"""Test import/export formations"""
|
|
G = sco_fake_gen.ScoFake(verbose=False)
|
|
|
|
# Lecture fichier XML local:
|
|
with open(
|
|
os.path.join(RESOURCES_DIR, "formations", filename),
|
|
encoding="utf-8",
|
|
) as f:
|
|
doc = f.read()
|
|
|
|
# --- Création de la formation
|
|
f = formation_io.formation_import_xml(doc)
|
|
assert len(f) == 3 # 3-uple
|
|
formation_id = f[0]
|
|
# --- Vérification des UE
|
|
ues = UniteEns.query.filter_by(formation_id=formation_id).all()
|
|
assert len(ues) == 10
|
|
assert all(not ue.is_external for ue in ues) # aucune UE externe dans le XML
|
|
# --- Mise en place de 4 semestres
|
|
formsemestre_ids = [
|
|
G.create_formsemestre(
|
|
formation_id=formation_id,
|
|
semestre_id=x[0],
|
|
date_debut=x[1],
|
|
date_fin=x[2],
|
|
)
|
|
for x in (
|
|
(1, "05/09/2019", "05/01/2020"),
|
|
(2, "06/01/2020", "30/06/2020"),
|
|
(3, "01/09/2020", "05/01/2021"),
|
|
(4, "06/01/2021", "30/06/2021"),
|
|
)
|
|
]
|
|
# et les modules
|
|
formation = Formation.get_formation(formation_id)
|
|
for mod in formation.modules:
|
|
moduleimpl_id = G.create_moduleimpl(
|
|
module_id=mod.id,
|
|
formsemestre_id=formsemestre_ids[mod.semestre_id - 1],
|
|
)
|
|
mi = db.session.get(ModuleImpl, moduleimpl_id)
|
|
assert mi.module_id == mod.id
|
|
|
|
# --- Export formation en XML
|
|
doc1 = formation_io.formation_export(formation_id, fmt="xml").get_data(as_text=True)
|
|
assert isinstance(doc1, str)
|