def __ex_valori_note(self,repoNota):
id_disc = 1
disc = Disciplina(id_disc,"Analiza","Berinde")
disc2 = Disciplina(3,"ASC","Vancea")
disc3 = Disciplina(4,"LC","Pop")
repoNota.adauga_nota(Nota(1,Student(1,"nutu"),disc,5))
repoNota.adauga_nota(Nota(10,Student(7,"bologneze"),disc2,9))
repoNota.adauga_nota(Nota(2,Student(2,"andrei"),disc,10))
repoNota.adauga_nota(Nota(5,Student(4,"aandrei"),disc,4.5))
repoNota.adauga_nota(Nota(8,Student(2,"andrei"),disc2,8.6))
repoNota.adauga_nota(Nota(3,Student(2,"andrei"),disc3,1))
repoNota.adauga_nota(Nota(9,Student(1,"nutu"),disc,7))
def test_validareDisc(self):
validDisc = ValidatorDisciplina()
id_disc = 1
nume_disc = "Analiza"
nume_prof = "Berinde Stefan"
disc = Disciplina(id_disc, nume_disc, nume_prof)
validDisc.valideaza_disc(disc)
disc_gresit = Disciplina(-1, "", "")
try:
validDisc.valideaza_disc(disc_gresit)
assert False
except ValidError as ve:
assert str(
ve
) == "Id disciplina invalid!Nume disciplina invalid!Nume profesor invalid!"
def test_sterge_get_disc(self):
self.__srvDisc.sterge_disc(1)
self.assertEqual(self.__srvDisc.get_discipline(),[Disciplina(0,"Analiza","Berinde")])
self.assertRaisesRegex(RepoError,"Disciplina inexistenta!",self.__srvDisc.sterge_disc,1)
self.assertRaisesRegex(RepoError,"Disciplina inexistenta!",self.__srvDisc.sterge_disc,99)
self.__srvDisc.sterge_discipline()
self.assertEqual(len(self.__srvDisc),0)
def test_domeniuNota(self):
id_nota = 0
id_stud = 3
nume_stud = "Mircea Augustin"
stud = Student(id_stud,nume_stud)
id_disc = 2
nume_disc = "Analiza"
nume_prof = "Berinde Stefan"
disc = Disciplina(id_disc,nume_disc,nume_prof)
val_nota = 9.5
nota = Nota(id_nota,stud,disc,val_nota)
assert nota.get_id_nota() == id_nota
assert nota.get_stud() == stud
assert nota.get_disc() == disc
assert abs(nota.get_val_nota() - val_nota) < 0.0001
nota2 = Nota(id_nota,Student(0,"a"),Disciplina(0,"a","a"),5.4)
assert nota == nota2
def setUp(self):
self.__repoStud = RepositoryStud()
self.__repoStud.adauga_stud(Student(0,"Chef Dumitrescu"))
self.__repoStud.adauga_stud(Student(1,"Chef Scarlatescu"))
self.__repoStud.adauga_stud(Student(2,"Chef Bontea"))
self.__repoStud.adauga_stud(Student(3,"Chef Dorin"))
self.__repoDisc = RepositoryDisc()
self.__repoDisc.adauga_disc(Disciplina(0,"Analiza","Berinde"))
self.__repoDisc.adauga_disc(Disciplina(1,"Algebra","Mo2"))
self.__repoDisc.adauga_disc(Disciplina(2,"Logica","Pop"))
self.__repoNota = RepositoryNota()
self.__srvNota = ServiceNota( self.__repoNota, ValidatorNota(), self.__repoStud, ValidatorStudent(), self.__repoDisc, ValidatorDisciplina(),)
self.__srvNota.adauga_nota(0,0,0,10)
self.__srvNota.adauga_nota(2,0,1,10)
self.__srvNota.adauga_nota(4,0,2,10)
self.__srvNota.adauga_nota(1,1,1,4.5)
self.__srvNota.adauga_nota(3,2,1,7.5)
self.__srvNota.adauga_nota(5,1,2,9.5)
def test_func(self):
repoStud = RepositoryStud()
srvNota = ServiceNota(RepositoryNota(),ValidatorNota(),repoStud,ValidatorStudent(),RepositoryDisc(),ValidatorDisciplina())
note_disc = [["nutu",5],["andrei",10],["aandrei",4.5],["nutu",7],["cosmin",10]]
srvNota.sort_by_nume_stud(note_disc)
assert note_disc == [["aandrei",4.5],["andrei",10],["cosmin",10],["nutu",7],["nutu",5]]
note_disc2 = []
srvNota.sort_by_nume_stud(note_disc2)
assert note_disc2 == []
note_disc3 = [["nutu",5],["cosmin",10],["andrei",10],["aandrei",4.5],["nutu",7]]
srvNota.sort_by_nota(note_disc3)
assert note_disc3 == [["andrei",10],["cosmin",10],["nutu",7],["nutu",5],["aandrei",4.5]]
note_disc4 = []
srvNota.sort_by_nota(note_disc4)
assert note_disc4 == []
s1 = Student(1,"Chef Scarlatescu")
s2 = Student(2,"Chef Dumitrescu")
s3 = Student(5,"Turturica Dorin")
repoStud.adauga_stud(s1)
repoStud.adauga_stud(s2)
repoStud.adauga_stud(Student(3,"Messi"))
repoStud.adauga_stud(Student(4,"Ronaldo"))
repoStud.adauga_stud(s3)
repoStud.adauga_stud(Student(6,"a"))
repoStud.adauga_stud(Student(7,"b"))
repoStud.adauga_stud(Student(8,"c"))
repoStud.adauga_stud(Student(9,"d"))
repoStud.adauga_stud(Student(10,"e"))
studenti = repoStud.get_studenti()
d1 = Disciplina(1,"Analiza","Berinde")
d2 = Disciplina(2,"Algebra","Mo2")
d3 = Disciplina(4,"ASC","Vancea")
note = [Nota(1,s1,d1,9.95),Nota(2,s2,d2,5),Nota(3,s2,d1,9.80),Nota(4,s2,d1,7),Nota(6,s1,d3,9),Nota(7,s3,d1,10)]
medii = srvNota.get_lista_nume_si_medie(studenti,note)
assert abs(medii[0][1]-9.475) < 0.001
assert abs(medii[1][1]-7.2666) < 0.1
assert abs(medii[4][1]-10) < 0.001
assert abs(medii[2][1]-0) < 0.001
def test_repoDiscFile(self, repoDiscF):
lung_init = len(repoDiscF)
assert lung_init == 3
self.test_repoDisc(repoDiscF, lung_init)
id_disc = 1
disc = Disciplina(id_disc, "a", "a")
try:
repoDiscF.adauga_disc(disc)
assert False
except RepoError as re:
assert str(re) == "Disciplina existenta!"
def adauga_disc(self, id_disc, nume_disc, nume_prof):
"""
metoda care adauga disciplina | sau eroare daca exista deja
date de intrare:
disc-disciplina pe care vrem sa o aduagam
date de iesire:-
date de exceptie:
RepoError-"Disciplina existenta!"
"""
disc = Disciplina(id_disc, nume_disc, nume_prof)
self._validDisc.valideaza_disc(disc)
self._repoDisc.adauga_disc(disc)
return disc
def modifica_disc(self, id_disc, nume_disc, nume_prof):
"""
metoda care modifica disciplina dupa id, id-ul ramanand la fel | sau eroare daca nu o gaseste
date de intrare:
disc_modif-inlocuitorul disciplinei pe care vrem s-o schimbam
date de iesire:-
date de exceptie:
RepoError-"Disciplina inexistenta!"
"""
disc_modif = Disciplina(id_disc, nume_disc, nume_prof)
self._validDisc.valideaza_disc(disc_modif)
disc_precedent = self._repoDisc.modifica_disc(disc_modif)
return [disc_precedent, disc_modif]
def cauta_disc(self, id_disc):
"""
metoda care returneaza o disciplina dupa id | sau eroare daca nu o gaseste
date de intrare:
id_disc-idul disciplinei pe care o cautam
date de iesire:
self._discipline[i]-disciplina pe care o cautam
date de exceptie:
RepoError-"Disciplina inexistenta!"
"""
key_disc = Disciplina(id_disc, "anything", "anything")
self._validDisc.valideaza_disc(key_disc)
return self._repoDisc.cauta_disc(id_disc)
def test_srvNota(self):
repoNota = RepositoryNota()
repoDisc = RepositoryDisc()
repoDisc.adauga_disc(Disciplina(1,"Analiza","Berinde"))
srvNota = ServiceNota(repoNota,ValidatorNota(),RepositoryStud(),ValidatorStudent(),repoDisc,ValidatorDisciplina())
"""
test sotare by nume
"""
id_disc = 1
self.__ex_valori_note(repoNota)
sorted_note_disc3,nume_disc = srvNota.get_sorted_note_disc_by_nume_sau_nota(id_disc,0)
assert sorted_note_disc3 == [["aandrei",4.5],["andrei",10],["nutu",7],["nutu",5]]
assert nume_disc == "Analiza"
def test_validareNota(self):
validNota = ValidatorNota()
id_nota = 0
stud = Student(3,"Mircea Augustin")
disc = Disciplina(2,"Analiza","Berinde Stefan")
val_nota = 9.5
nota = Nota(id_nota,stud,disc,val_nota)
validNota.valideaza_nota(nota)
nota_gresita = Nota(-1,stud,disc,10.3)
try:
validNota.valideaza_nota(nota_gresita)
assert False
except ValidError as ve:
assert str(ve) == ("Id nota invalid! Valoare nota invalida!")
def __load_discipline(self):
"""
metoda care incarca toate disciplinele din fisier
date de intrare:-
date de iesire:-
exceptii:-
"""
with open(self.__file, "r") as fd:
for line in fd:
atr_disc = line.split(",")
for i in range(len(atr_disc)):
atr_disc[i] = atr_disc[i].strip()
atr_disc[0] = int(atr_disc[0])
disc = Disciplina(atr_disc[0], atr_disc[1], atr_disc[2])
self._discipline.append(disc)
def test_domeniuDisc(self):
id_disc = 1
nume_disc = "Analiza"
nume_prof = "Berinde Stefan"
disc = Disciplina(id_disc, nume_disc, nume_prof)
assert disc.get_id_disc() == id_disc
assert disc.get_nume_disc() == nume_disc
assert disc.get_nume_prof() == nume_prof
assert str(disc) == "1 | Analiza | Berinde Stefan"
disc2 = Disciplina(id_disc, "Logica", "Pop")
assert disc == disc2
def __load_note(self):
"""
metoda care incarca toate notele din fisier
date de intrare:-
date de iesire:-
exceptii:-
"""
with open(self.__file, "r") as fn:
for line in fn:
atr_nota = line.split(",")
for i in range(len(atr_nota)):
atr_nota[i] = atr_nota[i].strip()
atr_nota[0] = int(atr_nota[0])
atr_nota[1] = int(atr_nota[1])
atr_nota[3] = int(atr_nota[3])
atr_nota[6] = float(atr_nota[6])
nota = Nota(atr_nota[0], Student(atr_nota[1], atr_nota[2]),
Disciplina(atr_nota[3], atr_nota[4], atr_nota[5]),
atr_nota[6])
self._note.append(nota)
def test_repoDisc(self, repoDisc, lung_init):
assert len(repoDisc) == 0 + lung_init
id_disc = 0
nume_disc = "Analiza"
nume_prof = "Berinde Stefan"
disc = Disciplina(id_disc, nume_disc, nume_prof)
repoDisc.adauga_disc(disc)
assert len(repoDisc) == 1 + lung_init
try:
repoDisc.adauga_disc(disc)
assert False
except RepoError as re:
assert str(re) == "Disciplina existenta!"
disc_modif = Disciplina(id_disc, "Algebra", "Modoi")
repoDisc.modifica_disc(disc_modif)
assert disc_modif.get_nume_disc() == "Algebra"
assert disc_modif.get_nume_prof() == "Modoi"
disc_modif_gresit = Disciplina(id_disc + 99, "Logica", "Pop")
try:
repoDisc.modifica_disc(disc_modif_gresit)
assert False
except RepoError as re:
assert str(re) == "Disciplina inexistenta!"
gasit = repoDisc.cauta_disc(id_disc)
assert gasit == disc_modif
try:
repoDisc.cauta_disc(id_disc + 99)
assert False
except RepoError as re:
assert str(re) == "Disciplina inexistenta!"
discipline = repoDisc.get_discipline()
assert len(discipline) == 1 + lung_init
repoDisc.sterge_disc(id_disc)
assert len(repoDisc) == 0 + lung_init
try:
repoDisc.sterge_disc(id_disc)
assert False
except RepoError as re:
assert str(re) == "Disciplina inexistenta!"
def test_sterge_note_disc(self):
self.__repoNota.sterge_note_disc(1)
note = [Nota(0,Student(0,"Chef Scarlatescu"),Disciplina(0,"Analiza","Berinde"),10)]
self.assertEqual(self.__repoNota.get_note(),note)
self.__repoNota.sterge_note_disc(99)
self.assertEqual(self.__repoNota.get_note(),note)
def test_get_note_by_disc(self):
self.assertEqual(self.__repoNota.get_note_by_disc(Disciplina(1,"Algebra","Modoi")),[["Chef Dumitrescu",4.5],["Chef Scarlatescu",8.55]])
self.assertEqual(self.__repoNota.get_note_by_disc(Disciplina(0,"Analiza","Berinde")),[["Chef Scarlatescu",10]])
self.assertEqual(self.__repoNota.get_note_by_disc(Disciplina(99,"a","a")),[])
def test_modifica_stud_note(self):
self.__repoNota.modifica_stud_note(Student(0,"Chef Bontea"))
note = [Nota(0,Student(0,"Chef Bontea"),Disciplina(0,"Analiza","Berinde"),10), Nota(1,Student(1,"Chef Dumitrescu"),Disciplina(1,"Algebra","Modoi"),4.5), Nota(3,Student(0,"Chef Bontea"),Disciplina(1,"Algebra","Modoi"),8.55)]
self.assertEqual(self.__repoNota.get_note(),note)
self.__repoNota.modifica_stud_note(Student(99,"a"))
self.assertEqual(self.__repoNota.get_note(),note)
def test_sterge_note_stud(self):
self.__repoNota.sterge_note_stud(0)
note = [Nota(1,Student(1,"Chef Dumitrescu"),Disciplina(1,"Algebra","Modoi"),4.5)]
self.assertEqual(self.__repoNota.get_note(),note)
self.__repoNota.sterge_note_stud(99)
self.assertEqual(self.__repoNota.get_note(),note)
def test_modifica_disc_note(self):
self.__repoNota.modifica_disc_note(Disciplina(1,"Logica","Pop"))
note = [Nota(0,Student(0,"Chef Scarlatescu"),Disciplina(0,"Analiza","Berinde"),10), Nota(1,Student(1,"Chef Dumitrescu"),Disciplina(1,"Logica","Pop"),4.5), Nota(3,Student(0,"Chef Scarlatescu"),Disciplina(1,"Logica","Pop"),8.55)]
self.assertEqual(self.__repoNota.get_note(),note)
self.__repoNota.modifica_disc_note(Disciplina(99,"a","a"))
self.assertEqual(self.__repoNota.get_note(),note)
def test_sterge_get_nota(self):
self.__repoNota.sterge_nota(1)
self.assertEqual(self.__repoNota.get_note(),[Nota(0,Student(0,"Chef Scarlatescu"),Disciplina(0,"Analiza","Berinde"),10),Nota(3,Student(0,"Chef Scarlatescu"),Disciplina(1,"Algebra","Modoi"),8.55)])
self.assertRaisesRegex(RepoError,"Nota inexistenta!",self.__repoNota.sterge_nota,99)
self.__repoNota.sterge_note()
self.assertEqual(len(self.__repoNota),0)
def test_modifica_cauta_nota(self):
self.__srvNota.modifica_nota(3,1,0,2.5)
self.assertEqual(self.__srvNota.cauta_nota(3),Nota(3,Student(1,"Chef Scarlatescu"),Disciplina(0,"Analiza","Berinde"),2.5))
self.assertRaisesRegex(RepoError,"Nota inexistenta!",self.__srvNota.modifica_nota,99,2,1,10)
self.assertRaisesRegex(RepoError,"Nota inexistenta!",self.__srvNota.cauta_nota,99)
def test_sort_by_nota(self):
note_disc = self.__repoNota.get_note_by_disc(Disciplina(1,"Algebra","Mo2"))#[['Chef Dumitrescu', 10], ['Chef Scarlatescu', 4.5], ['Chef Bontea', 7.5]]
self.__srvNota.sort_by_nota(note_disc)
self.assertEqual(note_disc,[ ['Chef Dumitrescu', 10], ['Chef Bontea', 7.5], ['Chef Scarlatescu', 4.5] ])
def setUp(self):
self.__repoNota = RepositoryNotaFile("test_unit_lista_note.txt")
self.__repoNota.adauga_nota(Nota(0,Student(0,"Chef Scarlatescu"),Disciplina(0,"Analiza","Berinde"),10))
self.__repoNota.adauga_nota(Nota(1,Student(1,"Chef Dumitrescu"),Disciplina(1,"Algebra","Modoi"),4.5))
self.__repoNota.adauga_nota(Nota(3,Student(0,"Chef Scarlatescu"),Disciplina(1,"Algebra","Modoi"),8.55))
def test_repoNotaFile(self,file,file2):
repoNotaF = RepositoryNotaFile(file)
repoNotaF2 = RepositoryNotaFile(file2)
note = repoNotaF2.get_note()
assert abs(note[0].get_val_nota()-9.95) < 0.001
repoNotaF.set_note(note)
#daca pun cele 5 valori din fisierul "valori" ca sa verific load
assert len(repoNotaF) == 6
id_nota = 1
nota_cautata = repoNotaF.cauta_nota(id_nota)
assert abs(nota_cautata.get_val_nota()-9.95) < 0.001
id_nota2 = 9
stud2 = Student(3,"Messi")
disc2 = Disciplina(5,"Sport","Prof Sport")
val_nota2 = 10
nota2 = Nota(id_nota2,stud2,disc2,val_nota2)
repoNotaF.adauga_nota(nota2) # 9,3,Messi,5,Sport,Prof Sport
assert len(repoNotaF) == 1+6
id_nota = 0
stud = Student(3,"Messi")
disc = Disciplina(2,"Analiza","Berinde Stefan")
val_nota = 9.5
nota = Nota(id_nota,stud,disc,val_nota)
repoNotaF.adauga_nota(nota)
assert len(repoNotaF) == 2+6
try:
repoNotaF.adauga_nota(nota)
assert False
except RepoError as re:
assert str(re) == "Nota existenta!"
assert len(repoNotaF) == 2+6
try:
repoNotaF.adauga_nota(Nota(1,Student(99,"a"),Disciplina(99,"a","a"),10))
assert False
except RepoError as re:
assert str(re) == "Nota existenta!"
stud2 = Student(11,"Andrei George")
nota_modif = Nota(id_nota,stud2,disc,10)
repoNotaF.modifica_nota(nota_modif)
nota_modif_gr = Nota(id_nota+99,stud2,disc,4)
try:
repoNotaF.modifica_nota(nota_modif_gr)
assert False
except RepoError as re:
assert str(re) == "Nota inexistenta!"
gasit = repoNotaF.cauta_nota(id_nota)
assert gasit == nota_modif
try:
repoNotaF.cauta_nota(id_nota+99)
assert False
except RepoError as re:
assert str(re) == "Nota inexistenta!"
tot = repoNotaF.get_note()
assert len(tot) == 2+6
try:
repoNotaF.sterge_nota(id_nota+99)
assert False
except RepoError as re:
assert str(re) == "Nota inexistenta!"
repoNotaF.sterge_nota(id_nota)
assert len(repoNotaF) == 1+6
try:
repoNotaF.sterge_nota(id_nota)
assert False
except RepoError as re:
assert str(re) == "Nota inexistenta!"
"""
test get toate notele de la o disciplina
"""
disc = Disciplina(1,"a","a")
note_disc = repoNotaF.get_note_by_disc(disc)
assert note_disc == [["Chef Scarlatescu",9.95],["Chef Dumitrescu",9.8],["Messi",7.474]]
disc2 = Disciplina(99,"a","a")
note_disc2 = repoNotaF.get_note_by_disc(disc2)
assert note_disc2 == []
"""
test sterge note de la stud
"""
id_stud = 2
repoNotaF.sterge_note_stud(id_stud)
assert len(repoNotaF) == 5
id_stud2 = 99
repoNotaF.sterge_note_stud(id_stud2)
assert len(repoNotaF) == 5
id_stud3 = 3
repoNotaF.sterge_note_stud(id_stud3)
assert len(repoNotaF) == 3
"""
test sterge note de la disc
"""
assert len(repoNotaF) == 3
id_disc = 2
repoNotaF.sterge_note_disc(id_disc)
assert len(repoNotaF) == 1
id_disc2 = 99
repoNotaF.sterge_note_disc(id_disc2)
assert len(repoNotaF) == 1
def test_modifica_cauta_nota(self):
self.__repoNota.modifica_nota(Nota(3,Student(5,"Gicu Camataru"),Disciplina(5,"Sport","Nicu Camataru"),1))
self.assertEqual(self.__repoNota.cauta_nota(3).get_stud(),Student(5,"Gicu Camataru"))
self.assertRaisesRegex(RepoError,"Nota inexistenta!",self.__repoNota.modifica_nota,Nota(99,Student(5,"Gicu Camataru"),Disciplina(5,"Sport","Nicu Camataru"),1))
self.assertRaisesRegex(RepoError,"Nota inexistenta!",self.__repoNota.cauta_nota,99)
def test_load_note(self):
repoNota2 = RepositoryNotaFile("test_unit_lista_note.txt")
self.assertEqual(repoNota2.get_note(), [Nota(0,Student(0,"Chef Scarlatescu"),Disciplina(0,"Analiza","Berinde"),10), Nota(1,Student(1,"Chef Dumitrescu"),Disciplina(1,"Algebra","Modoi"),4.5), Nota(3,Student(0,"Chef Scarlatescu"),Disciplina(1,"Algebra","Modoi"),8.55) ] )
def test_repoNota(self):
repoNota = RepositoryNota()
id_nota = 0
stud = Student(3,"Mircea Augustin")
disc = Disciplina(2,"Analiza","Berinde Stefan")
val_nota = 9.5
nota = Nota(id_nota,stud,disc,val_nota)
repoNota.adauga_nota(nota)
assert len(repoNota) == 1
try:
repoNota.adauga_nota(nota)
assert False
except RepoError as re:
assert str(re) == "Nota existenta!"
assert len(repoNota) == 1
stud2 = Student(2,"Andrei George")
nota_modif = Nota(id_nota,stud2,disc,10)
repoNota.modifica_nota(nota_modif)
nota_modif_gr = Nota(id_nota+5,stud2,disc,4)
try:
repoNota.modifica_nota(nota_modif_gr)
assert False
except RepoError as re:
assert str(re) == "Nota inexistenta!"
gasit = repoNota.cauta_nota(id_nota)
assert gasit == nota_modif
try:
repoNota.cauta_nota(id_nota+5)
assert False
except RepoError as re:
assert str(re) == "Nota inexistenta!"
tot = repoNota.get_note()
assert len(tot) == 1
try:
repoNota.sterge_nota(id_nota+5)
assert False
except RepoError as re:
assert str(re) == "Nota inexistenta!"
repoNota.sterge_nota(id_nota)
assert len(repoNota) == 0
try:
repoNota.sterge_nota(id_nota)
assert False
except RepoError as re:
assert str(re) == "Nota inexistenta!"
"""
test get toate notele de la o disciplina
"""
self.__ex_valori_note(repoNota)
disc = Disciplina(1,"Analiza","Berinde")
note_disc = repoNota.get_note_by_disc(disc)
assert note_disc == [["nutu",5],["andrei",10],["aandrei",4.5],["nutu",7]]
disc2 = Disciplina(5,"Sport","HabarNam")
note_disc2 = repoNota.get_note_by_disc(disc2)
assert note_disc2 == []
"""
test modifica note de la stud
"""
stud_modif = Student(2,"andrei")
repoNota.modifica_stud_note(stud_modif)
tot_note = repoNota.get_note()
assert tot_note[2].get_stud() == stud_modif
assert tot_note[4].get_stud() == stud_modif
assert tot_note[5].get_stud() == stud_modif
"""
test modifica note de la disc
"""
disc_modif = Disciplina(3,"TIC","Amanoae")
repoNota.modifica_disc_note(disc_modif)
tot_note = repoNota.get_note()
assert tot_note[1].get_disc() == disc_modif
assert tot_note[4].get_disc() == disc_modif
"""
test sterge note de la stud
"""
id_stud = 2
repoNota.sterge_note_stud(id_stud)
assert len(repoNota) == 4
id_stud2 = 7
repoNota.sterge_note_stud(id_stud2)
assert len(repoNota) == 3
id_stud3 = 99
repoNota.sterge_note_stud(id_stud3)
assert len(repoNota) == 3
"""
test sterge note de la stud
"""
repoNota.sterge_note()
self.__ex_valori_note(repoNota)
assert len(repoNota) == 7
id_disc = 1
repoNota.sterge_note_disc(id_disc)
assert len(repoNota) == 3
id_disc2 = 10
repoNota.sterge_note_disc(id_disc2)
assert len(repoNota) == 3
id_disc3 = 3
repoNota.sterge_note_disc(id_disc3)
assert len(repoNota) == 1
id_disc4 = 4
repoNota.sterge_note_disc(id_disc4)
assert len(repoNota) == 0
def test_append_nota(self):
self.__repoNota.adauga_nota(Nota(2,Student(3,"Gicu Camataru"),Disciplina(4,"Sport","Gicu Necamataru"),10))
repoNota2 = RepositoryNotaFile("test_unit_lista_note.txt")
self.assertEqual(len(repoNota2), 4)