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 setUpTestData(cls):
cls.school_unit = RegisteredSchoolUnitFactory()
cls.teacher = UserProfileFactory(
user_role=UserProfile.UserRoles.TEACHER,
school_unit=cls.school_unit)
cls.academic_year = 2020
cls.study_class = StudyClassFactory(school_unit=cls.school_unit,
class_master=cls.teacher,
class_grade='IX',
class_grade_arabic=9)
cls.coordination_subject = SubjectFactory(name='Dirigentie',
is_coordination=True)
TeacherClassThroughFactory(study_class=cls.study_class,
teacher=cls.teacher,
subject=cls.coordination_subject,
is_class_master=True)
cls.subject1 = SubjectFactory(name='Subject')
cls.subject2 = SubjectFactory(name='Another Subject')
cls.expected_fields = [
'id', 'class_grade', 'class_letter', 'academic_year',
'academic_program_name', 'class_master', 'taught_subjects',
'is_class_master'
]
cls.class_master_fields = ['id', 'full_name']
cls.taught_subject_fields = [
'id', 'name', 'is_coordination', 'allows_exemption', 'is_optional'
]
def test_subject_list(self):
self.client.login(username=self.principal.username, password='******')
subject1 = SubjectFactory(name='Matematica')
subject2 = SubjectFactory(name='Limba romana')
subject3 = SubjectFactory(name='Fizica')
SubjectFactory(name='Dirigentie', is_coordination=True)
SubjectFactory(name='Some other subject',
should_be_in_taught_subjects=False)
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 3)
self.assertEqual(subject3.id, response.data[0]['id'])
self.assertEqual(subject2.id, response.data[1]['id'])
self.assertEqual(subject1.id, response.data[2]['id'])
for result in response.data:
self.assertCountEqual(result.keys(), ['id', 'name'])
# Search
response = self.client.get(self.url, {'search': 'ma'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 2)
self.assertEqual(subject2.id, response.data[0]['id'])
self.assertEqual(subject1.id, response.data[1]['id'])
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 test_teacher_detail(self, profile_param):
self.client.login(username=getattr(self, profile_param).username, password='******')
profile = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=self.school_unit)
profile.labels.add(LabelFactory(user_role=UserProfile.UserRoles.TEACHER))
profile.taught_subjects.add(self.subject)
study_class1 = StudyClassFactory(school_unit=self.school_unit, class_master=profile, class_grade='IX', class_grade_arabic=9)
teacher_class_through1 = TeacherClassThroughFactory(study_class=study_class1, teacher=profile, is_class_master=True,
subject=SubjectFactory(name='A subject'))
teacher_class_through2 = TeacherClassThroughFactory(study_class=study_class1, teacher=profile, is_class_master=True,
subject=SubjectFactory(name='Dirigentie', is_coordination=True))
study_class2 = StudyClassFactory(school_unit=self.school_unit)
teacher_class_through3 = TeacherClassThroughFactory(study_class=study_class2, teacher=profile)
study_class3 = StudyClassFactory(school_unit=self.school_unit, academic_year=2019)
TeacherClassThroughFactory(study_class=study_class3, teacher=profile)
response = self.client.get(self.build_url(profile.id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
expected_fields = ['id', 'full_name', 'user_role', 'email', 'phone_number', 'use_phone_as_username',
'is_active', 'last_online', 'labels', 'taught_subjects', 'assigned_study_classes']
self.assertCountEqual(response.data.keys(), expected_fields)
self.assertCountEqual(response.data['labels'][0].keys(), ['id', 'text'])
self.assertCountEqual(response.data['taught_subjects'][0].keys(), ['id', 'name'])
self.assertEqual(len(response.data['assigned_study_classes']), 3)
self.assertCountEqual(response.data['assigned_study_classes'][0].keys(), ['id', 'study_class_id', 'class_grade', 'class_letter',
'subject_id', 'subject_name', 'is_optional_subject'])
self.assertEqual(response.data['assigned_study_classes'][0]['id'], teacher_class_through3.id)
self.assertEqual(response.data['assigned_study_classes'][1]['id'], teacher_class_through1.id)
self.assertEqual(response.data['assigned_study_classes'][2]['id'], teacher_class_through2.id)
def setUpTestData(cls):
cls.academic_year_calendar = AcademicYearCalendarFactory()
cls.school_unit = RegisteredSchoolUnitFactory()
cls.principal = cls.school_unit.school_principal
cls.subject1 = SubjectFactory()
cls.subject2 = SubjectFactory()
cls.subject3 = SubjectFactory()
cls.study_class = StudyClassFactory(school_unit=cls.school_unit,
class_grade_arabic=10,
class_grade='X',
class_letter='B')
TeacherClassThroughFactory(study_class=cls.study_class,
teacher=cls.study_class.class_master,
subject=cls.subject1,
is_class_master=True)
TeacherClassThroughFactory(study_class=cls.study_class,
teacher=cls.study_class.class_master,
subject=cls.subject2,
is_class_master=True)
cls.source_study_class = StudyClassFactory(class_grade='X',
class_grade_arabic=10,
school_unit=cls.school_unit)
cls.student = UserProfileFactory(
user_role=UserProfile.UserRoles.STUDENT,
school_unit=cls.school_unit,
student_in_class=cls.source_study_class)
cls.expected_fields = [
'id', 'class_grade', 'class_letter', 'academic_year',
'academic_program', 'academic_program_name', 'class_master',
'teachers_class_through', 'students', 'has_previous_catalog_data'
]
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 test_catalog_settings_update_not_teaching_subject(self):
self.client.login(username=self.teacher.username, password='******')
response = self.client.put(
self.build_url(self.study_class.id,
SubjectFactory().id), self.request_data)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_send_message_for_one_student(self, profile_param, mocked_send_sms, mocked_send_mail, mocked_send_mass_mail):
profile = getattr(self, profile_param)
self.client.login(username=profile.username, password='******')
subject2 = SubjectFactory(name='Subject 2')
TeacherClassThroughFactory(teacher=self.teacher, study_class=self.study_class, subject=subject2)
response = self.client.post(self.url, self.notification_for_one_student)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertCountEqual(response.data.keys(), self.expected_fields)
message = Notification.objects.get(id=response.data['id'])
self.assertEqual(message.from_user_id, profile.id)
self.assertEqual(message.from_user_role, profile.user_role)
if profile_param == 'principal':
self.assertIsNone(message.from_user_subjects)
else:
self.assertEqual(message.from_user_subjects, self.subject.name + '__' + subject2.name)
self.assertEqual(message.target_users_role, UserProfile.UserRoles.STUDENT)
self.assertEqual(message.target_study_class_id, self.study_class.id)
self.assertEqual(message.targets_count, 1)
self.assertEqual(mocked_send_mail.call_count, 1)
self.assertEqual(mocked_send_mass_mail.call_count, 0)
# self.assertEqual(mocked_send_sms.call_count, 1)
self.assertEqual(mocked_send_sms.call_count, 0)
self.assertEqual(TargetUserThrough.objects.filter(notification=message).count(), 1)
def test_study_class_update_validate_subjects(self, timezone_mock):
timezone_mock.return_value = datetime.datetime(self.calendar.academic_year, 9, 14, tzinfo=tz.UTC)
self.client.login(username=self.principal.username, password='******')
teachers_class_through1 = [
{
"teacher": self.teacher1.id,
"subject": self.subject1.id
},
{
"teacher": self.teacher2.id,
"subject": self.subject2.id
},
{
"teacher": self.teacher2.id,
"subject": SubjectFactory().id
}
]
teachers_class_through2 = [
{
"teacher": self.teacher1.id,
"subject": self.subject1.id
}
]
for teachers_class_through in [teachers_class_through1, teachers_class_through2]:
self.highschool_request_data['teachers_class_through'] = teachers_class_through
url = self.build_url(self.study_class1.id)
response = self.client.put(url, self.highschool_request_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data['teachers_class_through'], ['The subjects do not correspond with the academic program subjects.'])
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 test_study_class_partially_update_teachers_primary_school(self):
self.client.login(username=self.principal.username, password='******')
primary_study_class = StudyClassFactory(school_unit=self.school_unit, class_grade='I', class_grade_arabic=1)
class_master = primary_study_class.class_master
TeacherClassThroughFactory(study_class=primary_study_class, teacher=class_master, is_class_master=True)
teacher = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=self.school_unit)
subject = SubjectFactory()
teacher.taught_subjects.add(subject)
teacher_class_through = TeacherClassThroughFactory(study_class=primary_study_class, teacher=teacher, is_class_master=False)
url = self.build_url(primary_study_class.id)
request_data = {
'updated_teachers': [
{
'id': teacher_class_through.id,
'teacher': class_master.id
}
]
}
# This is allowed even if the teacher doesn't have the subject in taught subjects list
# (because the teacher is the class master)
response = self.client.patch(url, request_data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
teacher_class_through.refresh_from_db()
self.assertEqual(teacher_class_through.teacher, class_master)
self.assertTrue(teacher_class_through.is_class_master)
def test_academic_program_create_invalid_core_subject(self, mocked_method):
self.client.login(username=self.principal.username, password='******')
del self.data['core_subject']
response = self.client.post(self.build_url(self.academic_year), self.data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data, {'core_subject': ['This academic program must have a core subject.']})
self.data['core_subject'] = 0
response = self.client.post(self.build_url(self.academic_year), self.data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data, {'core_subject': ['Invalid pk "0" - object does not exist.']})
self.data['core_subject'] = SubjectFactory().id
response = self.client.post(self.build_url(self.academic_year), self.data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data, {'core_subject': ['Invalid core subject.']})
self.generic_academic_program.academic_profile = None
self.generic_academic_program.save()
self.school_unit.academic_profile = None
self.school_unit.save()
self.data['core_subject'] = self.mandatory_subject.id
response = self.client.post(self.build_url(self.academic_year), self.data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data, {'core_subject': ['This academic program does not have a core subject.']})
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 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.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.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 test_catalog_import_subject_not_taught_in_study_class(self):
self.client.login(username=self.teacher.username, password='******')
file = self.create_file(self.file_name)
response = self.get_response(
self.build_url(self.study_class.id,
SubjectFactory().id), file)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_catalog_import_does_not_teach_subject(self):
self.client.login(username=self.teacher.username, password='******')
self.teacher_class_through.subject = SubjectFactory()
self.teacher_class_through.save()
file = self.create_file(self.file_name)
response = self.get_response(
self.build_url(self.study_class.id, self.subject.id), file)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def setUpTestData(cls):
cls.principal = UserProfileFactory(user_role=UserProfile.UserRoles.PRINCIPAL)
cls.school_unit = RegisteredSchoolUnitFactory(school_principal=cls.principal)
cls.teacher = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school_unit)
cls.study_class = StudyClassFactory(school_unit=cls.school_unit)
cls.subject = SubjectFactory(name='Subject')
cls.another_subject = SubjectFactory(name='Another subject')
TeacherClassThroughFactory(teacher=cls.teacher, study_class=cls.study_class, subject=cls.subject)
cls.teacher.taught_subjects.add(cls.subject, cls.another_subject)
cls.parent = UserProfileFactory(user_role=UserProfile.UserRoles.PARENT, school_unit=cls.school_unit, sms_notifications_enabled=True)
cls.student1 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school_unit, student_in_class=cls.study_class, sms_notifications_enabled=True)
cls.student1.parents.add(cls.parent)
cls.student2 = UserProfileFactory(user_role=UserProfile.UserRoles.STUDENT, school_unit=cls.school_unit, student_in_class=cls.study_class, sms_notifications_enabled=True)
cls.url = reverse('notifications:my-sent-message-list')
cls.expected_fields = ['id', 'title', 'created', 'send_sms', 'status', 'receiver_type',
'target_users_role', 'target_study_class', 'target_user_through', 'body']
def setUpTestData(cls):
AcademicYearCalendarFactory()
cls.admin = UserProfileFactory(user_role=UserProfile.UserRoles.ADMINISTRATOR)
cls.principal = UserProfileFactory(user_role=UserProfile.UserRoles.PRINCIPAL)
cls.school_unit = RegisteredSchoolUnitFactory(school_principal=cls.principal)
cls.teacher = UserProfileFactory(user_role=UserProfile.UserRoles.TEACHER, school_unit=cls.school_unit)
cls.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=StudyClassFactory(school_unit=cls.school_unit))
cls.subject = SubjectFactory()
def setUpTestData(cls):
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)
cls.subject = SubjectFactory()
cls.teacher_class_through = TeacherClassThroughFactory(
study_class=cls.study_class,
teacher=cls.teacher,
subject=cls.subject)
def test_academic_program_update_invalid_core_subject(self, mocked_method):
self.client.login(username=self.principal.username, password='******')
self.data['core_subject'] = SubjectFactory().id
response = self.client.patch(self.build_url(self.academic_program.id),
self.data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
response.data, {
'core_subject':
['This academic program does not have a core subject.']
})
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_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 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 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)
