def test_study_class_partially_update_move_student_from_different_school(self):
self.client.login(username=self.principal.username, password='******')
self.new_student.labels.add(
LabelFactory(text=TRANSFERRED_LABEL, is_label_for_transfers_between_schools=True)
)
another_school_unit = RegisteredSchoolUnitFactory()
another_school_profile = UserProfileFactory(school_unit=another_school_unit, full_name=self.new_student.full_name,
username='******'.format(another_school_unit.id, self.new_student.email),
email=self.new_student.email,
phone_number=self.new_student.phone_number, user_role=UserProfile.UserRoles.STUDENT)
prev_study_class = StudyClassFactory(school_unit=self.school_unit, class_master=self.teacher1, academic_program=self.academic_program,
class_grade='IX', class_grade_arabic=9, class_letter='A', academic_year=self.calendar.academic_year - 1)
TeacherClassThroughFactory(study_class=prev_study_class, teacher=self.teacher1, subject=self.coordination_subject, is_class_master=True)
TeacherClassThroughFactory(study_class=prev_study_class, teacher=self.teacher1, subject=self.subject1, is_class_master=True)
TeacherClassThroughFactory(study_class=prev_study_class, teacher=self.teacher2, subject=self.subject2, is_class_master=True,
is_optional_subject=True)
student_prev_study_class = StudyClassFactory(school_unit=another_school_unit, class_grade='IX', class_grade_arabic=9,
academic_year=self.calendar.academic_year - 1)
StudentCatalogPerYearFactory(student=another_school_profile, study_class=student_prev_study_class,
avg_sem1=9, avg_sem2=9, avg_annual=9, avg_final=9)
catalog1 = StudentCatalogPerSubjectFactory(student=another_school_profile, study_class=student_prev_study_class,
subject=self.coordination_subject, avg_sem1=8, avg_sem2=8, avg_annual=8, avg_final=8)
SubjectGradeFactory(student=another_school_profile, catalog_per_subject=catalog1, grade=8)
SubjectAbsenceFactory(student=another_school_profile, catalog_per_subject=catalog1, is_founded=True)
catalog2 = StudentCatalogPerSubjectFactory(student=another_school_profile, study_class=student_prev_study_class, subject=self.subject2,
avg_sem1=10, avg_sem2=10, avg_annual=10, avg_final=10)
ExaminationGradeFactory(student=another_school_profile, catalog_per_subject=catalog2)
self.request_data = {
"new_students": [self.new_student.id]
}
response = self.client.patch(self.build_url(self.study_class.id), self.request_data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
catalog_per_year = StudentCatalogPerYear.objects.get(student=self.new_student, study_class=prev_study_class)
for average in [catalog_per_year.avg_sem1, catalog_per_year.avg_sem2, catalog_per_year.avg_annual, catalog_per_year.avg_final]:
self.assertEqual(average, 9)
new_catalog1 = StudentCatalogPerSubject.objects.get(student=self.new_student, study_class=prev_study_class,
subject=self.coordination_subject, teacher=self.teacher1)
for average in [new_catalog1.avg_sem1, new_catalog1.avg_sem2, new_catalog1.avg_annual, new_catalog1.avg_final]:
self.assertEqual(average, 8)
self.assertEqual(new_catalog1.grades.count(), 1)
self.assertEqual(new_catalog1.absences.count(), 1)
new_catalog2 = StudentCatalogPerSubject.objects.get(student=self.new_student, study_class=prev_study_class,
subject=self.subject2, teacher=self.teacher2)
for average in [new_catalog2.avg_sem1, new_catalog2.avg_sem2, new_catalog2.avg_annual, new_catalog2.avg_final]:
self.assertEqual(average, 10)
self.assertEqual(new_catalog2.examination_grades.count(), 1)
new_catalog3 = StudentCatalogPerSubject.objects.get(student=self.new_student, study_class=prev_study_class,
subject=self.subject1, teacher=self.teacher1)
for average in [new_catalog3.avg_sem1, new_catalog3.avg_sem2, new_catalog3.avg_annual, new_catalog3.avg_final]:
self.assertEqual(average, None)
def test_bulk_create_absence_validate_student(self, timezone_mock):
self.client.login(username=self.teacher.username, password='******')
self.request_data['taken_at'] = date(2019, 9, 20)
self.request_data['student_absences'][0]['student'] = 0
response = self.client.post(self.build_url(self.study_class.id, self.subject.id), data=self.request_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data['student_absences'][0]['student'], ['Invalid pk "0" - object does not exist.'])
# Not student in class
student1 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=self.school_unit)
# Not enrolled
student2 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=self.school_unit, student_in_class=self.study_class)
StudentCatalogPerSubjectFactory(student=student2, study_class=self.study_class, teacher=self.teacher, subject=self.subject, is_enrolled=False)
# Not active
student3 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=self.school_unit,
student_in_class=self.study_class, is_active=False)
StudentCatalogPerSubjectFactory(student=student3, study_class=self.study_class, teacher=self.teacher, subject=self.subject)
for student in [student1, student2, student3]:
self.request_data['student_absences'][0]['student'] = student.id
response = self.client.post(self.build_url(self.study_class.id, self.subject.id), data=self.request_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data['student'], [f'Invalid pk "{student.id}" - object does not exist.'])
def setUpTestData(cls):
cls.academic_calendar = AcademicYearCalendarFactory()
cls.academic_year = cls.academic_calendar.academic_year
cls.starts_at = datetime.date(2020, 10, 21)
cls.ends_at = datetime.date(2020, 10, 27)
cls.school = RegisteredSchoolUnitFactory()
cls.study_class = StudyClassFactory(school_unit=cls.school)
cls.student = UserProfileFactory(
school_unit=cls.school,
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class,
full_name="Pop Ionut")
cls.subject1 = SubjectFactory(name='Limba Romana')
cls.subject2 = SubjectFactory(name='Matematica')
cls.catalog1 = StudentCatalogPerSubjectFactory(
student=cls.student,
study_class=cls.study_class,
subject=cls.subject1)
cls.catalog2 = StudentCatalogPerSubjectFactory(
student=cls.student,
study_class=cls.study_class,
subject=cls.subject2)
def setUpTestData(cls):
cls.calendar = AcademicYearCalendarFactory()
cls.school_unit = RegisteredSchoolUnitFactory()
cls.school_stats = SchoolUnitStatsFactory(school_unit=cls.school_unit)
cls.teacher = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school_unit)
cls.study_class = StudyClassFactory(school_unit=cls.school_unit, class_master=cls.teacher)
cls.subject = SubjectFactory()
ProgramSubjectThroughFactory(academic_program=cls.study_class.academic_program, subject=cls.subject, weekly_hours_count=3,
class_grade=cls.study_class.class_grade, class_grade_arabic=cls.study_class.class_grade_arabic)
TeacherClassThroughFactory(teacher=cls.teacher, study_class=cls.study_class, is_class_master=True, subject=cls.subject)
cls.student1 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school_unit, student_in_class=cls.study_class)
cls.catalog1 = StudentCatalogPerSubjectFactory(student=cls.student1, study_class=cls.study_class, teacher=cls.teacher, subject=cls.subject)
cls.catalog_per_year1 = StudentCatalogPerYearFactory(student=cls.student1, study_class=cls.study_class)
cls.student2 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school_unit, student_in_class=cls.study_class)
cls.catalog2 = StudentCatalogPerSubjectFactory(student=cls.student2, study_class=cls.study_class, teacher=cls.teacher, subject=cls.subject)
cls.catalog_per_year2 = StudentCatalogPerYearFactory(student=cls.student2, study_class=cls.study_class)
cls.expected_fields = [
'id', 'student', 'avg_sem1', 'avg_sem2', 'avg_annual', 'avg_after_2nd_examination', 'avg_limit', 'abs_count_sem1', 'abs_count_sem2',
'abs_count_annual', 'founded_abs_count_sem1', 'founded_abs_count_sem2', 'founded_abs_count_annual', 'unfounded_abs_count_sem1',
'unfounded_abs_count_sem2', 'unfounded_abs_count_annual', 'grades_sem1', 'grades_sem2', 'abs_sem1', 'abs_sem2',
'second_examination_grades', 'difference_grades_sem1', 'difference_grades_sem2', 'wants_thesis', 'is_exempted',
'third_of_hours_count_sem1', 'third_of_hours_count_sem2', 'third_of_hours_count_annual', 'is_coordination_subject'
]
def test_own_child_school_situation_success(self):
self.client.login(username=self.parent.username, password='******')
another_catalog = StudentCatalogPerSubjectFactory(
student=self.student,
study_class=self.study_class,
academic_year=self.calendar.academic_year)
ProgramSubjectThroughFactory(
academic_program=self.study_class.academic_program,
class_grade=self.study_class.class_grade,
subject=another_catalog.subject,
weekly_hours_count=5)
StudentCatalogPerSubjectFactory(
student=self.student,
academic_year=self.calendar.academic_year - 1)
expected_fields = [
'id', 'full_name', 'study_class', 'labels', 'risk_description',
'catalogs_per_subjects'
]
expected_study_class_fields = [
'id', 'class_grade', 'class_letter', 'academic_program_name',
'class_master'
]
expected_class_master_fields = ['id', 'full_name']
expected_catalog_fields = [
'id', 'subject_name', 'teacher', 'avg_sem1', 'avg_sem2',
'avg_annual', 'avg_after_2nd_examination', 'avg_limit',
'grades_sem1', 'grades_sem2', 'second_examination_grades',
'difference_grades_sem1', 'difference_grades_sem2',
'abs_count_sem1', 'abs_count_sem2', 'abs_count_annual',
'founded_abs_count_sem1', 'founded_abs_count_sem2',
'founded_abs_count_annual', 'unfounded_abs_count_sem1',
'unfounded_abs_count_sem2', 'unfounded_abs_count_annual',
'third_of_hours_count_sem1', 'third_of_hours_count_sem2',
'third_of_hours_count_annual', 'abs_sem1', 'abs_sem2',
'wants_thesis', 'is_exempted', 'is_coordination_subject'
]
response = self.client.get(self.build_url(self.student.id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertCountEqual(response.data.keys(), expected_fields)
self.assertCountEqual(response.data['study_class'].keys(),
expected_study_class_fields)
self.assertCountEqual(
response.data['study_class']['class_master'].keys(),
expected_class_master_fields)
self.assertEqual(len(response.data['catalogs_per_subjects']), 2)
for catalog in response.data['catalogs_per_subjects']:
self.assertCountEqual(catalog.keys(), expected_catalog_fields)
self.assertEqual(catalog['avg_limit'], 5)
self.assertEqual(catalog['third_of_hours_count_sem1'], 25)
self.assertEqual(catalog['third_of_hours_count_sem2'], 25)
self.assertEqual(catalog['third_of_hours_count_annual'], 50)
def test_own_study_class_catalog_per_subject_ordering(self, ordering):
self.client.login(username=self.teacher.username, password='******')
StudentCatalogPerSubjectFactory(
subject=self.subject,
teacher=self.teacher,
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, full_name='a'),
study_class=self.study_class,
academic_year=2020,
avg_sem1=1,
avg_sem2=1,
avg_final=1,
abs_count_sem1=1,
abs_count_sem2=1,
abs_count_annual=1
)
StudentCatalogPerSubjectFactory(
subject=self.subject,
teacher=self.teacher,
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, full_name='b'),
study_class=self.study_class,
academic_year=2020,
avg_sem1=2,
avg_sem2=2,
avg_final=2,
abs_count_sem1=2,
abs_count_sem2=2,
abs_count_annual=2
)
StudentCatalogPerSubjectFactory(
subject=self.subject,
teacher=self.teacher,
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, full_name='c'),
study_class=self.study_class,
academic_year=2020,
avg_sem1=3,
avg_sem2=3,
avg_final=3,
abs_count_sem1=3,
abs_count_sem2=3,
abs_count_annual=3
)
response = self.client.get(self.build_url(self.study_class.id, self.subject.id), {'ordering': ordering} if ordering else None)
self.assertEqual(response.status_code, status.HTTP_200_OK)
if not ordering or ordering == 'student_name':
ordering = 'student__full_name'
if ordering == '-student_name':
ordering = '-student__full_name'
for catalog_data, catalog in zip(response.data, StudentCatalogPerSubject.objects.order_by(ordering)):
self.assertEqual(catalog_data['id'], catalog.id)
def test_move_student_ninth_grade(self):
self.client.login(username=self.principal.username, password='******')
for study_class in [self.study_class, self.source_study_class]:
study_class.class_grade = 'IX'
study_class.class_grade_arabic = 9
study_class.save()
catalog_per_year = 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)
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_year,
catalog_per_subject1, catalog_per_subject2
])
self.assertEqual(self.student.student_in_class, self.study_class)
self.assertEqual(catalog_per_year.study_class, self.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(
StudentCatalogPerSubject.objects.filter(
student=self.student,
teacher=self.study_class.class_master,
study_class=self.study_class,
subject=self.subject2).exists())
self.assertIsNotNone(self.principal.last_change_in_catalog)
self.assertIsNotNone(self.school_unit.last_change_in_catalog)
def test_catalog_settings_success(self):
self.client.login(username=self.teacher.username, password='******')
catalog1 = StudentCatalogPerSubjectFactory(
subject=self.subject,
teacher=self.teacher,
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT,
full_name='c'),
study_class=self.study_class)
catalog2 = StudentCatalogPerSubjectFactory(
subject=self.subject,
teacher=self.teacher,
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT,
full_name='a'),
study_class=self.study_class)
catalog3 = StudentCatalogPerSubjectFactory(
subject=self.subject,
teacher=self.teacher,
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT,
full_name='b'),
study_class=self.study_class)
StudentCatalogPerSubjectFactory(
subject=self.subject,
teacher=self.teacher,
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT,
full_name='d',
is_active=False),
study_class=self.study_class)
response = self.client.get(
self.build_url(self.study_class.id, self.subject.id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 3)
catalog_expected_fields = [
'id', 'student', 'wants_level_testing_grade', 'wants_thesis',
'wants_simulation', 'is_exempted', 'is_enrolled'
]
student_expected_fields = ['id', 'full_name']
for catalog_data in response.data:
self.assertCountEqual(catalog_data.keys(), catalog_expected_fields)
self.assertCountEqual(catalog_data['student'].keys(),
student_expected_fields)
self.assertEqual(response.data[0]['id'], catalog2.id)
self.assertEqual(response.data[1]['id'], catalog3.id)
self.assertEqual(response.data[2]['id'], catalog1.id)
def test_grade_create_secondary_school_averages(self, mocked_method):
# This is for a subject with weekly hours count = 1 and no thesis (1st semester)
self.client.login(username=self.teacher.username, password='******')
# Add a few more catalogs per subject for this student
StudentCatalogPerSubjectFactory(student=self.student,
study_class=self.study_class,
avg_sem1=9)
StudentCatalogPerSubjectFactory(student=self.student,
study_class=self.study_class,
is_enrolled=False)
StudentCatalogPerSubjectFactory(student=self.student,
study_class=self.study_class,
is_exempted=True)
# Add year catalog for a different student
StudentCatalogPerYearFactory(study_class=self.study_class, avg_sem1=9)
self.data['taken_at'] = date(2019, 11, 10)
response = self.client.post(self.build_url(self.catalog.id), self.data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# because the student doesn't have enough grades, the average shouldn't be computed yet
self.catalog.refresh_from_db()
self.assertIsNone(self.catalog.avg_sem1)
self.assertIsNone(self.catalog.avg_sem2)
self.assertIsNone(self.catalog.avg_annual)
self.assertIsNone(self.catalog.avg_final)
# Add another grade, so we can compute the average
self.data['grade'] = 9
response = self.client.post(self.build_url(self.catalog.id), self.data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.refresh_objects_from_db([
self.catalog, self.catalog_per_year, self.study_class,
self.school_stats
])
self.assertEqual(self.catalog.avg_sem1, 10)
self.assertEqual(self.catalog_per_year.avg_sem1, 9.5)
for catalog in [self.catalog, self.catalog_per_year]:
self.assertIsNone(catalog.avg_sem2)
self.assertIsNone(catalog.avg_annual)
self.assertIsNone(catalog.avg_final)
for obj in [self.study_class, self.school_stats]:
self.assertEqual(obj.avg_sem1, 9.25)
self.assertIsNone(obj.avg_sem2)
self.assertIsNone(obj.avg_annual)
def setUpTestData(cls):
cls.academic_calendar = AcademicYearCalendarFactory()
cls.corigente_event = SchoolEventFactory(
event_type=SchoolEvent.EventTypes.CORIGENTE,
academic_year_calendar=cls.academic_calendar,
starts_at=datetime.date(2020, 8, 20),
ends_at=datetime.date(2020, 8, 27))
cls.diferente_event = SchoolEventFactory(
event_type=SchoolEvent.EventTypes.DIFERENTE,
academic_year_calendar=cls.academic_calendar,
starts_at=datetime.date(2020, 9, 1),
ends_at=datetime.date(2020, 9, 8))
cls.school_unit = RegisteredSchoolUnitFactory()
cls.school_stats = SchoolUnitStatsFactory(school_unit=cls.school_unit)
cls.teacher = UserProfileFactory(
user_role=UserProfile.UserRoles.TEACHER,
school_unit=cls.school_unit)
cls.study_class = StudyClassFactory(school_unit=cls.school_unit,
class_grade='IX',
class_grade_arabic=9)
cls.subject = SubjectFactory()
ProgramSubjectThroughFactory(
academic_program=cls.study_class.academic_program,
class_grade='IX',
subject=cls.subject,
weekly_hours_count=3)
cls.student = UserProfileFactory(
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class)
cls.teacher_class_through = TeacherClassThroughFactory(
study_class=cls.study_class,
teacher=cls.teacher,
subject=cls.subject)
cls.catalog = StudentCatalogPerSubjectFactory(
subject=cls.subject,
teacher=cls.teacher,
student=cls.student,
study_class=cls.study_class)
cls.catalog_per_year = StudentCatalogPerYearFactory(
student=cls.student, study_class=cls.study_class)
cls.expected_fields = [
'id', 'student', 'avg_sem1', 'avg_sem2', 'avg_annual',
'avg_after_2nd_examination', 'avg_limit', 'abs_count_sem1',
'abs_count_sem2', 'abs_count_annual', 'founded_abs_count_sem1',
'founded_abs_count_sem2', 'founded_abs_count_annual',
'unfounded_abs_count_sem1', 'unfounded_abs_count_sem2',
'unfounded_abs_count_annual', 'grades_sem1', 'grades_sem2',
'abs_sem1', 'abs_sem2', 'second_examination_grades',
'difference_grades_sem1', 'difference_grades_sem2', 'wants_thesis',
'is_exempted', 'third_of_hours_count_sem1',
'third_of_hours_count_sem2', 'third_of_hours_count_annual',
'is_coordination_subject'
]
cls.examination_grade_fields = [
'id', 'examination_type', 'taken_at', 'grade1', 'grade2', 'created'
]
def test_get_grades_for_students(self):
self.assertEqual(
get_grades_for_students(self.student.id, self.starts_at,
self.ends_at).count(), 0)
catalog = StudentCatalogPerSubjectFactory(is_coordination_subject=True)
SubjectGradeFactory(student=self.student,
catalog_per_subject=self.catalog1,
taken_at=self.starts_at -
timezone.timedelta(days=1))
SubjectGradeFactory(student=self.student,
catalog_per_subject=self.catalog1,
taken_at=self.starts_at)
SubjectGradeFactory(student=self.student,
catalog_per_subject=self.catalog1,
taken_at=self.starts_at +
timezone.timedelta(days=1))
SubjectGradeFactory(student=self.student,
catalog_per_subject=self.catalog2,
taken_at=self.ends_at - timezone.timedelta(days=1))
SubjectGradeFactory(student=self.student,
catalog_per_subject=self.catalog2,
taken_at=self.ends_at)
SubjectGradeFactory(student=self.student,
catalog_per_subject=catalog,
taken_at=self.ends_at)
SubjectGradeFactory(student=self.student,
catalog_per_subject=self.catalog2,
taken_at=self.ends_at + timezone.timedelta(days=1))
self.assertEqual(
get_grades_for_students(self.student.id, self.starts_at,
self.ends_at).count(), 4)
def setUpTestData(cls):
cls.academic_calendar = AcademicYearCalendarFactory()
cls.corigente_event = SchoolEventFactory(event_type=SchoolEvent.EventTypes.CORIGENTE, academic_year_calendar=cls.academic_calendar,
starts_at=datetime.date(2020, 8, 20), ends_at=datetime.date(2020, 8, 27))
cls.diferente_event = SchoolEventFactory(event_type=SchoolEvent.EventTypes.DIFERENTE, academic_year_calendar=cls.academic_calendar,
starts_at=datetime.date(2020, 9, 1), ends_at=datetime.date(2020, 9, 8))
cls.school_unit = RegisteredSchoolUnitFactory()
cls.school_stats = SchoolUnitStatsFactory(school_unit=cls.school_unit)
cls.teacher = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school_unit)
cls.study_class = StudyClassFactory(school_unit=cls.school_unit, class_grade='IX', class_grade_arabic=9)
cls.subject = SubjectFactory()
ProgramSubjectThroughFactory(academic_program=cls.study_class.academic_program, class_grade='IX',
subject=cls.subject, weekly_hours_count=3)
cls.teacher_class_through = TeacherClassThroughFactory(
study_class=cls.study_class,
teacher=cls.teacher,
subject=cls.subject
)
cls.student = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, student_in_class=cls.study_class)
cls.catalog = StudentCatalogPerSubjectFactory(
subject=cls.subject,
teacher=cls.teacher,
student=cls.student,
study_class=cls.study_class,
is_enrolled=True
)
cls.catalog_per_year = StudentCatalogPerYearFactory(
student=cls.student,
study_class=cls.study_class
)
def setUpTestData(cls):
cls.academic_calendar = AcademicYearCalendarFactory()
cls.school_unit = RegisteredSchoolUnitFactory()
cls.school_stats = SchoolUnitStatsFactory(school_unit=cls.school_unit)
cls.teacher = UserProfileFactory(
user_role=UserProfile.UserRoles.TEACHER,
school_unit=cls.school_unit)
cls.study_class = StudyClassFactory(school_unit=cls.school_unit)
cls.subject = SubjectFactory()
cls.teacher_class_through = TeacherClassThroughFactory(
study_class=cls.study_class,
teacher=cls.teacher,
subject=cls.subject)
ProgramSubjectThroughFactory(
academic_program=cls.study_class.academic_program,
subject=cls.subject,
weekly_hours_count=1,
class_grade=cls.study_class.class_grade,
class_grade_arabic=cls.study_class.class_grade_arabic)
cls.student = UserProfileFactory(
user_role=UserProfile.UserRoles.STUDENT,
full_name='a',
student_in_class=cls.study_class)
cls.catalog = StudentCatalogPerSubjectFactory(
subject=cls.subject,
teacher=cls.teacher,
student=cls.student,
study_class=cls.study_class,
is_enrolled=True)
cls.catalog_per_year = StudentCatalogPerYearFactory(
student=cls.student, study_class=cls.study_class)
def setUpTestData(cls):
cls.school = RegisteredSchoolUnitFactory()
cls.teacher = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school)
cls.study_class = StudyClassFactory(school_unit=cls.school)
cls.subject = SubjectFactory()
cls.teacher_class_through = TeacherClassThroughFactory(study_class=cls.study_class, teacher=cls.teacher, subject=cls.subject)
cls.catalog = StudentCatalogPerSubjectFactory(study_class=cls.study_class, teacher=cls.teacher, subject=cls.subject, student__full_name='a')
cls.current_calendar = AcademicYearCalendarFactory()
def setUpTestData(cls):
AcademicYearCalendarFactory()
cls.school_unit = RegisteredSchoolUnitFactory()
cls.teacher = UserProfileFactory(
user_role=UserProfile.UserRoles.TEACHER,
school_unit=cls.school_unit)
cls.study_class = StudyClassFactory(school_unit=cls.school_unit,
class_grade='IX',
class_grade_arabic=9)
cls.subject = SubjectFactory()
ProgramSubjectThroughFactory(
academic_program=cls.study_class.academic_program,
subject=cls.subject,
weekly_hours_count=1)
cls.teacher_class_through = TeacherClassThroughFactory(
study_class=cls.study_class,
teacher=cls.teacher,
subject=cls.subject)
cls.student1 = UserProfileFactory(
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class)
cls.catalog1 = StudentCatalogPerSubjectFactory(
subject=cls.subject,
teacher=cls.teacher,
student=cls.student1,
study_class=cls.study_class,
avg_sem1=10,
avg_sem2=10,
avg_annual=10,
avg_final=10)
for semester in [1, 2]:
for i in range(2):
SubjectGradeFactory(student=cls.student1,
catalog_per_subject=cls.catalog1,
semester=semester)
cls.student2 = UserProfileFactory(
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=cls.study_class)
cls.catalog2 = StudentCatalogPerSubjectFactory(
subject=cls.subject,
teacher=cls.teacher,
student=cls.student2,
study_class=cls.study_class)
def setUpTestData(cls):
cls.school_unit = RegisteredSchoolUnitFactory()
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)
cls.student.parents.add(cls.parent)
cls.catalog = StudentCatalogPerSubjectFactory(student=cls.student)
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 test_create_absence_student_not_enrolled(self):
self.client.login(username=self.teacher.username, password='******')
catalog = StudentCatalogPerSubjectFactory(student=self.student,
study_class=self.study_class,
teacher=self.teacher,
is_enrolled=False)
response = self.client.post(self.build_url(catalog.id),
data=self.request_data)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def setUp(self):
self.catalog = StudentCatalogPerSubjectFactory(
study_class=self.study_class,
teacher=self.teacher,
subject=self.subject,
student=self.student,
is_enrolled=True)
self.study_class.refresh_from_db()
self.teacher_class_through.refresh_from_db()
self.data = {
'Nume': self.student.full_name,
'Etichete': 'good; v good',
'Note sem. I': '',
'Teză sem. I': '',
'Note sem. II': '4-4-2020: 10; 5-4-2020: 10',
'Teză sem. II': '4-4-2020: 7',
'Diferență sem. I Oral Prof. I': '22-12-2019: 6',
'Diferență sem. I Oral Prof. II': '22-12-2019: 7',
'Diferență sem. I Scris Prof. I': '22-12-2019: 8',
'Diferență sem. I Scris Prof. II': '22-12-2019: 9',
'Diferență sem. II Oral Prof. I': '',
'Diferență sem. II Oral Prof. II': '',
'Diferență sem. II Scris Prof. I': '',
'Diferență sem. II Scris Prof. II': '',
'Diferență anuală Oral Prof. I': '',
'Diferență anuală Oral Prof. II': '',
'Diferență anuală Scris Prof. I': '',
'Diferență anuală Scris Prof. II': '',
'Corigență Oral Prof. I': '5-5-2020: 6',
'Corigență Oral Prof. II': '5-5-2020: 7',
'Corigență Scris Prof. I': '5-5-2020: 8',
'Corigență Scris Prof. II': '5-5-2020: 9',
'Absențe motivate sem. I': '12-12-2019; 13-12-2019',
'Absențe motivate sem. II': '4-4-2020; 5-4-2020',
'Absențe nemotivate sem. I': '12-12-2019; 13-12-2019',
'Absențe nemotivate sem. II': '4-4-2020; 5-4-2020',
'Observații': 'foarte bun elev',
'Teste inițiale / finale': 'Da',
'Teză': 'Da',
'Simulări': 'Da',
'Scutit': 'Nu',
'Înregistrat opțional': 'Da'
}
def test_grade_update_secondary_school_averages(self, mocked_method):
# This is for a subject with weekly hours count = 1 and no thesis (1st semester)
self.client.login(username=self.teacher.username, password='******')
# Add a few more catalogs per subject for this student
StudentCatalogPerSubjectFactory(student=self.student,
study_class=self.study_class,
avg_sem1=9)
StudentCatalogPerSubjectFactory(student=self.student,
study_class=self.study_class,
avg_sem1=10)
SubjectGradeFactory(student=self.student,
catalog_per_subject=self.catalog,
semester=1,
grade=9)
grade = self.create_grade(semester=1)
self.catalog.avg_sem1 = 10
self.catalog.save()
self.data['taken_at'] = date(2019, 11, 10)
response = self.client.put(self.build_url(grade.id), self.data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.refresh_objects_from_db([
self.catalog, self.catalog_per_year, self.study_class,
self.school_stats
])
self.assertEqual(self.catalog.avg_sem1, 9)
self.assertIsNone(self.catalog.avg_sem2)
self.assertIsNone(self.catalog.avg_annual)
self.assertIsNone(self.catalog.avg_final)
self.assertIsNone(self.catalog_per_year.avg_final)
for obj in [
self.catalog_per_year, self.study_class, self.school_stats
]:
self.assertEqual(obj.avg_sem1, Decimal('9.33'))
self.assertIsNone(obj.avg_sem2)
self.assertIsNone(obj.avg_annual)
def setUpTestData(cls):
cls.school_unit = RegisteredSchoolUnitFactory(
academic_profile=SchoolUnitProfileFactory(name='Artistic'))
cls.study_class = StudyClassFactory(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.catalog = StudentCatalogPerSubjectFactory(
student=cls.student, study_class=cls.study_class)
cls.study_class.academic_program.core_subject = cls.catalog.subject
cls.study_class.academic_program.save()
cls.url = reverse('statistics:own-activity-history')
def test_examination_grade_create_differences_per_previous_year_success(
self, mocked_method):
self.client.login(username=self.teacher.username, password='******')
study_class = StudyClassFactory(school_unit=self.school_unit,
class_grade='IX',
class_grade_arabic=9,
academic_year=2019)
catalog = StudentCatalogPerSubjectFactory(subject=self.subject,
teacher=self.teacher,
student=self.student,
study_class=study_class)
catalog_per_year = StudentCatalogPerYearFactory(
student=self.student, study_class=study_class)
school_stats = SchoolUnitStatsFactory(school_unit=self.school_unit,
academic_year=2019)
self.data['grade_type'] = ExaminationGrade.GradeTypes.DIFFERENCE
self.data['taken_at'] = date(2020, 9, 7)
response = self.client.post(self.build_url(catalog.id), self.data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.data['examination_type'] = ExaminationGrade.ExaminationTypes.ORAL
response = self.client.post(self.build_url(catalog.id), self.data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(len(response.data['second_examination_grades']), 0)
self.assertEqual(len(response.data['difference_grades_sem1']), 0)
self.assertEqual(len(response.data['difference_grades_sem2']), 2)
self.refresh_objects_from_db([
catalog, catalog_per_year, study_class,
study_class.academic_program, school_stats, self.teacher,
self.teacher.school_unit
])
for catalog in [catalog, catalog_per_year]:
self.assertEqual(catalog.avg_annual, Decimal('9.5'))
self.assertEqual(catalog.avg_final, Decimal('9.5'))
for obj in [study_class, study_class.academic_program, school_stats]:
self.assertEqual(obj.avg_annual, Decimal('9.5'))
self.assertEqual(self.teacher.last_change_in_catalog, timezone.now())
self.assertEqual(self.teacher.school_unit.last_change_in_catalog,
timezone.now())
def test_own_study_class_catalog_per_subject_is_not_enrolled(self):
StudentCatalogPerSubjectFactory(
subject=self.subject,
teacher=self.teacher,
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, full_name='a'),
study_class=self.study_class,
academic_year=2020,
avg_sem1=1,
avg_sem2=1,
avg_final=1,
abs_count_sem1=1,
abs_count_sem2=1,
abs_count_annual=1,
is_enrolled=False
)
self.client.login(username=self.teacher.username, password='******')
response = self.client.get(self.build_url(self.study_class.id, self.subject.id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 0)
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)
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 = StudentCatalogPerSubjectFactory(
subject=cls.subject,
teacher=cls.teacher,
student=UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, full_name='a'),
study_class=cls.study_class,
academic_year=2020,
is_enrolled=True
)
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 setUp(self):
self.teacher_class_through1 = TeacherClassThroughFactory(study_class=self.study_class, teacher=self.teacher1,
subject=self.coordination_subject, is_class_master=True)
self.teacher_class_through2 = TeacherClassThroughFactory(study_class=self.study_class, teacher=self.teacher1, subject=self.subject1,
is_class_master=True)
self.teacher_class_through3 = TeacherClassThroughFactory(study_class=self.study_class, teacher=self.teacher2, subject=self.subject2,
is_class_master=False, is_optional_subject=True)
self.subject_catalog1 = StudentCatalogPerSubjectFactory(student=self.student1, teacher=self.teacher1,
study_class=self.study_class, subject=self.coordination_subject)
self.subject_catalog2 = StudentCatalogPerSubjectFactory(student=self.student1, teacher=self.teacher1,
study_class=self.study_class, subject=self.subject1)
self.subject_catalog3 = StudentCatalogPerSubjectFactory(student=self.student1, teacher=self.teacher2,
study_class=self.study_class, subject=self.subject2)
self.subject_catalog4 = StudentCatalogPerSubjectFactory(student=self.student2, teacher=self.teacher1,
study_class=self.study_class, subject=self.coordination_subject)
self.subject_catalog5 = StudentCatalogPerSubjectFactory(student=self.student2, teacher=self.teacher1,
study_class=self.study_class, subject=self.subject1)
self.subject_catalog6 = StudentCatalogPerSubjectFactory(student=self.student2, teacher=self.teacher2,
study_class=self.study_class, subject=self.subject2)
self.request_data = {
"class_master": self.teacher2.id,
"updated_teachers": [
{
"id": self.teacher_class_through2.id,
"teacher": self.teacher2.id,
},
{
"id": self.teacher_class_through3.id,
"teacher": self.teacher1.id,
}
],
"new_students": [
self.new_student.id
],
"deleted_students": [
self.student2.id
]
}
def test_own_child_activity_history_exam_grades(self):
self.client.login(username=self.parent.username, password='******')
yesterday = (timezone.now() -
timezone.timedelta(days=1)).replace(tzinfo=utc)
two_days_ago = (timezone.now() - timezone.timedelta(days=2)).date()
three_days_ago = (timezone.now() - timezone.timedelta(days=3)).date()
four_days_ago = (timezone.now() - timezone.timedelta(days=3)).date()
with patch('django.utils.timezone.now',
return_value=yesterday) as mocked_method:
# 2nd examinations
ExaminationGradeFactory(student=self.student,
catalog_per_subject=self.catalog,
taken_at=yesterday.date())
ExaminationGradeFactory(
student=self.student,
catalog_per_subject=self.catalog,
taken_at=yesterday.date(),
examination_type=ExaminationGrade.ExaminationTypes.ORAL)
# difference for 1st semester
ExaminationGradeFactory(
student=self.student,
catalog_per_subject=self.catalog,
taken_at=three_days_ago,
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE,
semester=1)
ExaminationGradeFactory(
student=self.student,
catalog_per_subject=self.catalog,
taken_at=three_days_ago,
examination_type=ExaminationGrade.ExaminationTypes.ORAL,
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE,
semester=1)
# difference for 2nd semester
ExaminationGradeFactory(
student=self.student,
catalog_per_subject=self.catalog,
taken_at=two_days_ago,
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE,
semester=2)
ExaminationGradeFactory(
student=self.student,
catalog_per_subject=self.catalog,
taken_at=two_days_ago,
examination_type=ExaminationGrade.ExaminationTypes.ORAL,
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE,
semester=2)
# difference for whole year for a previous year
study_class = StudyClassFactory(class_grade='V',
class_grade_arabic=5,
academic_year=2018)
catalog2 = StudentCatalogPerSubjectFactory(
student=self.student,
study_class=study_class,
is_coordination_subject=True)
ExaminationGradeFactory(
student=self.student,
catalog_per_subject=catalog2,
taken_at=four_days_ago,
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE,
grade1=9,
grade2=9)
ExaminationGradeFactory(
student=self.student,
catalog_per_subject=catalog2,
taken_at=four_days_ago,
examination_type=ExaminationGrade.ExaminationTypes.ORAL,
grade_type=ExaminationGrade.GradeTypes.DIFFERENCE)
self.catalog.avg_after_2nd_examination = 10
self.catalog.avg_annual = 10
self.catalog.avg_sem1 = 10
self.catalog.avg_sem2 = 10
self.catalog.save()
catalog2.avg_annual = 9.5
catalog2.save()
response = self.client.get(self.build_url(self.student.id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 4)
self.assertEqual(response.data[0]['date'],
yesterday.date().strftime('%d-%m-%Y'))
self.assertEqual(response.data[0]['subject_name'],
self.catalog.subject_name)
self.assertEqual(response.data[0]['event_type'],
'SECOND_EXAMINATION_AVERAGE')
self.assertEqual(response.data[0]['event'],
'Second examination average 10')
self.assertEqual(response.data[0]['grade_limit'], 5)
self.assertEqual(response.data[0]['grade_value'], 10)
self.assertEqual(response.data[1]['date'],
two_days_ago.strftime('%d-%m-%Y'))
self.assertEqual(response.data[1]['subject_name'],
self.catalog.subject_name)
self.assertEqual(response.data[1]['event_type'], 'DIFFERENCE_AVERAGE')
self.assertEqual(response.data[1]['event'],
'Difference average 10 for class VI, semester 2')
self.assertEqual(response.data[1]['grade_limit'], 5)
self.assertEqual(response.data[1]['grade_value'], 10)
self.assertEqual(response.data[2]['date'],
three_days_ago.strftime('%d-%m-%Y'))
self.assertEqual(response.data[2]['subject_name'],
self.catalog.subject_name)
self.assertEqual(response.data[2]['event_type'], 'DIFFERENCE_AVERAGE')
self.assertEqual(response.data[2]['event'],
'Difference average 10 for class VI, semester 1')
self.assertEqual(response.data[2]['grade_limit'], 5)
self.assertEqual(response.data[2]['grade_value'], 10)
self.assertEqual(response.data[3]['date'],
three_days_ago.strftime('%d-%m-%Y'))
self.assertEqual(response.data[3]['subject_name'],
catalog2.subject_name)
self.assertEqual(response.data[3]['event_type'], 'DIFFERENCE_AVERAGE')
self.assertEqual(response.data[3]['event'],
'Difference average 9.5 for class V')
self.assertEqual(response.data[3]['grade_limit'], 6)
self.assertEqual(response.data[3]['grade_value'], 9.5)
def test_own_absences_evolution_success(self, mocked_method):
self.client.login(username=self.student.username, password='******')
catalog1 = StudentCatalogPerSubjectFactory(student=self.student)
for day in [5, 10]:
absence = SubjectAbsenceFactory(student=self.student,
catalog_per_subject=catalog1,
is_founded=True,
taken_at=datetime.date(
2020, 6, day))
absence.created = datetime.datetime(2020, 6,
day).replace(tzinfo=utc)
absence.save()
catalog2 = StudentCatalogPerSubjectFactory(student=self.student)
for day in [5, 11]:
absence = SubjectAbsenceFactory(student=self.student,
catalog_per_subject=catalog2,
is_founded=False,
taken_at=datetime.date(
2020, 6, day))
absence.created = datetime.datetime(2020, 6,
day).replace(tzinfo=utc)
absence.save()
SubjectAbsenceFactory(student=self.student,
catalog_per_subject=catalog2,
is_founded=True,
taken_at=datetime.date(2020, 6, 16))
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 30)
self.assertEqual(response.data[4]['day'], 5)
self.assertEqual(response.data[4]['weekday'], 'Vi')
self.assertEqual(response.data[4]['total_count'], 2)
self.assertEqual(response.data[9]['day'], 10)
self.assertEqual(response.data[9]['weekday'], 'Mi')
self.assertEqual(response.data[9]['total_count'], 1)
self.assertEqual(response.data[10]['day'], 11)
self.assertEqual(response.data[10]['weekday'], 'Jo')
self.assertEqual(response.data[10]['total_count'], 1)
response = self.client.get(self.url, {'by_category': 'true'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 30)
self.assertEqual(response.data[4]['day'], 5)
self.assertEqual(response.data[4]['weekday'], 'Vi')
self.assertEqual(response.data[4]['founded_count'], 1)
self.assertEqual(response.data[4]['unfounded_count'], 1)
self.assertEqual(response.data[9]['day'], 10)
self.assertEqual(response.data[9]['weekday'], 'Mi')
self.assertEqual(response.data[9]['founded_count'], 1)
self.assertEqual(response.data[9]['unfounded_count'], 0)
self.assertEqual(response.data[10]['day'], 11)
self.assertEqual(response.data[10]['weekday'], 'Jo')
self.assertEqual(response.data[10]['founded_count'], 0)
self.assertEqual(response.data[10]['unfounded_count'], 1)
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)