def test_own_child_school_situation_filter_by_academic_year(self):
self.client.login(username=self.parent.username, password='******')
StudentCatalogPerSubjectFactory(
student=self.student, academic_year=self.calendar.academic_year)
past_study_class = StudyClassFactory(
school_unit=self.school_unit,
class_grade='IX',
class_grade_arabic=9,
academic_year=self.calendar.academic_year - 1)
StudentCatalogPerYearFactory(student=self.student,
study_class=past_study_class)
past_catalog = StudentCatalogPerSubjectFactory(
student=self.student,
study_class=past_study_class,
academic_year=self.calendar.academic_year - 1)
ProgramSubjectThroughFactory(
academic_program=past_study_class.academic_program,
class_grade=past_study_class.class_grade,
subject=past_catalog.subject,
weekly_hours_count=4)
response = self.client.get(
self.build_url(self.student.id),
{'academic_year': self.calendar.academic_year - 1})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['study_class']['class_grade'], 'IX')
self.assertEqual(response.data['study_class']['academic_program_name'],
past_study_class.academic_program_name)
self.assertEqual(len(response.data['catalogs_per_subjects']), 1)
self.assertEqual(response.data['catalogs_per_subjects'][0]['id'],
past_catalog.id)
self.assertEqual(
response.data['catalogs_per_subjects'][0]['avg_limit'], 5)
self.assertEqual(
response.data['catalogs_per_subjects'][0]
['third_of_hours_count_sem1'], 20)
self.assertEqual(
response.data['catalogs_per_subjects'][0]
['third_of_hours_count_sem2'], 20)
self.assertEqual(
response.data['catalogs_per_subjects'][0]
['third_of_hours_count_annual'], 40)
def setUpTestData(cls):
cls.school_unit = RegisteredSchoolUnitFactory()
cls.teacher = UserProfileFactory(
user_role=UserProfile.UserRoles.TEACHER,
school_unit=cls.school_unit)
cls.student = UserProfileFactory(
user_role=UserProfile.UserRoles.STUDENT,
school_unit=cls.school_unit)
cls.study_class = StudyClassFactory(school_unit=cls.school_unit,
class_master=cls.teacher)
cls.subject = SubjectFactory()
cls.teacher.taught_subjects.add(cls.subject)
cls.teacher_class_through = TeacherClassThroughFactory(
study_class=cls.study_class,
teacher=cls.teacher,
subject=cls.subject,
)
cls.catalog = StudentCatalogPerYearFactory(student=UserProfileFactory(
user_role=UserProfile.UserRoles.STUDENT, full_name='a'),
study_class=cls.study_class,
academic_year=2020)
def test_own_students_at_risk_success(self):
self.client.login(username=self.teacher.username, password='******')
study_class = StudyClassFactory(class_master=self.teacher, school_unit=self.school_unit)
catalog1 = StudentCatalogPerYearFactory(student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, student_in_class=study_class,
school_unit=self.school_unit, is_at_risk=True, full_name='b'),
study_class=study_class, unfounded_abs_count_sem1=2, unfounded_abs_count_annual=2)
catalog2 = StudentCatalogPerYearFactory(student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, student_in_class=study_class,
school_unit=self.school_unit, is_at_risk=True, full_name='c'),
study_class=study_class, unfounded_abs_count_sem1=1, unfounded_abs_count_annual=1)
catalog3 = StudentCatalogPerYearFactory(student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, student_in_class=study_class,
school_unit=self.school_unit, is_at_risk=True, full_name='e'),
study_class=study_class, unfounded_abs_count_sem1=3, unfounded_abs_count_annual=3,
behavior_grade_sem1=8, behavior_grade_annual=8)
catalog4 = StudentCatalogPerYearFactory(student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, student_in_class=study_class,
school_unit=self.school_unit, is_at_risk=True, full_name='d'),
study_class=study_class, unfounded_abs_count_sem1=3, unfounded_abs_count_annual=3,
behavior_grade_sem1=9, behavior_grade_annual=9)
catalog5 = StudentCatalogPerYearFactory(student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, student_in_class=study_class,
school_unit=self.school_unit, is_at_risk=True, full_name='a'),
study_class=study_class, unfounded_abs_count_sem1=2, unfounded_abs_count_annual=2)
StudentCatalogPerYearFactory(student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, student_in_class=study_class), study_class=study_class)
StudentCatalogPerYearFactory(student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, is_at_risk=True))
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data['results']), 5)
expected_fields = ['id', 'student', 'avg_sem1', 'avg_final', 'unfounded_abs_count_sem1', 'unfounded_abs_count_annual',
'second_examinations_count', 'behavior_grade_sem1', 'behavior_grade_annual', 'behavior_grade_limit']
expected_student_fields = ['id', 'full_name']
for result in response.data['results']:
self.assertCountEqual(result.keys(), expected_fields)
self.assertCountEqual(result['student'].keys(), expected_student_fields)
self.assertEqual(response.data['results'][0]['id'], catalog4.id)
self.assertEqual(response.data['results'][1]['id'], catalog3.id)
self.assertEqual(response.data['results'][2]['id'], catalog5.id)
self.assertEqual(response.data['results'][3]['id'], catalog1.id)
self.assertEqual(response.data['results'][4]['id'], catalog2.id)
def setUpTestData(cls):
cls.calendar = AcademicYearCalendarFactory()
cls.school_unit = RegisteredSchoolUnitFactory()
cls.study_class = StudyClassFactory(school_unit=cls.school_unit,
class_grade='IX',
class_grade_arabic=9)
cls.parent = UserProfileFactory(user_role=UserProfile.UserRoles.PARENT,
school_unit=cls.school_unit)
cls.student = UserProfileFactory(
user_role=UserProfile.UserRoles.STUDENT,
school_unit=cls.school_unit,
student_in_class=cls.study_class)
cls.student.parents.add(cls.parent)
StudentCatalogPerYearFactory(student=cls.student,
study_class=cls.study_class)
cls.student_catalog_per_subject = StudentCatalogPerSubjectFactory(
student=cls.student, study_class=cls.study_class)
ProgramSubjectThroughFactory(
academic_program=cls.study_class.academic_program,
class_grade=cls.study_class.class_grade,
subject=cls.student_catalog_per_subject.subject,
weekly_hours_count=5)
def test_study_class_cloned_to_next_year_success(self):
self.client.login(username=self.principal.username, password='******')
subject1 = SubjectFactory(name='Subject B')
subject2 = SubjectFactory(name='Subject C')
subject3 = SubjectFactory(name='Subject A')
ProgramSubjectThroughFactory(subject=subject1, academic_program=self.current_year_program, class_grade='VII', class_grade_arabic=7, is_mandatory=False)
ProgramSubjectThroughFactory(subject=subject2, academic_program=self.current_year_program, class_grade='VII', class_grade_arabic=7, is_mandatory=False)
ProgramSubjectThroughFactory(subject=subject3, generic_academic_program=self.current_year_program.generic_academic_program,
class_grade='VII', class_grade_arabic=7)
student1 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, full_name='Student B', student_in_class=self.study_class)
StudentCatalogPerYearFactory(student=student1, study_class=self.study_class)
# Behavior grade below 6
student2 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, full_name='Student C', student_in_class=self.study_class)
StudentCatalogPerYearFactory(student=student2, study_class=self.study_class, behavior_grade_annual=5)
student3 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, full_name='Student A', student_in_class=self.study_class)
StudentCatalogPerYearFactory(student=student3, study_class=self.study_class)
# No average
student4 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, full_name='Student E', student_in_class=self.study_class)
StudentCatalogPerYearFactory(student=student4, study_class=self.study_class)
StudentCatalogPerSubjectFactory(student=student4, subject=subject1, study_class=self.study_class)
# Average below 5
student5 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, full_name='Student D', student_in_class=self.study_class)
StudentCatalogPerYearFactory(student=student5, study_class=self.study_class)
StudentCatalogPerSubjectFactory(student=student5, subject=subject2, study_class=self.study_class, avg_final=4)
response = self.client.get(self.build_url(self.study_class.id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertCountEqual(response.data.keys(), ['class_grade', 'class_letter', 'academic_program', 'academic_program_name',
'class_master', 'subjects', 'students'])
self.assertCountEqual(response.data['class_master'].keys(), ['id', 'full_name'])
for subject in response.data['subjects']:
self.assertCountEqual(subject.keys(), ['subject_id', 'subject_name', 'is_mandatory'])
for subject in response.data['students']:
self.assertCountEqual(subject.keys(), ['id', 'full_name'])
self.assertEqual(response.data['class_grade'], 'VII')
self.assertEqual(response.data['class_letter'], 'A')
self.assertEqual(response.data['academic_program'], self.current_year_program.id)
self.assertEqual(response.data['academic_program_name'], self.current_year_program.name)
self.assertEqual(response.data['class_master']['id'], self.study_class.class_master_id)
subjects_response = response.data['subjects']
self.assertEqual(len(subjects_response), 3)
self.assertEqual(subjects_response[0]['subject_id'], subject3.id)
self.assertTrue(subjects_response[0]['is_mandatory'])
self.assertEqual(subjects_response[1]['subject_id'], subject1.id)
self.assertFalse(subjects_response[1]['is_mandatory'])
self.assertEqual(subjects_response[2]['subject_id'], subject2.id)
self.assertFalse(subjects_response[2]['is_mandatory'])
students_response = response.data['students']
self.assertEqual(len(students_response), 2)
self.assertEqual(students_response[0]['id'], student3.id)
self.assertEqual(students_response[1]['id'], student1.id)
def setUpTestData(cls):
cls.calendar = AcademicYearCalendarFactory(
first_semester__starts_at=datetime(2019, 9, 9),
first_semester__ends_at=datetime(2020, 1, 12),
second_semester__starts_at=datetime(2020, 1, 13),
second_semester__ends_at=datetime(2020, 6, 12))
cls.create_semester_end_events(cls.calendar)
subject = SubjectFactory(name='Matematică')
cls.school1 = RegisteredSchoolUnitFactory()
cls.study_class1 = StudyClassFactory(school_unit=cls.school1)
# No risk
cls.student1 = UserProfileFactory(
school_unit=cls.school1,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class1)
StudentCatalogPerYearFactory(student=cls.student1,
study_class=cls.study_class1)
# Absences risk 1
cls.student2 = UserProfileFactory(
school_unit=cls.school1,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class1)
StudentCatalogPerYearFactory(student=cls.student2,
study_class=cls.study_class1,
unfounded_abs_count_sem1=1,
unfounded_abs_count_sem2=3)
# Absences risk 2
cls.student3 = UserProfileFactory(
school_unit=cls.school1,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class1)
StudentCatalogPerYearFactory(student=cls.student3,
study_class=cls.study_class1,
unfounded_abs_count_sem1=4,
unfounded_abs_count_sem2=5)
cls.study_class2 = StudyClassFactory(school_unit=cls.school1,
class_grade='X',
class_grade_arabic=10)
# Grades risk 1
cls.student4 = UserProfileFactory(
school_unit=cls.school1,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class2)
StudentCatalogPerYearFactory(student=cls.student4,
study_class=cls.study_class2)
cls.catalog4 = StudentCatalogPerSubjectFactory(
student=cls.student4,
study_class=cls.study_class2,
subject=subject,
avg_sem1=5,
avg_sem2=6)
# Grades risk 2 (sem II)
cls.student5 = UserProfileFactory(
school_unit=cls.school1,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class2)
StudentCatalogPerYearFactory(student=cls.student5,
study_class=cls.study_class2)
cls.catalog5 = StudentCatalogPerSubjectFactory(
student=cls.student5,
study_class=cls.study_class2,
subject=subject,
avg_sem1=7,
avg_sem2=4)
cls.study_class3 = StudyClassFactory(school_unit=cls.school1,
class_grade='XII',
class_grade_arabic=12)
# Behavior grade risk 1 (sem II)
cls.student6 = UserProfileFactory(
school_unit=cls.school1,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class3)
StudentCatalogPerYearFactory(student=cls.student6,
study_class=cls.study_class3,
behavior_grade_sem1=10,
behavior_grade_sem2=9)
# Behavior grade risk 2
cls.student7 = UserProfileFactory(
school_unit=cls.school1,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class3)
StudentCatalogPerYearFactory(student=cls.student7,
study_class=cls.study_class3,
behavior_grade_sem1=7,
behavior_grade_sem2=6)
cls.school2 = RegisteredSchoolUnitFactory()
cls.school2.categories.add(
SchoolUnitCategoryFactory(name='Liceu - Filieră Tehnologică'))
cls.study_class4 = StudyClassFactory(school_unit=cls.school2,
class_grade='VIII',
class_grade_arabic=8)
# Absences risk 1 + Grades risk 2
cls.student8 = UserProfileFactory(
school_unit=cls.school2,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class4)
StudentCatalogPerYearFactory(student=cls.student8,
study_class=cls.study_class4,
unfounded_abs_count_sem1=1,
unfounded_abs_count_sem2=3)
cls.catalog8 = StudentCatalogPerSubjectFactory(
student=cls.student8,
study_class=cls.study_class4,
subject=subject,
avg_sem1=4,
avg_sem2=4)
# Grades risk 1 + Behavior grade risk 2 (sem II)
cls.student9 = UserProfileFactory(
school_unit=cls.school2,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class4)
StudentCatalogPerYearFactory(student=cls.student9,
study_class=cls.study_class4,
behavior_grade_sem1=10,
behavior_grade_sem2=7)
cls.catalog9 = StudentCatalogPerSubjectFactory(
student=cls.student9,
study_class=cls.study_class4,
subject=subject,
avg_sem1=7,
avg_sem2=6)
cls.study_class5 = StudyClassFactory(school_unit=cls.school2,
class_grade='IX',
class_grade_arabic=9)
# Absences risk 2 (both sem) + Behavior grade risk 1 (sem II)
cls.student10 = UserProfileFactory(
school_unit=cls.school2,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class5)
StudentCatalogPerYearFactory(student=cls.student10,
study_class=cls.study_class5,
behavior_grade_sem1=10,
behavior_grade_sem2=9,
unfounded_abs_count_sem1=4,
unfounded_abs_count_sem2=5)
# Absences risk 2 + Grades risk 2 + Behavior grade risk 2
cls.student11 = UserProfileFactory(
school_unit=cls.school2,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class5)
StudentCatalogPerYearFactory(student=cls.student11,
study_class=cls.study_class5,
behavior_grade_sem1=7,
behavior_grade_sem2=6,
unfounded_abs_count_sem1=4,
unfounded_abs_count_sem2=6)
cls.catalog11 = StudentCatalogPerSubjectFactory(
student=cls.student11,
study_class=cls.study_class5,
subject=subject,
avg_sem1=4,
avg_sem2=3)
cls.create_risk_stats()
def test_move_student_success(self):
self.client.login(username=self.principal.username, password='******')
catalog_per_year1 = StudentCatalogPerYearFactory(
student=self.student, study_class=self.source_study_class)
catalog_per_subject1 = StudentCatalogPerSubjectFactory(
student=self.student,
teacher=self.source_study_class.class_master,
study_class=self.source_study_class,
subject=self.subject1)
catalog_per_subject2 = StudentCatalogPerSubjectFactory(
student=self.student,
teacher=self.source_study_class.class_master,
study_class=self.source_study_class,
subject=self.subject3)
previous_study_class = StudyClassFactory(
school_unit=self.school_unit,
academic_year=self.study_class.academic_year - 1,
class_grade_arabic=9,
class_grade='IX',
class_letter='B',
class_master=self.study_class.class_master)
TeacherClassThroughFactory(study_class=previous_study_class,
teacher=self.study_class.class_master,
subject=self.subject1,
is_class_master=True)
TeacherClassThroughFactory(study_class=previous_study_class,
teacher=self.study_class.class_master,
subject=self.subject2,
is_class_master=True)
optional_subject = SubjectFactory()
TeacherClassThroughFactory(study_class=previous_study_class,
teacher=self.study_class.class_master,
subject=optional_subject,
is_class_master=True,
is_optional_subject=True)
own_previous_study_class = StudyClassFactory(
school_unit=self.school_unit,
academic_year=self.source_study_class.academic_year - 1,
class_grade='IX',
class_grade_arabic=9,
class_master=self.source_study_class.class_master)
catalog_per_year2 = StudentCatalogPerYearFactory(
student=self.student, study_class=own_previous_study_class)
catalog_per_subject3 = StudentCatalogPerSubjectFactory(
student=self.student,
teacher=self.source_study_class.class_master,
study_class=own_previous_study_class,
subject=self.subject1)
catalog_per_subject4 = StudentCatalogPerSubjectFactory(
student=self.student,
teacher=self.source_study_class.class_master,
study_class=own_previous_study_class,
subject=self.subject3)
response = self.client.post(
self.build_url(self.student.id, self.study_class.id), {})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertCountEqual(response.data.keys(), self.expected_fields)
self.assertEqual(response.data['id'], self.source_study_class.id)
self.refresh_objects_from_db([
self.student, self.principal, self.school_unit, catalog_per_year1,
catalog_per_year2, catalog_per_subject1, catalog_per_subject2,
catalog_per_subject3, catalog_per_subject4
])
self.assertEqual(self.student.student_in_class, self.study_class)
self.assertEqual(catalog_per_year1.study_class, self.study_class)
self.assertEqual(catalog_per_year2.study_class, previous_study_class)
self.assertTrue(catalog_per_subject1.is_enrolled)
self.assertEqual(catalog_per_subject1.teacher,
self.study_class.class_master)
self.assertEqual(catalog_per_subject1.study_class, self.study_class)
self.assertFalse(catalog_per_subject2.is_enrolled)
self.assertEqual(catalog_per_subject2.teacher,
self.source_study_class.class_master)
self.assertEqual(catalog_per_subject2.study_class,
self.source_study_class)
self.assertTrue(catalog_per_subject3.is_enrolled)
self.assertEqual(catalog_per_subject3.teacher,
own_previous_study_class.class_master)
self.assertEqual(catalog_per_subject3.study_class,
previous_study_class)
self.assertFalse(catalog_per_subject4.is_enrolled)
self.assertEqual(catalog_per_subject4.teacher,
own_previous_study_class.class_master)
self.assertEqual(catalog_per_subject4.study_class,
own_previous_study_class)
self.assertTrue(
StudentCatalogPerSubject.objects.filter(
student=self.student,
teacher=self.study_class.class_master,
study_class=self.study_class,
subject=self.subject2).exists())
self.assertTrue(
StudentCatalogPerSubject.objects.filter(
student=self.student,
teacher=previous_study_class.class_master,
study_class=previous_study_class,
subject=self.subject2).exists())
self.assertTrue(
StudentCatalogPerSubject.objects.filter(
student=self.student,
subject=optional_subject,
is_enrolled=False).exists())
def test_study_class_detail_success(self):
self.client.login(username=self.principal.username, password='******')
student1 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT,
full_name='Student B',
student_in_class=self.study_class)
StudentCatalogPerYearFactory(student=student1,
study_class=self.study_class)
student2 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT,
full_name='Student C',
student_in_class=self.study_class)
StudentCatalogPerYearFactory(student=student2,
study_class=self.study_class)
student3 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT,
full_name='Student A',
student_in_class=self.study_class)
StudentCatalogPerYearFactory(student=student3,
study_class=self.study_class)
teacher1 = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER)
teacher2 = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER)
teacher3 = self.study_class.class_master
subject1 = SubjectFactory(name='Subject B')
subject2 = SubjectFactory(name='Subject C')
subject3 = SubjectFactory(name='Subject A')
subject4 = SubjectFactory(name='Dirigentie', is_coordination=True)
teacher_class_through1 = TeacherClassThroughFactory(
study_class=self.study_class, teacher=teacher1, subject=subject1)
teacher_class_through2 = TeacherClassThroughFactory(
study_class=self.study_class, teacher=teacher2, subject=subject2)
teacher_class_through3 = TeacherClassThroughFactory(
study_class=self.study_class, teacher=teacher3, subject=subject3)
TeacherClassThroughFactory(study_class=self.study_class,
teacher=teacher3,
subject=subject4)
response = self.client.get(self.build_url(self.study_class.id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertCountEqual(response.data.keys(), [
'id', 'class_grade', 'class_letter', 'academic_year',
'academic_program', 'academic_program_name', 'class_master',
'teachers_class_through', 'students', 'has_previous_catalog_data'
])
self.assertCountEqual(response.data['class_master'].keys(),
['id', 'full_name'])
teachers_class_through_response = response.data[
'teachers_class_through']
self.assertEqual(len(teachers_class_through_response), 3)
self.assertCountEqual(teachers_class_through_response[0].keys(),
['id', 'teacher', 'subject_id', 'subject_name'])
self.assertCountEqual(
teachers_class_through_response[0]['teacher'].keys(),
['id', 'full_name'])
self.assertEqual(teachers_class_through_response[0]['id'],
teacher_class_through3.id)
self.assertEqual(teachers_class_through_response[1]['id'],
teacher_class_through1.id)
self.assertEqual(teachers_class_through_response[2]['id'],
teacher_class_through2.id)
students_response = response.data['students']
self.assertEqual(len(students_response), 3)
self.assertCountEqual(students_response[0].keys(), ['id', 'full_name'])
self.assertEqual(students_response[0]['id'], student3.id)
self.assertEqual(students_response[1]['id'], student1.id)
self.assertEqual(students_response[2]['id'], student2.id)
def test_user_profile_update_taught_subjects(self):
self.client.login(username=self.principal.username, password='******')
url = self.build_url(self.teacher_profile.id)
# Create a few taught subjects
subject1 = SubjectFactory(name='Sport')
subject2 = SubjectFactory(name='Religie')
self.teacher_data['user_role'] = UserProfile.UserRoles.TEACHER
self.teacher_data['taught_subjects'] = [subject1.id, subject2.id]
response = self.client.put(url, self.teacher_data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.teacher_profile.refresh_from_db()
for attr_name, value in self.teacher_data.items():
if attr_name not in ['labels', 'taught_subjects']:
self.assertEqual(getattr(self.teacher_profile, attr_name), value)
self.assertCountEqual(self.teacher_profile.taught_subjects.values_list('id', flat=True), [subject1.id, subject2.id])
study_class1 = StudyClassFactory(school_unit=self.school_unit, class_grade='I', class_grade_arabic=1)
teacher_class_through1 = TeacherClassThroughFactory(study_class=study_class1, teacher=self.teacher_profile,
subject=subject1, is_class_master=False)
study_class2 = StudyClassFactory(school_unit=self.school_unit, class_master=self.teacher_profile)
teacher_class_through2 = TeacherClassThroughFactory(study_class=study_class2, teacher=self.teacher_profile,
subject=subject2, is_class_master=True)
self.student_profile.student_in_class = study_class2
self.student_profile.save()
StudentCatalogPerYearFactory(student=self.student_profile, study_class=study_class2)
catalog = StudentCatalogPerSubjectFactory(student=self.student_profile, teacher=self.teacher_profile,
study_class=study_class2, subject=subject2)
new_teacher = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=self.school_unit)
new_teacher.taught_subjects.add(subject2)
self.teacher_data['taught_subjects'] = [subject1.id]
self.teacher_data['new_teachers'] = [
{
'id': teacher_class_through2.id,
'teacher': new_teacher.id
}
]
response = self.client.put(url, self.teacher_data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.refresh_objects_from_db([teacher_class_through2, catalog])
self.assertEqual(teacher_class_through2.teacher, new_teacher)
self.assertFalse(teacher_class_through2.is_class_master)
self.assertEqual(catalog.teacher, new_teacher)
self.teacher_data['taught_subjects'] = []
self.teacher_data['new_teachers'] = [
{
'id': teacher_class_through1.id,
'teacher': study_class1.class_master.id
}
]
response = self.client.put(url, self.teacher_data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
teacher_class_through1.refresh_from_db()
self.assertEqual(teacher_class_through1.teacher, study_class1.class_master)
self.assertTrue(teacher_class_through1.is_class_master)
def setUpTestData(cls):
cls.admin = UserProfileFactory(
user_role=UserProfile.UserRoles.ADMINISTRATOR)
cls.principal = UserProfileFactory(
user_role=UserProfile.UserRoles.PRINCIPAL)
cls.school_unit = RegisteredSchoolUnitFactory(
school_principal=cls.principal)
cls.teacher = UserProfileFactory(
user_role=UserProfile.UserRoles.TEACHER,
school_unit=cls.school_unit)
cls.study_class = StudyClassFactory(school_unit=cls.school_unit)
cls.teacher_class_through = TeacherClassThroughFactory(
study_class=cls.study_class, teacher=cls.teacher)
another_study_class = StudyClassFactory(school_unit=cls.school_unit,
class_grade='IX',
class_grade_arabic=9)
cls.another_school_unit = RegisteredSchoolUnitFactory(
academic_profile=SchoolUnitProfileFactory(name='Militar'))
cls.catalog1 = StudentCatalogPerYearFactory(
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT,
full_name='Student a',
school_unit=cls.another_school_unit),
study_class=StudyClassFactory(school_unit=cls.another_school_unit),
avg_sem1=1,
avg_sem2=1,
avg_final=1,
second_examinations_count=1,
unfounded_abs_count_sem1=1,
unfounded_abs_count_sem2=1,
unfounded_abs_count_annual=1,
behavior_grade_sem1=1,
behavior_grade_sem2=1,
behavior_grade_annual=1,
)
cls.catalog2 = StudentCatalogPerYearFactory(
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT,
full_name='Student b',
school_unit=cls.school_unit),
study_class=another_study_class,
avg_sem1=2,
avg_sem2=2,
avg_final=2,
second_examinations_count=2,
unfounded_abs_count_sem1=2,
unfounded_abs_count_sem2=2,
unfounded_abs_count_annual=2,
behavior_grade_sem1=2,
behavior_grade_sem2=2,
behavior_grade_annual=2,
)
cls.catalog3 = StudentCatalogPerYearFactory(
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT,
full_name='Student c',
school_unit=cls.school_unit),
study_class=cls.study_class,
avg_sem1=3,
avg_sem2=3,
avg_final=3,
second_examinations_count=3,
unfounded_abs_count_sem1=3,
unfounded_abs_count_sem2=3,
unfounded_abs_count_annual=3,
behavior_grade_sem1=3,
behavior_grade_sem2=3,
behavior_grade_annual=3,
)
cls.catalog4 = StudentCatalogPerYearFactory(
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT,
full_name='Student d',
school_unit=cls.school_unit),
study_class=cls.study_class,
avg_sem1=4,
avg_sem2=4,
avg_final=4,
second_examinations_count=4,
unfounded_abs_count_sem1=4,
unfounded_abs_count_sem2=4,
unfounded_abs_count_annual=4,
behavior_grade_sem1=4,
behavior_grade_sem2=4,
behavior_grade_annual=4,
)
cls.url = reverse('statistics:pupils-statistics')
def test_pupils_statistics_admin_success(self):
self.client.login(username=self.admin.username, password='******')
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 4)
catalog_expected_fields = [
'id', 'student', 'school_unit', 'avg_sem1', 'avg_sem2',
'avg_final', 'second_examinations_count',
'unfounded_abs_count_sem1', 'unfounded_abs_count_sem2',
'unfounded_abs_count_annual', 'behavior_grade_sem1',
'behavior_grade_sem2', 'behavior_grade_annual',
'behavior_grade_limit', 'labels', 'risk_description',
'student_in_class', 'academic_program_name'
]
school_unit_expected_fields = ['id', 'name']
label_expected_fields = ['id', 'text']
study_class_expected_fields = ['id', 'class_grade', 'class_letter']
for catalog_data in response.data['results']:
self.assertCountEqual(catalog_data.keys(), catalog_expected_fields)
self.assertCountEqual(catalog_data['school_unit'].keys(),
school_unit_expected_fields)
self.assertCountEqual(catalog_data['student_in_class'].keys(),
study_class_expected_fields)
for label_data in catalog_data['labels']:
self.assertCountEqual(label_data.keys(), label_expected_fields)
# Search
student = self.catalog2.student
student.labels.add(LabelFactory(text='Label 1'))
response = self.client.get(self.url, {'search': 'Label 1'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
self.assertEqual(response.data['results'][0]['id'], self.catalog2.id)
self.assertEqual(response.data['results'][0]['behavior_grade_limit'],
6)
response = self.client.get(self.url,
{'search': self.another_school_unit.name})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
self.assertEqual(response.data['results'][0]['id'], self.catalog1.id)
self.assertEqual(response.data['results'][0]['behavior_grade_limit'],
8)
# Filters
response = self.client.get(
self.url, {
'academic_program':
self.study_class.academic_program.generic_academic_program.id
})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 2)
self.assertEqual(response.data['results'][0]['id'], self.catalog3.id)
self.assertEqual(response.data['results'][1]['id'], self.catalog4.id)
response = self.client.get(self.url, {'study_class_grade': 'IX'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
self.assertEqual(response.data['results'][0]['id'], self.catalog2.id)
catalog = StudentCatalogPerYearFactory(
academic_year=2018,
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT,
school_unit=self.school_unit))
response = self.client.get(self.url, {'academic_year': '2018'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
self.assertEqual(response.data['results'][0]['id'], catalog.id)
def setUpTestData(cls):
cls.calendar = AcademicYearCalendarFactory(
first_semester__starts_at=datetime(2019, 9, 9),
first_semester__ends_at=datetime(2020, 1, 12),
second_semester__starts_at=datetime(2020, 1, 13),
second_semester__ends_at=datetime(2020, 6, 12))
cls.create_semester_end_events(cls.calendar)
cls.subject = SubjectFactory(name='Matematică')
cls.subject2 = SubjectFactory(name='Limba Romana')
coordination_subject = SubjectFactory(is_coordination=True)
cls.school1 = RegisteredSchoolUnitFactory()
cls.study_class1 = StudyClassFactory(school_unit=cls.school1)
# behavior grade for the 1st semester lower than 8 and subject average grade for the 1st semester lower than 5
cls.student1 = UserProfileFactory(
school_unit=cls.school1,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class1)
cls.parent1 = UserProfileFactory(
school_unit=cls.school1, user_role=UserProfile.UserRoles.PARENT)
cls.student1.parents.add(cls.parent1)
StudentCatalogPerYearFactory(student=cls.student1,
study_class=cls.study_class1)
StudentCatalogPerSubjectFactory(student=cls.student1,
study_class=cls.study_class1,
subject=cls.subject,
avg_sem1=4,
avg_final=6)
StudentCatalogPerSubjectFactory(student=cls.student1,
study_class=cls.study_class1,
subject=coordination_subject,
avg_sem1=7,
avg_final=9)
cls.study_class2 = StudyClassFactory(school_unit=cls.school1,
class_grade='XII',
class_grade_arabic=12)
# Average below limit (both sem) - 12th grade
cls.student2 = UserProfileFactory(
school_unit=cls.school1,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class2)
StudentCatalogPerYearFactory(student=cls.student2,
study_class=cls.study_class2)
StudentCatalogPerSubjectFactory(student=cls.student2,
study_class=cls.study_class2,
subject=cls.subject)
StudentCatalogPerSubjectFactory(student=cls.student2,
study_class=cls.study_class2,
subject=cls.subject,
avg_sem1=4,
avg_sem2=1)
cls.school2 = RegisteredSchoolUnitFactory()
cls.school2.categories.add(
SchoolUnitCategoryFactory(name='Liceu - Filieră Tehnologică'))
cls.study_class3 = StudyClassFactory(school_unit=cls.school2,
class_grade='VIII',
class_grade_arabic=8)
# Average below limit (both sem) - 8th grade
cls.student3 = UserProfileFactory(
school_unit=cls.school2,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class3)
StudentCatalogPerYearFactory(student=cls.student3,
study_class=cls.study_class3)
StudentCatalogPerSubjectFactory(student=cls.student3,
study_class=cls.study_class3,
subject=cls.subject,
avg_sem1=4,
avg_sem2=3)
cls.study_class4 = StudyClassFactory(school_unit=cls.school2,
class_grade='IX',
class_grade_arabic=9)
# Averages below limit (both sem) - 9th grade, technological
cls.student4 = UserProfileFactory(
school_unit=cls.school2,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class4)
StudentCatalogPerYearFactory(student=cls.student4,
study_class=cls.study_class4)
StudentCatalogPerSubjectFactory(student=cls.student4,
study_class=cls.study_class4,
subject=cls.subject,
avg_sem1=4,
avg_sem2=2)
StudentCatalogPerSubjectFactory(student=cls.student4,
study_class=cls.study_class4,
subject=cls.subject2,
avg_sem1=3,
avg_sem2=4)
def test_catalog_import_success(self):
self.client.login(username=self.teacher.username, password='******')
file = self.create_file(self.file_name)
writer = self.write_data(file, self.data)
# Create a few thesis and difference grade that should be deleted
difference_sem1 = ExaminationGradeFactory(
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE,
examination_type=ExaminationGrade.ExaminationTypes.ORAL,
catalog_per_subject=self.catalog,
semester=1)
other_student = UserProfileFactory(
user_role=UserProfile.UserRoles.STUDENT,
school_unit=self.school,
student_in_class=self.study_class)
other_catalog = StudentCatalogPerSubjectFactory(
study_class=self.study_class,
teacher=self.teacher,
subject=self.subject,
student=other_student,
is_enrolled=True)
other_catalog_per_year = StudentCatalogPerYearFactory(
study_class=self.study_class, student=other_student)
self.data['Nume'] = other_student.full_name
writer.writerow(self.data)
writer.writerow({})
response = self.get_response(
self.build_url(self.study_class.id, self.subject.id), file)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertNotIn(1, response.data['errors'])
self.assertNotIn(2, response.data['errors'])
self.assertNotEqual(response.data['errors'][3], {})
self.assertEqual(response.data['report'],
'2 out of 3 catalogs saved successfully.')
self.assertFalse(
ExaminationGrade.objects.filter(id=difference_sem1.id).exists())
self.catalog = self.student.student_catalogs_per_subject.first()
other_catalog = other_student.student_catalogs_per_subject.first()
for catalog in [self.catalog, other_catalog]:
self.assertEqual(catalog.remarks, self.data['Observații'])
self.assertEqual(catalog.wants_level_testing_grade, True)
self.assertEqual(catalog.wants_thesis, True)
self.assertEqual(catalog.wants_simulation, True)
self.assertEqual(catalog.is_exempted, False)
self.assertEqual(catalog.is_enrolled, True)
self.assertEqual(
catalog.founded_abs_count_sem1,
len(self.data['Absențe motivate sem. I'].split('; ')))
self.assertEqual(
catalog.unfounded_abs_count_sem1,
len(self.data['Absențe nemotivate sem. I'].split('; ')))
self.assertEqual(
catalog.founded_abs_count_sem2,
len(self.data['Absențe motivate sem. II'].split('; ')))
self.assertEqual(
catalog.unfounded_abs_count_sem2,
len(self.data['Absențe nemotivate sem. II'].split('; ')))
self.assertEqual(
catalog.founded_abs_count_annual,
catalog.founded_abs_count_sem1 +
catalog.founded_abs_count_sem2)
self.assertEqual(
catalog.unfounded_abs_count_annual,
catalog.unfounded_abs_count_sem1 +
catalog.unfounded_abs_count_sem2)
for student in [self.student, other_student]:
self.assertCountEqual(student.labels.values_list('id', flat=True),
[self.label.id, self.label2.id])
self.study_class.refresh_from_db()
self.assertEqual(self.study_class.avg_sem1, 8)
self.assertEqual(self.study_class.avg_annual, Decimal(8.25))
self.assertEqual(self.study_class.unfounded_abs_avg_sem1, 2)
self.assertEqual(self.study_class.unfounded_abs_avg_sem2, 2)
self.assertEqual(self.study_class.unfounded_abs_avg_annual, 4)
self.assertEqual(
self.study_class.academic_program.unfounded_abs_avg_sem1, 2)
self.assertEqual(
self.study_class.academic_program.unfounded_abs_avg_sem2, 2)
self.assertEqual(
self.study_class.academic_program.unfounded_abs_avg_annual, 4)
for catalog in [self.catalog, other_catalog]:
self.assertEqual(
catalog.grades.filter(
semester=1,
taken_at__in=[
datetime.date(2019, 12, 13),
datetime.date(2019, 12, 12)
],
grade=10,
grade_type=SubjectGrade.GradeTypes.REGULAR).count(), 0)
self.assertEqual(
catalog.grades.filter(
semester=1,
taken_at=datetime.date(2019, 12, 19),
grade=7,
grade_type=SubjectGrade.GradeTypes.THESIS).count(), 0)
self.assertEqual(
catalog.grades.filter(
semester=2,
taken_at__in=[
datetime.date(2020, 4, 4),
datetime.date(2020, 4, 5)
],
grade=10,
grade_type=SubjectGrade.GradeTypes.REGULAR).count(), 2)
self.assertEqual(
catalog.grades.filter(
semester=2,
taken_at=datetime.date(2020, 4, 4),
grade=7,
grade_type=SubjectGrade.GradeTypes.THESIS).count(), 1)
self.assertEqual(
catalog.absences.filter(semester=1,
taken_at__in=[
datetime.date(2019, 12, 12),
datetime.date(2019, 12, 13)
],
is_founded=True).count(), 2)
self.assertEqual(
catalog.absences.filter(semester=1,
taken_at__in=[
datetime.date(2019, 12, 12),
datetime.date(2019, 12, 13)
],
is_founded=False).count(), 2)
self.assertEqual(
catalog.absences.filter(semester=2,
taken_at__in=[
datetime.date(2020, 4, 4),
datetime.date(2020, 4, 5)
],
is_founded=True).count(), 2)
self.assertEqual(
catalog.absences.filter(semester=2,
taken_at__in=[
datetime.date(2020, 4, 4),
datetime.date(2020, 4, 5)
],
is_founded=False).count(), 2)
self.assertEqual(
catalog.examination_grades.filter(
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE,
examination_type=ExaminationGrade.ExaminationTypes.ORAL,
semester=1,
taken_at=datetime.date(2019, 12, 22),
grade1=6,
grade2=7).count(), 1)
self.assertEqual(
catalog.examination_grades.filter(
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE,
examination_type=ExaminationGrade.ExaminationTypes.ORAL,
semester=1,
taken_at=datetime.date(2019, 12, 22),
grade1=6,
grade2=7).count(), 1)
self.assertEqual(
catalog.examination_grades.filter(
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE,
examination_type=ExaminationGrade.ExaminationTypes.ORAL,
semester=2,
taken_at=datetime.date(2020, 4, 20),
grade1=6,
grade2=7).count(), 0)
self.assertEqual(
catalog.examination_grades.filter(
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE,
examination_type=ExaminationGrade.ExaminationTypes.WRITTEN,
semester=2,
taken_at=datetime.date(2020, 4, 20),
grade1=8,
grade2=9).count(), 0)
self.assertEqual(
catalog.examination_grades.filter(
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE,
examination_type=ExaminationGrade.ExaminationTypes.ORAL,
taken_at=datetime.date(2019, 12, 22),
grade1=6,
grade2=7,
semester__isnull=True).count(), 0)
self.assertEqual(
catalog.examination_grades.filter(
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE,
examination_type=ExaminationGrade.ExaminationTypes.WRITTEN,
taken_at=datetime.date(2019, 12, 22),
grade1=8,
grade2=9,
semester__isnull=True).count(), 0)
self.assertEqual(
catalog.examination_grades.filter(
grade_type=ExaminationGrade.GradeTypes.SECOND_EXAMINATION,
examination_type=ExaminationGrade.ExaminationTypes.ORAL,
taken_at=datetime.date(2020, 5, 5),
grade1=6,
grade2=7).count(), 1)
self.assertEqual(
catalog.examination_grades.filter(
grade_type=ExaminationGrade.GradeTypes.SECOND_EXAMINATION,
examination_type=ExaminationGrade.ExaminationTypes.WRITTEN,
taken_at=datetime.date(2020, 5, 5),
grade1=8,
grade2=9).count(), 1)
for field in [
'wants_level_testing_grade', 'wants_thesis',
'wants_simulation', 'is_enrolled'
]:
self.assertTrue(getattr(catalog, field), True)
self.assertFalse(catalog.is_exempted)
def test_student_placement_during_first_semester(self, mocked_method):
catalog1 = StudentCatalogPerYearFactory(study_class=self.study_class,
avg_sem1=1,
avg_sem2=1,
avg_annual=1,
abs_count_sem1=1,
abs_count_sem2=1,
abs_count_annual=1)
catalog2 = StudentCatalogPerYearFactory(study_class=self.study_class,
avg_sem1=None,
avg_sem2=None,
avg_annual=None,
abs_count_sem1=2,
abs_count_sem2=2,
abs_count_annual=2)
catalog3 = StudentCatalogPerYearFactory(study_class=self.study_class,
avg_sem1=3,
avg_sem2=3,
avg_annual=3,
abs_count_sem1=3,
abs_count_sem2=3,
abs_count_annual=3)
other_class = StudyClassFactory(school_unit=self.school)
catalog4 = StudentCatalogPerYearFactory(study_class=other_class,
avg_sem1=4,
avg_sem2=4,
avg_annual=4,
abs_count_sem1=4,
abs_count_sem2=4,
abs_count_annual=4)
catalog5 = StudentCatalogPerYearFactory(study_class=other_class,
avg_sem1=5,
avg_sem2=5,
avg_annual=5,
abs_count_sem1=5,
abs_count_sem2=5,
abs_count_annual=5)
other_class2 = StudyClassFactory()
catalog6 = StudentCatalogPerYearFactory(study_class=other_class2,
avg_sem1=10,
avg_sem2=10,
avg_annual=10,
abs_count_sem1=10,
abs_count_sem2=10,
abs_count_annual=10)
self.assertTrue(calculate_student_placements())
catalog1.refresh_from_db()
catalog2.refresh_from_db()
catalog3.refresh_from_db()
catalog4.refresh_from_db()
catalog5.refresh_from_db()
self.assertEqual(catalog3.class_place_by_avg_sem1, 1)
self.assertEqual(catalog1.class_place_by_avg_sem1, 2)
self.assertEqual(catalog2.class_place_by_avg_sem1, 3)
self.assertEqual(catalog3.class_place_by_abs_sem1, 1)
self.assertEqual(catalog2.class_place_by_abs_sem1, 2)
self.assertEqual(catalog1.class_place_by_abs_sem1, 3)
self.assertEqual(catalog4.class_place_by_avg_sem1, 2)
self.assertEqual(catalog5.class_place_by_avg_sem1, 1)
self.assertEqual(catalog4.class_place_by_abs_sem1, 2)
self.assertEqual(catalog5.class_place_by_abs_sem1, 1)
self.assertEqual(catalog3.school_place_by_avg_sem1, 3)
self.assertEqual(catalog1.school_place_by_avg_sem1, 4)
self.assertEqual(catalog2.school_place_by_avg_sem1, 5)
self.assertEqual(catalog3.school_place_by_abs_sem1, 3)
self.assertEqual(catalog2.school_place_by_abs_sem1, 4)
self.assertEqual(catalog1.school_place_by_abs_sem1, 5)
self.assertEqual(catalog4.school_place_by_abs_sem1, 2)
self.assertEqual(catalog5.school_place_by_abs_sem1, 1)
self.assertEqual(catalog4.class_place_by_abs_sem1, 2)
self.assertEqual(catalog5.class_place_by_abs_sem1, 1)
for field in [
'class_place_by_avg_sem2', 'class_place_by_avg_annual',
'class_place_by_abs_sem2', 'class_place_by_abs_annual',
'school_place_by_avg_sem2', 'school_place_by_avg_annual',
'school_place_by_abs_sem2', 'school_place_by_abs_annual'
]:
self.assertIsNone(getattr(catalog1, field))
self.assertIsNone(getattr(catalog2, field))
self.assertIsNone(getattr(catalog3, field))
self.assertIsNone(getattr(catalog4, field))
self.assertIsNone(getattr(catalog5, field))
def test_student_placement_during_second_semester(self, mocked_method):
catalog1 = StudentCatalogPerYearFactory(study_class=self.study_class,
avg_sem1=1,
avg_sem2=1,
avg_annual=5,
avg_final=1,
abs_count_sem1=1,
abs_count_sem2=1,
abs_count_annual=1)
catalog2 = StudentCatalogPerYearFactory(study_class=self.study_class,
avg_sem1=2,
avg_sem2=2,
avg_annual=1,
avg_final=2,
abs_count_sem1=2,
abs_count_sem2=2,
abs_count_annual=2)
catalog3 = StudentCatalogPerYearFactory(study_class=self.study_class,
avg_sem1=3,
avg_sem2=3,
avg_annual=6,
avg_final=3,
abs_count_sem1=3,
abs_count_sem2=3,
abs_count_annual=3)
other_class = StudyClassFactory(school_unit=self.school)
catalog4 = StudentCatalogPerYearFactory(study_class=other_class,
avg_sem1=4,
avg_sem2=4,
avg_annual=1,
avg_final=4,
abs_count_sem1=4,
abs_count_sem2=4,
abs_count_annual=4)
catalog5 = StudentCatalogPerYearFactory(study_class=other_class,
avg_sem1=4,
avg_sem2=4,
avg_annual=2,
avg_final=4,
abs_count_sem1=4,
abs_count_sem2=4,
abs_count_annual=4)
other_class2 = StudyClassFactory()
catalog6 = StudentCatalogPerYearFactory(study_class=other_class2,
avg_sem1=10,
avg_sem2=10,
avg_annual=10,
abs_count_sem1=10,
abs_count_sem2=10,
abs_count_annual=10)
self.assertTrue(calculate_student_placements())
catalog1.refresh_from_db()
catalog2.refresh_from_db()
catalog3.refresh_from_db()
catalog4.refresh_from_db()
catalog5.refresh_from_db()
self.assertEqual(catalog3.class_place_by_avg_sem1, 1)
self.assertEqual(catalog2.class_place_by_avg_sem1, 2)
self.assertEqual(catalog1.class_place_by_avg_sem1, 3)
self.assertEqual(catalog3.class_place_by_abs_sem1, 1)
self.assertEqual(catalog2.class_place_by_abs_sem1, 2)
self.assertEqual(catalog1.class_place_by_abs_sem1, 3)
self.assertEqual(catalog3.class_place_by_avg_sem2, 1)
self.assertEqual(catalog2.class_place_by_avg_sem2, 2)
self.assertEqual(catalog1.class_place_by_avg_sem2, 3)
self.assertEqual(catalog3.class_place_by_abs_sem2, 1)
self.assertEqual(catalog2.class_place_by_abs_sem2, 2)
self.assertEqual(catalog1.class_place_by_abs_sem2, 3)
self.assertEqual(catalog3.class_place_by_avg_annual, 1)
self.assertEqual(catalog2.class_place_by_avg_annual, 2)
self.assertEqual(catalog1.class_place_by_avg_annual, 3)
self.assertEqual(catalog3.class_place_by_abs_annual, 1)
self.assertEqual(catalog2.class_place_by_abs_annual, 2)
self.assertEqual(catalog1.class_place_by_abs_annual, 3)
self.assertEqual(catalog4.class_place_by_avg_sem1, 1)
self.assertEqual(catalog5.class_place_by_avg_sem1, 1)
self.assertEqual(catalog4.class_place_by_abs_sem1, 1)
self.assertEqual(catalog5.class_place_by_abs_sem1, 1)
self.assertEqual(catalog4.class_place_by_avg_sem2, 1)
self.assertEqual(catalog5.class_place_by_avg_sem2, 1)
self.assertEqual(catalog4.class_place_by_abs_sem2, 1)
self.assertEqual(catalog5.class_place_by_abs_sem2, 1)
self.assertEqual(catalog4.class_place_by_avg_annual, 1)
self.assertEqual(catalog5.class_place_by_avg_annual, 1)
self.assertEqual(catalog4.class_place_by_abs_annual, 1)
self.assertEqual(catalog5.class_place_by_abs_annual, 1)
self.assertEqual(catalog3.school_place_by_avg_sem1, 2)
self.assertEqual(catalog2.school_place_by_avg_sem1, 3)
self.assertEqual(catalog1.school_place_by_avg_sem1, 4)
self.assertEqual(catalog3.school_place_by_abs_sem1, 2)
self.assertEqual(catalog2.school_place_by_abs_sem1, 3)
self.assertEqual(catalog1.school_place_by_abs_sem1, 4)
self.assertEqual(catalog3.school_place_by_avg_sem2, 2)
self.assertEqual(catalog2.school_place_by_avg_sem2, 3)
self.assertEqual(catalog1.school_place_by_avg_sem2, 4)
self.assertEqual(catalog3.school_place_by_abs_sem2, 2)
self.assertEqual(catalog2.school_place_by_abs_sem2, 3)
self.assertEqual(catalog1.school_place_by_abs_sem2, 4)
self.assertEqual(catalog3.school_place_by_avg_annual, 2)
self.assertEqual(catalog2.school_place_by_avg_annual, 3)
self.assertEqual(catalog1.school_place_by_avg_annual, 4)
self.assertEqual(catalog3.school_place_by_abs_annual, 2)
self.assertEqual(catalog2.school_place_by_abs_annual, 3)
self.assertEqual(catalog1.school_place_by_abs_annual, 4)
self.assertEqual(catalog4.school_place_by_abs_sem1, 1)
self.assertEqual(catalog5.school_place_by_abs_sem1, 1)
self.assertEqual(catalog4.class_place_by_abs_sem1, 1)
self.assertEqual(catalog5.class_place_by_abs_sem1, 1)
self.assertEqual(catalog4.school_place_by_abs_sem2, 1)
self.assertEqual(catalog5.school_place_by_abs_sem2, 1)
self.assertEqual(catalog4.class_place_by_abs_sem2, 1)
self.assertEqual(catalog5.class_place_by_abs_sem2, 1)
self.assertEqual(catalog4.school_place_by_abs_annual, 1)
self.assertEqual(catalog5.school_place_by_abs_annual, 1)
self.assertEqual(catalog4.class_place_by_abs_annual, 1)
self.assertEqual(catalog5.class_place_by_abs_annual, 1)