def setUpTestData(cls): cls.principal = UserProfileFactory(user_role=UserProfile.UserRoles.PRINCIPAL) cls.school_unit = RegisteredSchoolUnitFactory(school_principal=cls.principal) cls.calendar = AcademicYearCalendarFactory() cls.subject1 = SubjectFactory() cls.subject2 = SubjectFactory() cls.coordination_subject = SubjectFactory(is_coordination=True) cls.academic_program = AcademicProgramFactory(school_unit=cls.school_unit) ProgramSubjectThroughFactory(generic_academic_program=cls.academic_program.generic_academic_program, subject=cls.subject1, class_grade='X', class_grade_arabic=10) ProgramSubjectThroughFactory(academic_program=cls.academic_program, subject=cls.subject2, is_mandatory=False, class_grade='X', class_grade_arabic=10) cls.teacher1 = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school_unit) cls.teacher2 = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school_unit) cls.teacher1.taught_subjects.add(cls.subject1) cls.teacher2.taught_subjects.add(cls.subject1) cls.study_class = StudyClassFactory(school_unit=cls.school_unit, class_master=cls.teacher1, academic_program=cls.academic_program, class_grade='X', class_grade_arabic=10, class_letter='A') cls.student1 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school_unit, student_in_class=cls.study_class) 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) StudentCatalogPerYearFactory(student=cls.student2, study_class=cls.study_class) cls.new_student = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school_unit)
def test_academic_program_subject_list_success(self): self.client.login(username=self.principal.username, password='******') # Create a subject through with another class grade subject = SubjectFactory(name='Wrong class grade') ProgramSubjectThroughFactory( generic_academic_program=self.generic_academic_program, subject=subject, class_grade='X', class_grade_arabic=10) response = self.get_response() self.assertEqual(len(response.data), 2) self.assertCountEqual( [subject['subject_id'] for subject in response.data], [self.optional_subject.id, self.mandatory_subject.id]) self.assertCountEqual( [subject['is_mandatory'] for subject in response.data], [False, True]) # Create a mandatory subject from another generic academic program generic_academic_program = GenericAcademicProgramFactory() subject = SubjectFactory(name='Other generic academic program') ProgramSubjectThroughFactory( generic_academic_program=generic_academic_program, subject=subject, class_grade='IX', class_grade_arabic=9) response = self.get_response() self.assertEqual(len(response.data), 2) # Create another optional subject subject = SubjectFactory(name='Other optional') ProgramSubjectThroughFactory(academic_program=self.academic_program, subject=subject, class_grade='IX', class_grade_arabic=9, is_mandatory=False) response = self.get_response() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.data), 3) # Create another mandatory subject subject = SubjectFactory(name='Other mandatory') ProgramSubjectThroughFactory( generic_academic_program=self.generic_academic_program, subject=subject, class_grade='IX', class_grade_arabic=9) response = self.get_response() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.data), 4)
def setUpTestData(cls): cls.principal = UserProfileFactory(user_role=UserProfile.UserRoles.PRINCIPAL) cls.school_unit = RegisteredSchoolUnitFactory(school_principal=cls.principal) cls.category1 = SchoolUnitCategoryFactory(category_level=SchoolUnitCategory.CategoryLevels.SECONDARY_SCHOOL) cls.category2 = SchoolUnitCategoryFactory(category_level=SchoolUnitCategory.CategoryLevels.HIGHSCHOOL) cls.school_unit.categories.add(cls.category1, cls.category2) cls.calendar = AcademicYearCalendarFactory() cls.subject1 = SubjectFactory() cls.subject2 = SubjectFactory() cls.coordination_subject = SubjectFactory(is_coordination=True) cls.academic_program = AcademicProgramFactory(school_unit=cls.school_unit) for class_grade, class_grade_arabic in zip(['VI', 'X'], [6, 10]): ProgramSubjectThroughFactory(academic_program=cls.academic_program, subject=cls.subject1, is_mandatory=False, class_grade=class_grade, class_grade_arabic=class_grade_arabic) ProgramSubjectThroughFactory(generic_academic_program=cls.academic_program.generic_academic_program, subject=cls.subject2, class_grade=class_grade, class_grade_arabic=class_grade_arabic) cls.teacher1 = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school_unit) cls.teacher2 = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school_unit) cls.teacher1.taught_subjects.add(cls.subject1, cls.subject2) cls.teacher2.taught_subjects.add(cls.subject1, cls.subject2) cls.study_class1 = StudyClassFactory(school_unit=cls.school_unit, class_master=cls.teacher1, academic_program=cls.academic_program, class_grade='X', class_grade_arabic=10, class_letter='A') TeacherClassThroughFactory(study_class=cls.study_class1, teacher=cls.teacher1, subject=cls.coordination_subject, is_class_master=True) cls.study_class2 = StudyClassFactory(school_unit=cls.school_unit, class_master=cls.teacher2, academic_program=cls.academic_program) TeacherClassThroughFactory(study_class=cls.study_class2, teacher=cls.teacher2, subject=cls.coordination_subject, is_class_master=True) TeacherClassThroughFactory(study_class=cls.study_class1, teacher=cls.teacher1, subject=cls.subject1, is_class_master=True) TeacherClassThroughFactory(study_class=cls.study_class1, teacher=cls.teacher2, subject=cls.subject2, is_class_master=False) TeacherClassThroughFactory(study_class=cls.study_class2, teacher=cls.teacher1, subject=cls.subject1, is_class_master=False) TeacherClassThroughFactory(study_class=cls.study_class2, teacher=cls.teacher2, subject=cls.subject2, is_class_master=True) cls.student1 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school_unit, student_in_class=cls.study_class1) StudentCatalogPerYearFactory(student=cls.student1, study_class=cls.study_class1) cls.student2 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school_unit, student_in_class=cls.study_class1) StudentCatalogPerYearFactory(student=cls.student2, study_class=cls.study_class1) cls.student3 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school_unit, student_in_class=cls.study_class2) StudentCatalogPerYearFactory(student=cls.student3, study_class=cls.study_class2) cls.academic_program2 = AcademicProgramFactory(school_unit=cls.school_unit) for class_grade, class_grade_arabic in zip(['VII', 'XI'], [7, 11]): ProgramSubjectThroughFactory(academic_program=cls.academic_program2, subject=cls.subject1, is_mandatory=False, class_grade=class_grade, class_grade_arabic=class_grade_arabic) ProgramSubjectThroughFactory(generic_academic_program=cls.academic_program2.generic_academic_program, subject=cls.subject2, class_grade=class_grade, class_grade_arabic=class_grade_arabic) cls.new_teacher = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school_unit) cls.new_student = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school_unit)
def test_generate_next_year_academic_programs(self): current_calendar = AcademicYearCalendarFactory() program1 = AcademicProgramFactory( academic_year=current_calendar.academic_year - 1) ProgramSubjectThroughFactory(academic_program=program1, subject=SubjectFactory()) program2 = AcademicProgramFactory( academic_year=current_calendar.academic_year - 1) ProgramSubjectThroughFactory(academic_program=program2, subject=SubjectFactory()) generate_next_year_academic_programs() self.assertEqual( AcademicProgram.objects.filter( academic_year=current_calendar.academic_year).count(), 2) cloned_program1 = AcademicProgram.objects.filter( name=program1.name, academic_year=current_calendar.academic_year).first() self.assertIsNotNone(cloned_program1) cloned_program2 = AcademicProgram.objects.filter( name=program2.name, academic_year=current_calendar.academic_year).first() self.assertIsNotNone(cloned_program2) for field in [ 'avg_sem1', 'avg_sem2', 'avg_annual', 'unfounded_abs_avg_sem1', 'unfounded_abs_avg_sem2', 'unfounded_abs_avg_annual' ]: self.assertIsNone(getattr(cloned_program1, field)) self.assertIsNone(getattr(cloned_program2, field)) for field in ['classes_count', 'students_at_risk_count']: self.assertEqual(getattr(cloned_program1, field), 0) self.assertEqual(getattr(cloned_program2, field), 0) self.assertEqual(ProgramSubjectThrough.objects.count(), 4) self.assertEqual( ProgramSubjectThrough.objects.filter( academic_program__academic_year=current_calendar.academic_year ).count(), 2) self.assertTrue( ProgramSubjectThrough.objects.filter( academic_program=cloned_program1).exists()) self.assertTrue( ProgramSubjectThrough.objects.filter( academic_program=cloned_program2).exists())
def setUpTestData(cls): cls.principal = UserProfileFactory( user_role=UserProfile.UserRoles.PRINCIPAL) cls.school_unit = RegisteredSchoolUnitFactory( school_principal=cls.principal) cls.generic_academic_program = GenericAcademicProgramFactory( optional_subjects_weekly_hours={ "IX": 10, "X": 1 }, academic_profile=cls.school_unit.academic_profile, ) cls.school_unit.categories.add(cls.generic_academic_program.category) cls.academic_year = 2020 cls.academic_year_calendar = AcademicYearCalendarFactory( academic_year=cls.academic_year) cls.academic_program = AcademicProgramFactory( school_unit=cls.school_unit, generic_academic_program=cls.generic_academic_program, academic_year=cls.academic_year) cls.subject = SubjectFactory(name='Subject') cls.subject_through = ProgramSubjectThroughFactory( academic_program=cls.academic_program, subject=cls.subject, class_grade='IX', class_grade_arabic=9)
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.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 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.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_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 setUpTestData(cls): cls.principal = UserProfileFactory( user_role=UserProfile.UserRoles.PRINCIPAL) cls.school_unit = RegisteredSchoolUnitFactory( school_principal=cls.principal) cls.generic_academic_program = GenericAcademicProgramFactory() cls.academic_program = AcademicProgramFactory( school_unit=cls.school_unit, generic_academic_program=cls.generic_academic_program) cls.mandatory_subject = SubjectFactory(name='Mandatory') cls.optional_subject = SubjectFactory(name='Optional') cls.mandatory_through = ProgramSubjectThroughFactory( generic_academic_program=cls.generic_academic_program, subject=cls.mandatory_subject, class_grade='IX', class_grade_arabic=9) cls.optional_through = ProgramSubjectThroughFactory( academic_program=cls.academic_program, subject=cls.optional_subject, class_grade='IX', class_grade_arabic=9, is_mandatory=False)
def test_generic_academic_program_detail(self): self.client.login(username=self.principal.username, password='******') subject1 = SubjectFactory(name='Subject B') subject2 = SubjectFactory(name='Subject C') subject3 = SubjectFactory(name='Subject A') subject_through1 = ProgramSubjectThroughFactory( generic_academic_program=self.program, subject=subject1) subject_through2 = ProgramSubjectThroughFactory( generic_academic_program=self.program, subject=subject2, class_grade='X', class_grade_arabic=10) subject_through3 = ProgramSubjectThroughFactory( generic_academic_program=self.program, subject=subject3) response = self.client.get(self.build_url(self.program.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertCountEqual( response.data.keys(), ['id', 'subjects', 'optional_subjects_weekly_hours']) subjects_response = response.data['subjects'] self.assertEqual(len(subjects_response.keys()), 2) self.assertTrue( all([ 'IX' in subjects_response.keys(), 'X' in subjects_response.keys() ])) self.assertEqual([ subject_through['id'] for subject_through in subjects_response['IX'] ], [subject_through3.id, subject_through1.id]) self.assertEqual([ subject_through['id'] for subject_through in subjects_response['X'] ], [ subject_through2.id, ])
def test_academic_program_detail(self): self.client.login(username=self.principal.username, password='******') subject1 = SubjectFactory(name='Subject A') subject2 = SubjectFactory(name='Subject C') subject3 = SubjectFactory(name='Subject B') subject_through1 = ProgramSubjectThroughFactory( academic_program=self.academic_program, subject=subject1, is_mandatory=False, class_grade='IX', class_grade_arabic=9) subject_through2 = ProgramSubjectThroughFactory( academic_program=self.academic_program, subject=subject2, class_grade='X', class_grade_arabic=10, is_mandatory=False) subject_through3 = ProgramSubjectThroughFactory( generic_academic_program=self.generic_academic_program, subject=subject3, is_mandatory=True, class_grade='IX', class_grade_arabic=9) response = self.client.get(self.build_url(self.academic_program.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data['optional_subjects_weekly_hours'], self.optional_subjects_weekly_hours) subjects = response.data['subjects'] self.assertCountEqual(subjects.keys(), ['IX', 'X']) self.assertEqual(subjects['IX']['optional_subjects'][0]['id'], subject_through1.id) self.assertEqual(subjects['X']['optional_subjects'][0]['id'], subject_through2.id) self.assertEqual(subjects['IX']['mandatory_subjects'][0]['id'], subject_through3.id)
def setUpTestData(cls): cls.calendar = AcademicYearCalendarFactory() 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_grade='IX', class_grade_arabic=9) 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, class_grade='IX', subject=cls.subject, weekly_hours_count=3)
def test_academic_program_detail_expected_fields(self): self.client.login(username=self.principal.username, password='******') expected_fields = [ 'id', 'name', 'classes_count', 'academic_year', 'core_subject', 'optional_subjects_weekly_hours', 'subjects' ] subjects_expected_fields = ['mandatory_subjects', 'optional_subjects'] subject_expected_fields = [ 'subject_id', 'subject_name', 'id', 'weekly_hours_count' ] subject1 = SubjectFactory(name='Subject A') ProgramSubjectThroughFactory(class_grade='X', academic_program=self.academic_program, subject=subject1, is_mandatory=False, class_grade_arabic=10) subject2 = SubjectFactory(name='Subject B') ProgramSubjectThroughFactory(academic_program=self.academic_program, subject=subject2, class_grade='X', is_mandatory=True, class_grade_arabic=10) response = self.client.get(self.build_url(self.academic_program.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertCountEqual(response.data.keys(), expected_fields) self.assertEqual(len(response.data['subjects']), 1) self.assertCountEqual(response.data['subjects']['X'].keys(), subjects_expected_fields) for subject in response.data['subjects']['X']['optional_subjects']: self.assertCountEqual(subject.keys(), subject_expected_fields) for subject in response.data['subjects']['X']['mandatory_subjects']: self.assertCountEqual(subject.keys(), subject_expected_fields)
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 = RegisteredSchoolUnitFactory() cls.teacher = UserProfileFactory( user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school) cls.study_class = StudyClassFactory(school_unit=cls.school, class_grade='IX', class_grade_arabic=9, class_letter='A') cls.student = UserProfileFactory( user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school, student_in_class=cls.study_class) cls.subject = SubjectFactory() cls.teacher_class_through = TeacherClassThroughFactory( study_class=cls.study_class, teacher=cls.teacher, subject=cls.subject) cls.current_calendar = AcademicYearCalendarFactory() cls.label = LabelFactory(user_role=UserProfile.UserRoles.STUDENT, text='good') cls.label2 = LabelFactory(user_role=UserProfile.UserRoles.STUDENT, text='v good') cls.subject_through = ProgramSubjectThroughFactory( subject=cls.subject, class_grade='IX', class_grade_arabic=9, is_mandatory=True, generic_academic_program=cls.study_class.academic_program. generic_academic_program, weekly_hours_count=1, ) cls.differences_event = SchoolEventFactory( event_type=SchoolEvent.EventTypes.DIFERENTE, semester=cls.current_calendar.first_semester, academic_year_calendar=cls.current_calendar, starts_at=datetime.date(2019, 12, 21), ends_at=datetime.date(2019, 12, 23)) cls.second_examination_event = SchoolEventFactory( event_type=SchoolEvent.EventTypes.CORIGENTE, academic_year_calendar=cls.current_calendar, starts_at=datetime.date(2020, 5, 4), ends_at=datetime.date(2020, 5, 7)) cls.catalog_per_year = StudentCatalogPerYearFactory( study_class=cls.study_class, student=cls.student) cls.file_name = 'file.csv'
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_grade_update_highschool_school_averages(self, mocked_method): # This is for an optional subject with weekly hours count = 3 and with thesis (2nd semester) self.client.login(username=self.teacher.username, password='******') self.study_class.class_grade = 'IX' self.study_class.class_grade_arabic = 9 self.study_class.save() ProgramSubjectThroughFactory( academic_program=self.study_class.academic_program, subject=self.subject, weekly_hours_count=3) for i in range(3): SubjectGradeFactory(student=self.student, catalog_per_subject=self.catalog, semester=2, grade=9) grade = SubjectGradeFactory(student=self.student, catalog_per_subject=self.catalog, semester=2, grade=6, grade_type=SubjectGrade.GradeTypes.THESIS) self.catalog.avg_sem1 = 9 self.catalog.avg_sem2 = 8 self.catalog.avg_annual = 8.5 self.catalog.avg_final = 8.5 self.catalog.wants_thesis = True self.catalog.save() 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.study_class.academic_program, self.school_stats ]) for obj in [ self.catalog, self.catalog_per_year, self.study_class, self.study_class.academic_program, self.school_stats ]: self.assertEqual(obj.avg_sem1, 9) self.assertEqual(obj.avg_sem2, 9) self.assertEqual(obj.avg_annual, 9) self.assertEqual(self.catalog.avg_final, 9) self.assertEqual(self.catalog_per_year.avg_final, 9)
def test_grade_create_highschool_averages(self, mocked_method): # This is for a required subject with weekly hours count = 3 and with thesis (2nd semester) self.study_class.class_grade = 'IX' self.study_class.class_grade_arabic = 9 self.study_class.save() ProgramSubjectThroughFactory(generic_academic_program=self.study_class. academic_program.generic_academic_program, subject=self.subject, weekly_hours_count=3) self.catalog.avg_sem1 = 10 self.catalog.wants_thesis = True self.catalog.save() for i in range(3): SubjectGradeFactory(student=self.student, catalog_per_subject=self.catalog, semester=2, grade=9) self.client.login(username=self.teacher.username, password='******') self.data['taken_at'] = date(2020, 4, 5) self.data['grade_type'] = SubjectGrade.GradeTypes.THESIS 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.study_class.academic_program, self.school_stats ]) for catalog in [self.catalog, self.catalog_per_year]: self.assertEqual(catalog.avg_sem1, 10) self.assertEqual(catalog.avg_sem2, 9) self.assertEqual(catalog.avg_annual, 9.5) self.assertEqual(catalog.avg_final, 9.5) for obj in [ self.study_class, self.study_class.academic_program, self.school_stats ]: self.assertEqual(obj.avg_sem1, 10) self.assertEqual(obj.avg_sem2, 9) self.assertEqual(obj.avg_annual, 9.5)
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_difference_subject_list_success(self, today): self.client.login(username=self.principal.username, password='******') semester = 1 if today == timezone.datetime(2019, 12, 1) else 2 subject1 = SubjectFactory() ProgramSubjectThroughFactory( generic_academic_program=self.generic_academic_program, subject=subject1, class_grade_arabic=9, class_grade='IX') subject2 = SubjectFactory() ProgramSubjectThroughFactory( generic_academic_program=self.generic_academic_program, subject=subject2, class_grade_arabic=9, class_grade='IX') StudentCatalogPerSubjectFactory(student=self.student, study_class=StudyClassFactory( class_grade='IX', class_grade_arabic=9), subject=subject2) ProgramSubjectThroughFactory( generic_academic_program=self.generic_academic_program, subject=subject2, class_grade_arabic=10, class_grade='X') subject4 = SubjectFactory() ProgramSubjectThroughFactory( generic_academic_program=self.generic_academic_program, subject=subject4, class_grade_arabic=10, class_grade='X') subject5 = SubjectFactory() ProgramSubjectThroughFactory( subject=subject5, generic_academic_program=self.generic_academic_program, class_grade_arabic=11, class_grade='XI') subject6 = SubjectFactory() ProgramSubjectThroughFactory( subject=subject6, generic_academic_program=self.generic_academic_program, class_grade_arabic=12, class_grade='XII') with patch('django.utils.timezone.now', return_value=today.replace(tzinfo=utc)) as mocked_method: response = self.client.get( self.build_url(self.student.id, self.study_class.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) if semester == 1: expected_grades = ['IX', 'X'] self.assertCountEqual( [subject['id'] for subject in response.data['IX']], [subject1.id]) self.assertCountEqual( [subject['id'] for subject in response.data['X']], [subject2.id, subject4.id]) else: expected_grades = ['IX', 'X', 'XI'] self.assertCountEqual( [subject['id'] for subject in response.data['IX']], [subject1.id]) self.assertCountEqual( [subject['id'] for subject in response.data['X']], [subject2.id, subject4.id]) self.assertCountEqual( [subject['id'] for subject in response.data['XI']], [subject5.id]) self.assertCountEqual(response.data.keys(), expected_grades) subject_expected_fields = ['id', 'name'] for subject_list in response.data.values(): for subject in subject_list: self.assertCountEqual(subject.keys(), subject_expected_fields) StudentCatalogPerSubjectFactory(student=self.student, study_class=StudyClassFactory( class_grade='X', class_grade_arabic=10), subject=subject4) with patch('django.utils.timezone.now', return_value=today.replace(tzinfo=utc)) as mocked_method: response = self.client.get( self.build_url(self.student.id, self.study_class.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) if semester == 1: expected_grades = ['IX', 'X'] else: expected_grades = ['IX', 'X', 'XI'] self.assertCountEqual( [subject['id'] for subject in response.data['X']], [subject2.id]) self.assertCountEqual(response.data.keys(), expected_grades)
def test_bulk_create_grade_highschool_averages(self, timezone_mock): # This is for a required subject with weekly hours count = 3 and with thesis (2nd semester) self.study_class.class_grade = 'IX' self.study_class.class_grade_arabic = 9 self.study_class.save() ProgramSubjectThroughFactory(generic_academic_program=self.study_class. academic_program.generic_academic_program, subject=self.subject, weekly_hours_count=3) for catalog in [self.catalog1, self.catalog2]: catalog.avg_sem1 = 10 catalog.wants_thesis = True catalog.save() SubjectGradeFactory(student=self.student1, catalog_per_subject=self.catalog1, semester=2, grade=10, grade_type=SubjectGrade.GradeTypes.THESIS) SubjectGradeFactory(student=self.student2, catalog_per_subject=self.catalog2, semester=2, grade=10, grade_type=SubjectGrade.GradeTypes.THESIS) self.client.login(username=self.teacher.username, password='******') self.request_data = { "taken_at": date(2020, 4, 5), "student_grades": [{ "student": self.student1.id, "grade": 10 }, { "student": self.student1.id, "grade": 9 }, { "student": self.student1.id, "grade": 9 }, { "student": self.student2.id, "grade": 10 }] } 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_201_CREATED) self.refresh_objects_from_db([ self.catalog1, self.catalog2, self.catalog_per_year1, self.catalog_per_year2, self.study_class, self.study_class.academic_program, self.school_stats ]) for catalog in [self.catalog1, self.catalog_per_year1]: self.assertEqual(catalog.avg_sem1, 10) # This is a 9.49 situation self.assertEqual(catalog.avg_sem2, 9) self.assertEqual(catalog.avg_annual, 9.5) self.assertEqual(catalog.avg_final, 9.5) for catalog in [self.catalog2, self.catalog_per_year2]: self.assertEqual(catalog.avg_sem1, 10) self.assertIsNone(catalog.avg_sem2) self.assertIsNone(catalog.avg_annual) self.assertIsNone(catalog.avg_final) for obj in [ self.study_class, self.study_class.academic_program, self.school_stats ]: self.assertEqual(obj.avg_sem1, Decimal('10')) self.assertEqual(obj.avg_sem2, Decimal('9')) self.assertEqual(obj.avg_annual, Decimal('9.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 test_own_child_subjects_at_risk_success(self): self.client.login(username=self.parent.username, password='******') subject1 = SubjectFactory(name='B') catalog1 = StudentCatalogPerSubjectFactory( student=self.student, subject=subject1, study_class=self.study_class, is_at_risk=True, unfounded_abs_count_sem1=2, unfounded_abs_count_annual=2) ProgramSubjectThroughFactory( academic_program=self.study_class.academic_program, class_grade=self.study_class.class_grade, subject=subject1, weekly_hours_count=5) subject2 = SubjectFactory(name='A', is_coordination=True) catalog2 = StudentCatalogPerSubjectFactory( student=self.student, subject=subject2, is_coordination_subject=True, study_class=self.study_class, is_at_risk=True, unfounded_abs_count_sem1=1, unfounded_abs_count_annual=1) ProgramSubjectThroughFactory( academic_program=self.study_class.academic_program, class_grade=self.study_class.class_grade, subject=subject2, weekly_hours_count=1) StudentCatalogPerSubjectFactory(student=self.student, study_class=self.study_class, is_at_risk=False) expected_fields = [ 'id', 'subject_name', 'avg_sem1', 'avg_final', 'avg_limit', 'unfounded_abs_count_sem1', 'unfounded_abs_count_annual', 'third_of_hours_count_sem1', 'third_of_hours_count_annual' ] response = self.client.get(self.build_url(self.student.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data['count'], 2) for catalog in response.data['results']: self.assertCountEqual(catalog.keys(), expected_fields) self.assertEqual(response.data['results'][0]['id'], catalog1.id) self.assertEqual(response.data['results'][0]['avg_limit'], 5) self.assertEqual( response.data['results'][0]['third_of_hours_count_sem1'], 25) self.assertEqual( response.data['results'][0]['third_of_hours_count_annual'], 50) self.assertEqual(response.data['results'][1]['id'], catalog2.id) self.assertEqual(response.data['results'][1]['avg_limit'], 6) self.assertEqual( response.data['results'][1]['third_of_hours_count_sem1'], 5) self.assertEqual( response.data['results'][1]['third_of_hours_count_annual'], 10)
def test_grade_create_second_examinations_count(self, timezone_mock): for avg in [4, 5, 6, 10]: StudentCatalogPerSubjectFactory(student=self.student, study_class=self.study_class, avg_sem1=avg, avg_sem2=avg) self.school_unit.academic_profile = SchoolUnitProfileFactory( name='Artistic') self.school_unit.save() self.study_class.class_grade = 'IX' self.study_class.class_grade_arabic = 9 self.study_class.save() ProgramSubjectThroughFactory(generic_academic_program=self.study_class. academic_program.generic_academic_program, subject=self.subject, weekly_hours_count=1) self.study_class.academic_program.core_subject = self.subject self.study_class.academic_program.save() self.catalog.avg_sem1 = 5 self.catalog.save() self.client.login(username=self.teacher.username, password='******') self.data['taken_at'] = date(2020, 4, 5) response = self.client.post(self.build_url(self.catalog.id), self.data) self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.catalog_per_year.refresh_from_db() self.assertEqual(self.catalog_per_year.second_examinations_count, 3) # Check labels catalog = StudentCatalogPerSubject.objects.get( student=self.student, study_class=self.study_class, avg_sem1=4, avg_sem2=4) catalog.avg_sem1 = 5 catalog.save() response = self.client.post(self.build_url(self.catalog.id), self.data) self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.catalog_per_year.refresh_from_db() self.assertEqual(self.catalog_per_year.second_examinations_count, 2) self.assertCountEqual( self.student.labels.all(), Label.objects.filter(text=FAILING_2_SUBJECTS_LABEL)) catalog.avg_sem2 = 5 catalog.save() response = self.client.post(self.build_url(self.catalog.id), self.data) self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.catalog_per_year.refresh_from_db() self.assertEqual(self.catalog_per_year.second_examinations_count, 1) self.assertCountEqual( self.student.labels.all(), Label.objects.filter(text=FAILING_1_SUBJECT_LABEL)) self.catalog.avg_sem1 = 6 self.catalog.save() response = self.client.post(self.build_url(self.catalog.id), self.data) self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.catalog_per_year.refresh_from_db() self.assertEqual(self.catalog_per_year.second_examinations_count, 0) self.assertEqual(self.student.labels.count(), 0)
def test_own_study_class_pupil_detail_success(self): self.client.login(username=self.teacher.username, password='******') parent = UserProfileFactory(user_role=UserProfile.UserRoles.PARENT, school_unit=self.school_unit) self.student.parents.add(parent) label = LabelFactory(user_role=UserProfile.UserRoles.STUDENT) self.student.labels.add(label) coordination_subject = SubjectFactory(name='Dirigentie', is_coordination=True) subject1 = SubjectFactory(name='Subject') subject2 = SubjectFactory(name='Another Subject') subject3 = SubjectFactory(name='Optional Subject') teacher2 = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=self.school_unit) TeacherClassThroughFactory(study_class=self.study_class, teacher=self.teacher, subject=coordination_subject, is_class_master=True) TeacherClassThroughFactory(study_class=self.study_class, teacher=self.teacher, subject=subject1, is_class_master=True) TeacherClassThroughFactory(study_class=self.study_class, teacher=teacher2, subject=subject2) TeacherClassThroughFactory(study_class=self.study_class, teacher=teacher2, subject=subject3) catalog1 = StudentCatalogPerSubjectFactory( student=self.student, teacher=self.teacher, study_class=self.study_class, subject=coordination_subject) catalog2 = StudentCatalogPerSubjectFactory( student=self.student, teacher=self.teacher, study_class=self.study_class, subject=subject1) catalog3 = StudentCatalogPerSubjectFactory( student=self.student, teacher=teacher2, study_class=self.study_class, subject=subject2) StudentCatalogPerSubjectFactory(student=self.student, teacher=teacher2, study_class=self.study_class, subject=subject3, is_enrolled=False) for subject in [subject1, subject2]: ProgramSubjectThroughFactory( academic_program=self.study_class.academic_program, class_grade=self.study_class.class_grade, subject=subject, weekly_hours_count=1) yesterday = timezone.now().date() - timezone.timedelta(days=1) grade1 = SubjectGradeFactory(student=self.student, catalog_per_subject=catalog2) grade2 = SubjectGradeFactory(student=self.student, catalog_per_subject=catalog2, taken_at=yesterday) grade3 = SubjectGradeFactory(student=self.student, catalog_per_subject=catalog2, semester=2, taken_at=yesterday) grade4 = SubjectGradeFactory(student=self.student, catalog_per_subject=catalog2, semester=2) exam_grade1 = ExaminationGradeFactory(student=self.student, catalog_per_subject=catalog2) exam_grade2 = ExaminationGradeFactory( student=self.student, catalog_per_subject=catalog2, examination_type=ExaminationGrade.ExaminationTypes.ORAL) exam_grade3 = ExaminationGradeFactory( student=self.student, catalog_per_subject=catalog2, taken_at=yesterday, grade_type=ExaminationGrade.GradeTypes.DIFFERENCE, semester=1) exam_grade4 = ExaminationGradeFactory( student=self.student, catalog_per_subject=catalog2, examination_type=ExaminationGrade.ExaminationTypes.ORAL, grade_type=ExaminationGrade.GradeTypes.DIFFERENCE, semester=1) exam_grade5 = ExaminationGradeFactory( student=self.student, catalog_per_subject=catalog2, semester=2, grade_type=ExaminationGrade.GradeTypes.DIFFERENCE) exam_grade6 = ExaminationGradeFactory( student=self.student, catalog_per_subject=catalog2, taken_at=yesterday, semester=2, examination_type=ExaminationGrade.ExaminationTypes.ORAL, grade_type=ExaminationGrade.GradeTypes.DIFFERENCE) abs1 = SubjectAbsenceFactory(student=self.student, catalog_per_subject=catalog2) abs2 = SubjectAbsenceFactory(student=self.student, catalog_per_subject=catalog2, taken_at=yesterday) abs3 = SubjectAbsenceFactory(student=self.student, catalog_per_subject=catalog2, semester=2, taken_at=yesterday) abs4 = SubjectAbsenceFactory(student=self.student, catalog_per_subject=catalog2, semester=2) response = self.client.get( self.build_url(self.study_class.id, self.student.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) expected_fields = [ 'id', 'full_name', 'parents', 'labels', 'risk_description', 'study_class', 'catalogs_per_subjects' ] catalog_expected_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' ] profile_expected_fields = ['id', 'full_name'] label_expected_fields = ['id', 'text'] study_class_expected_fields = ['id', 'class_grade', 'class_letter'] grade_expected_fields = [ 'id', 'grade', 'taken_at', 'grade_type', 'created' ] absence_expected_fields = ['id', 'taken_at', 'is_founded', 'created'] exam_grade_expected_fields = [ 'id', 'examination_type', 'grade1', 'grade2', 'taken_at', 'created' ] self.assertCountEqual(response.data.keys(), expected_fields) self.assertEqual(len(response.data['parents']), 1) self.assertCountEqual(response.data['parents'][0].keys(), profile_expected_fields) self.assertEqual(len(response.data['labels']), 1) self.assertCountEqual(response.data['labels'][0].keys(), label_expected_fields) self.assertCountEqual(response.data['study_class'].keys(), study_class_expected_fields) catalogs_per_subjects = response.data['catalogs_per_subjects'] self.assertEqual(len(catalogs_per_subjects), 3) for catalog_data in catalogs_per_subjects: self.assertCountEqual(catalog_data.keys(), catalog_expected_fields) self.assertCountEqual(catalog_data['teacher'].keys(), profile_expected_fields) self.assertEqual(catalog_data['avg_limit'], 6 if catalog_data['id'] == catalog1.id else 5) self.assertEqual(catalog_data['third_of_hours_count_sem1'], 5) self.assertEqual(catalog_data['third_of_hours_count_sem2'], 5) self.assertEqual(catalog_data['third_of_hours_count_annual'], 10) self.assertEqual(catalogs_per_subjects[0]['id'], catalog1.id) self.assertEqual(catalogs_per_subjects[0]['teacher']['id'], self.teacher.id) self.assertEqual(catalogs_per_subjects[0]['subject_name'], coordination_subject.name) self.assertEqual(catalogs_per_subjects[1]['id'], catalog3.id) self.assertEqual(catalogs_per_subjects[1]['teacher']['id'], teacher2.id) self.assertEqual(catalogs_per_subjects[1]['subject_name'], subject2.name) self.assertEqual(catalogs_per_subjects[2]['id'], catalog2.id) self.assertEqual(catalogs_per_subjects[2]['teacher']['id'], self.teacher.id) self.assertEqual(catalogs_per_subjects[2]['subject_name'], subject1.name) for grade_data in catalogs_per_subjects[2][ 'grades_sem1'] + catalogs_per_subjects[2]['grades_sem2']: self.assertCountEqual(grade_data.keys(), grade_expected_fields) for abs_data in catalogs_per_subjects[2][ 'abs_sem1'] + catalogs_per_subjects[2]['abs_sem2']: self.assertCountEqual(abs_data.keys(), absence_expected_fields) for exam_grade_data in catalogs_per_subjects[2]['second_examination_grades'] + \ catalogs_per_subjects[2]['difference_grades_sem1'] + catalogs_per_subjects[2]['difference_grades_sem2']: self.assertCountEqual(exam_grade_data.keys(), exam_grade_expected_fields) self.assertEqual(catalogs_per_subjects[2]['grades_sem1'][0]['id'], grade1.id) self.assertEqual(catalogs_per_subjects[2]['grades_sem1'][1]['id'], grade2.id) self.assertEqual(catalogs_per_subjects[2]['grades_sem2'][0]['id'], grade4.id) self.assertEqual(catalogs_per_subjects[2]['grades_sem2'][1]['id'], grade3.id) self.assertEqual(catalogs_per_subjects[2]['abs_sem1'][0]['id'], abs1.id) self.assertEqual(catalogs_per_subjects[2]['abs_sem1'][1]['id'], abs2.id) self.assertEqual(catalogs_per_subjects[2]['abs_sem2'][0]['id'], abs4.id) self.assertEqual(catalogs_per_subjects[2]['abs_sem2'][1]['id'], abs3.id) self.assertEqual( catalogs_per_subjects[2]['second_examination_grades'][0]['id'], exam_grade2.id) self.assertEqual( catalogs_per_subjects[2]['second_examination_grades'][1]['id'], exam_grade1.id) self.assertEqual( catalogs_per_subjects[2]['difference_grades_sem1'][0]['id'], exam_grade4.id) self.assertEqual( catalogs_per_subjects[2]['difference_grades_sem1'][1]['id'], exam_grade3.id) self.assertEqual( catalogs_per_subjects[2]['difference_grades_sem2'][0]['id'], exam_grade5.id) self.assertEqual( catalogs_per_subjects[2]['difference_grades_sem2'][1]['id'], exam_grade6.id)
def setUpTestData(cls): cls.principal = UserProfileFactory( user_role=UserProfile.UserRoles.PRINCIPAL) cls.school_unit = RegisteredSchoolUnitFactory( school_principal=cls.principal) cls.category1 = SchoolUnitCategoryFactory( category_level=SchoolUnitCategory.CategoryLevels.PRIMARY_SCHOOL) cls.category2 = SchoolUnitCategoryFactory( category_level=SchoolUnitCategory.CategoryLevels.SECONDARY_SCHOOL) cls.category3 = SchoolUnitCategoryFactory( category_level=SchoolUnitCategory.CategoryLevels.HIGHSCHOOL) cls.school_unit.categories.add(cls.category1, cls.category2, cls.category3) cls.calendar = AcademicYearCalendarFactory() cls.subject1 = SubjectFactory() cls.subject2 = SubjectFactory() cls.coordination_subject = SubjectFactory(is_coordination=True) cls.academic_program = AcademicProgramFactory( school_unit=cls.school_unit) for class_grade, class_grade_arabic in zip(['I', 'VI', 'IX'], [1, 6, 9]): ProgramSubjectThroughFactory(academic_program=cls.academic_program, subject=cls.subject1, is_mandatory=False, class_grade=class_grade, class_grade_arabic=class_grade_arabic) ProgramSubjectThroughFactory( generic_academic_program=cls.academic_program. generic_academic_program, subject=cls.subject2, class_grade=class_grade, class_grade_arabic=class_grade_arabic) cls.teacher1 = UserProfileFactory( user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school_unit) cls.teacher2 = UserProfileFactory( user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school_unit) cls.teacher1.taught_subjects.add(cls.subject1) cls.teacher2.taught_subjects.add(cls.subject2) cls.student1 = UserProfileFactory( user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school_unit) cls.student2 = UserProfileFactory( user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school_unit) cls.url = reverse('study_classes:study-class-list', kwargs={'academic_year': cls.calendar.academic_year}) cls.class_master = UserProfileFactory( user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school_unit) cls.primary_school_request_data = { 'class_grade': 'I', 'class_letter': 'A', 'academic_program': cls.academic_program.id, "class_master": cls.class_master.id, "teachers_class_through": [{ "teacher": cls.teacher1.id, "subject": cls.subject1.id }, { "teacher": cls.teacher2.id, "subject": cls.subject2.id }], "students": [cls.student1.id, cls.student2.id] } cls.secondary_school_request_data = { 'class_grade': 'VI', 'class_letter': 'A1', 'academic_program': cls.academic_program.id, "class_master": cls.class_master.id, "teachers_class_through": [{ "teacher": cls.teacher1.id, "subject": cls.subject1.id }, { "teacher": cls.teacher2.id, "subject": cls.subject2.id }], "students": [cls.student1.id, cls.student2.id] }