def testCauta(self):
key_stud = Student(1, '')
result_stud = self.ctr.cauta_student(key_stud)
self.assertEquals(result_stud.get_idStudent(), 1)
self.assertEquals(result_stud.get_nume(), 'bogdan')
key_stud = Student(3, '')
self.assertRaises(RepoException, self.ctr.cauta_student, key_stud)
def testValidateStudent():
"""
Testing method for validate
Feature 1 - add a student
Task2 - Validate Student
"""
val = StudentValidator()
#student invalid if id is empty
st = Student("", "Ion", Address("Adr", 1, "Cluj"))
try:
val.validate(st)
assert False
except ValidationException:
assert True
#student invalid if name is empty
st = Student("3", "", Address("Adr", 1, "Cluj"))
try:
val.validate(st)
assert False
except ValidationException:
assert True
#student invalid if adr is empty
st = Student("3", "Ion", Address("", 1, "Cluj"))
try:
val.validate(st)
assert False
except ValidationException:
assert True
def setUp(self):
self.student1 = Student(1, 'bogdan')
self.student2 = Student(1, 'alex')
self.disciplina1 = Disciplina(1, 'informatica', 'prof1')
self.disciplina2 = Disciplina(1, 'matematica', 'prof2')
self.nota1 = Nota(1, 1, 1, 5.5)
self.nota2 = Nota(1, 2, 2, 8.6)
class TestCaseDomain(unittest.TestCase):
def setUp(self):
self.student1 = Student(1, 'bogdan')
self.student2 = Student(1, 'alex')
self.disciplina1 = Disciplina(1, 'informatica', 'prof1')
self.disciplina2 = Disciplina(1, 'matematica', 'prof2')
self.nota1 = Nota(1, 1, 1, 5.5)
self.nota2 = Nota(1, 2, 2, 8.6)
def tearDown(self):
unittest.TestCase.tearDown(self)
def testStudent(self):
self.assertEquals(self.student1.get_idStudent(), 1)
self.assertEquals(self.student1.get_nume(), 'bogdan')
self.assertEquals(str(self.student1), '1 bogdan')
self.assertEquals(self.student1, self.student2)
def testDisciplina(self):
self.assertEquals(self.disciplina1.get_idDisciplina(), 1)
self.assertEquals(self.disciplina1.get_nume(), 'informatica')
self.assertEquals(self.disciplina1.get_profesor(), 'prof1')
self.assertEquals(str(self.disciplina1), '1 informatica prof1')
self.assertEquals(self.disciplina1, self.disciplina2)
def testNota(self):
self.assertEquals(self.nota1.get_idNota(), 1)
self.assertEquals(self.nota1.get_idStudent(), 1)
self.assertEquals(self.nota1.get_idDisciplina(), 1)
self.assertEquals(self.nota1.get_punctaj(), 5.5)
self.assertEquals(str(self.nota1), '1 1 1 5.5')
self.assertEquals(self.nota1, self.nota2)
def testGetStudentGrades():
"""
Test function for getForDisc
"""
rep = GradeFileRepository("testgrade.txt")
rep.removeAll()
st = Student("1", "Ion", Address("Adr", 1, "Cluj"))
gr = Grade(st, "FP", 10)
rep.store(gr)
gr = Grade(st, "SO", 9.5)
rep.store(gr)
studentGrades = rep.getAllForDisc("FP")
assert len(studentGrades) == 1
assert studentGrades[0].getStudentID() == "1"
assert studentGrades[0].getGrade() == 10
assert studentGrades[0].getDiscipline() == "FP"
st = Student("2", "Ionel", Address("Adr2", 22, "Cluj"))
gr = Grade(st, "SO", 9.5)
rep.store(gr)
studentGrades = rep.getAllForDisc("SO")
assert len(studentGrades) == 2
assert studentGrades[0].getStudentID() == "1"
assert studentGrades[1].getStudentID() == "2"
def statistics_students_failing(self):
partial_grades = self.__gradeRepository.get_all()
grades = []
for grade in partial_grades:
student = self.__studentRepository.search(
Student(grade.get_student().get_stud_id(), ""))
discipline = self.__disciplineRepository.search(
Discipline(grade.get_discipline().get_dis_id(), ""))
grades.append(Grade(student, discipline, grade.get_value()))
students = {}
for grade in grades:
if not grade.get_student().get_stud_id() in students:
students[grade.get_student().get_stud_id()] = []
students[grade.get_student().get_stud_id()].append(
grade.get_value())
failing = []
for item in students.items():
stud_id = item[0]
stud_name = self.__studentRepository.search(Student(
stud_id, "")).get_stud_name()
average = sum(item[1]) / len(item[1])
if average < 5.0:
fail_stud_dto = StudentDTO(stud_name, average)
failing.append(fail_stud_dto)
failing.sort(key=lambda x: x.get_average(), reverse=False)
return failing[:]
def statistics_students_best(self):
partial_grades = self.__gradeRepository.get_all()
grades = []
for grade in partial_grades:
student = self.__studentRepository.search(
Student(grade.get_student().get_stud_id(), ""))
discipline = self.__disciplineRepository.search(
Discipline(grade.get_discipline().get_dis_id(), ""))
grades.append(Grade(student, discipline, grade.get_value()))
students = {}
for grade in grades:
if not grade.get_student().get_stud_id() in students:
students[grade.get_student().get_stud_id()] = []
students[grade.get_student().get_stud_id()].append(
grade.get_value())
best = []
for item in students.items():
stud_id = item[0]
stud_name = self.__studentRepository.search(Student(
stud_id, "")).get_stud_name()
average = sum(item[1]) / len(item[1])
best_stud = StudentDTO(stud_name, average)
best.append(best_stud)
best.sort(key=lambda x: x.get_average(), reverse=True)
return best[:3]
def setUp(self):
validator = ValidatorStud()
self.ctr = ControllerStud(RepositoryStud(), validator,
RepositoryNote())
student1 = Student(1, 'bogdan')
self.ctr.add_student(1, 'bogdan')
student2 = Student(2, 'alex')
self.ctr.add_student(2, 'alex')
def testRemove(self):
self.assertRaises(RepoException, self.repo.remove,
Student(1, 'bogdan'))
self.repo.store(Student(1, 'bogdan'))
self.repo.store(Student(2, 'alex'))
self.assertEquals(len(self.repo), 2)
self.repo.remove(Student(1, ''))
self.assertEquals(len(self.repo), 1)
self.assertRaises(RepoException, self.repo.remove, Student(1, ''))
def testUpdate(self):
self.assertRaises(RepoException, self.repo.update, Student(1, ''))
self.repo.store(Student(1, 'bogdan'))
result_stud = self.repo.search(Student(1, ''))
self.assertEquals(result_stud.get_idStudent(), 1)
self.assertEquals(result_stud.get_nume(), 'bogdan')
self.repo.update(Student(1, 'marius'))
result_stud = self.repo.search(Student(1, ''))
self.assertEquals(result_stud.get_idStudent(), 1)
self.assertEquals(result_stud.get_nume(), 'marius')
def update_student_name(self, stud_id, new_stud_name):
old_student = self.__studentRepository.search(Student(stud_id, ""))
new_student = Student(stud_id, new_stud_name)
self.__studentValidator.validate_student(new_student)
self.__studentRepository.update(old_student, new_student)
action = UndoRedoActionTwoObjects(self.__studentRepository,
self.__studentRepository.update,
new_student, old_student)
self.__undoStack.push(action)
self.__redoStack.clear()
def testStundet(self):
repos = studentRepository()
repos.add(Student(1, "Vasile"))
self.assertEqual(str(repos.getPos(0)), str(Student(1, "Vasile")))
repos.add(Student(2, "Ion"))
self.assertEqual(str(repos.getPos(1)), str(Student(2, "Ion")))
repos.remove(Student(2, "Ion"))
self.assertEqual(str(repos.getPos(0)), str(Student(1, "Vasile")))
repos.update(Student(1, "Vasile"), Student(1, "Ion"))
self.assertEqual(str(repos.getPos(0)), str(Student(1, "Ion")))
class TestCaseStudent(unittest.TestCase):
def setUp(self):
self.st1 = Student(12, "mihai", 215)
self.st3 = Student(12, "gigi", 200)
def tearDown(self):
unittest.TestCase.tearDown(self)
def testGetName(self):
self.assertEqual(self.st1.get_nume(), "mihai", "nume eronat")
self.assertEqual(self.st3.get_nume(), "gigi", "nume gresit")
def testGetId(self):
self.assertTrue(self.st1.get_id() == 12)
def setUpClass(cls):
cls.speciality_dao = SpecialitySqlDataMapper()
cls.student_dao = StudentSqlDataMapper()
cls.test_speciality = cls.speciality_dao.save(Speciality(name="Право"))
cls.test_students = [
# Студент с несуществ. спец-тью
cls.student_dao.save(Student(name="Петров П.П.", age=19, sex="М", speciality=Speciality(
sp_id=(cls.test_speciality.id + 1),
name="Бла-бла"
))),
cls.student_dao.save(Student(name="Иванов И.И.", age=18, sex="М", speciality=cls.test_speciality)),
cls.student_dao.save(Student(name="Маркова А.И.", age=20, sex="Ж", speciality=cls.test_speciality))
]
def setUp(self):
self.valid_stud = ValidatorStud()
self.student_valid = Student(1, 'bogdan')
self.student_invalid = Student(-23, '')
self.valid_disc = ValidatorDisc()
self.disciplina_valida = Disciplina(2, 'informatica', 'prof')
self.disciplina_invalida = Disciplina(-59, '', '')
self.valid_nota = ValidatorNota()
self.nota_valida = Nota(3, 1, 2, 7.5)
self.nota_invalida = Nota(-1, -25, -28, 0.5)
self.repo_stud = RepositoryStud()
self.repo_stud.store(self.student_valid)
self.repo_disc = RepositoryDisc()
self.repo_disc.store(self.disciplina_valida)
def test_should_AddWithMandatoryFields(self):
student = Student(name="Иванов И.И.", age=18, sex="М", speciality=self.test_speciality)
self.student_dao.save(student)
self.added_students.append(student)
self.assertIsNotNone(student.id)
self.assertGreater(student.id, 0)
def testStudValid():
validator = StudentValidator()
st1 = Student(12, "Mircea", 215)
try:
validator.valideazaStudent(st1)
assert True
except ValidError as ve:
assert False
st2 = Student(-5, "", -1)
try:
validator.valideazaStudent(st2)
assert False
except ValidError as ve:
assert str(ve) == "id invalid!\nnume invalid!\ngrupa invalida!\n"
def statistics_disciplines(self):
partial_grades = self.__gradeRepository.get_all()
grades = []
for grade in partial_grades:
student = self.__studentRepository.search(
Student(grade.get_student().get_stud_id(), ""))
discipline = self.__disciplineRepository.search(
Discipline(grade.get_discipline().get_dis_id(), ""))
grades.append(Grade(student, discipline, grade.get_value()))
disciplines = {}
for grade in grades:
if not grade.get_discipline().get_dis_id() in disciplines:
disciplines[grade.get_discipline().get_dis_id()] = []
disciplines[grade.get_discipline().get_dis_id()].append(
grade.get_value())
results = []
for item in disciplines.items():
dis_id = item[0]
dis_name = self.__disciplineRepository.search(
Discipline(dis_id, "")).get_dis_name()
average = sum(item[1]) / len(item[1])
dis_dto = DisciplineDTO(dis_name, average)
results.append(dis_dto)
results.sort(key=lambda x: x.get_average(), reverse=True)
return results[:]
def update(self, student_id, student_name):
'''
creates a student object with the given student_id and student_name
and calls the update method in repository
'''
student = Student(student_id, student_name)
self.__student_repository.update(student_id, student)
def valideaza(self,nota,repo_studenti,repo_discipline):
"""
Valideaza o nota
Ridica o exceptie in cazul in care nota nu este valida
"""
errors = ''
if nota.get_idNota() < 0 :
errors += 'id invalid!\n'
idStudent = nota.get_idStudent()
student = Student(idStudent,'')
try:
result_stud = repo_studenti.search(student)
gasit_stud = True
except RepoException:
gasit_stud = False
if nota.get_idStudent() < 0 or gasit_stud == False:
errors += 'id student invalid!\n'
idDisciplina = nota.get_idDisciplina()
disciplina = Disciplina(idDisciplina,'','')
try:
result_disc = repo_discipline.search(disciplina)
gasit_disc = True
except RepoException:
gasit_disc = False
if nota.get_idDisciplina() < 0 or gasit_disc == False:
errors += 'id disciplina invalid!\n'
if nota.get_punctaj() < 1 or nota.get_punctaj()>10:
errors += 'punctaj invalid!\n'
if len(errors) > 0:
raise ValidationException(errors)
def __loadFromFile(self):
f = open(self.file, "r")
for line in f:
id, name, group = line.split(",")
s = Student(id, name, group)
self.list.append(s)
f.close()
def add_student(self, student_id, student_name):
'''
creates a student with student_id and student_name
and calls the add method in repository with certain student
'''
student = Student(student_id, student_name)
self.__student_repository.add(student)
def readStudent():
'''
reads a studentType object from the keyboard
'''
uid = int(input("student id:"))
name = input("student name: ")
return Student(uid, name)
def __ui_del_student(self):
"""
Citirea de la consola a datelor pentru stergerea unui student
"""
idStudent = int(input('Introduceti id-ul studentului pe care doriti sa il stergeti: '))
key_stud = Student(idStudent,'')
self.__controller_studenti.del_student(key_stud)
print('Studentul a fost sters din catalog!')
def __ui_cauta_student(self):
"""
Citirea de la consola a datelor pentru cautarea unui student
"""
idStudent = int(input('Introduceti id-ul studentului pe care doriti sa il cautati: '))
key_stud = Student(idStudent,'')
result_student = self.__controller_studenti.cauta_student(key_stud)
print("Studentul cautat este: ",result_student)
def updateStudent(self, id, newname, newgrupa):
st = Student(id, newname, newgrupa)
list = self.__repoNota.get_all_note()
for x in list:
if x.get_student() == id:
self.__repoNota.update_nota_stud(st)
self.__repoStudent.update_student(st)
def __ui_modifica_student(self):
"""
Citirea de la consola a datelor pentru modificarea unui student
"""
idStudent = int(input("Introduceti id-ul studentului caruia doriti sa ii modificati numele: "))
nume = input("Introduceti numele nou al studentului: ")
student = Student(idStudent,nume)
self.__controller_studenti.modifica_student(student)
def add_student(self, stud_id, stud_name):
student = Student(stud_id, stud_name)
self.__studentValidator.validate_student(student)
self.__studentRepository.add(student)
action = UndoRedoAction(self.__studentRepository,
self.__studentRepository.remove,
self.__studentRepository.add, student)
self.__undoStack.push(action)
self.__redoStack.clear()
def deleteStudent(self, id):
st = Student(id, "george", 210)
list = self.__repoNota.get_all_note()
for x in list:
if x.get_student() == id:
self.__repoNota.delete_nota(st)
self.__repoStudent.delete_student(st)
def TestFileStudenti():
x = StudentFileRepository("test.txt")
st = Student(13, "alin", 200)
x.store_studenti(st)
l = x.get_all_studenti()
assert len(l) == 1
x.delete_student(13)
l = x.get_all_studenti()
assert len(l) == 0
