def test_study_class_update_validate_academic_program(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='******')
program1 = AcademicProgramFactory(school_unit=self.school_unit, academic_year=2010)
program2 = AcademicProgramFactory(school_unit=RegisteredSchoolUnitFactory())
program3 = AcademicProgramFactory(school_unit=self.school_unit)
program3.generic_academic_program.category.category_level = SchoolUnitCategory.CategoryLevels.PRIMARY_SCHOOL
program3.generic_academic_program.category.save()
for program in [program1, program2, program3]:
self.highschool_request_data['academic_program'] = program.id
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, {'academic_program': ['Invalid academic program.']})
StudyClassFactory(school_unit=self.school_unit, class_master=self.teacher1, class_grade='IX', class_grade_arabic=9,
academic_year=self.study_class1.academic_year - 1)
self.highschool_request_data['academic_program'] = self.academic_program2.id
self.highschool_request_data['class_grade'] = 'X'
response = self.client.put(url, self.highschool_request_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data['academic_program'], ['Cannot change the academic program for a class that has previous catalog data.'])
def test_academic_program_list_filter_by_category(self):
self.client.login(username=self.principal.username, password='******')
highschool_category = SchoolUnitCategoryFactory()
self.school_unit.categories.add(highschool_category)
AcademicProgramFactory(
academic_year=self.academic_year,
name='program',
school_unit=self.school_unit,
generic_academic_program=GenericAcademicProgramFactory(
category=highschool_category))
AcademicProgramFactory(
academic_year=self.academic_year,
name='other',
school_unit=self.school_unit,
generic_academic_program=GenericAcademicProgramFactory(
category=highschool_category))
response = self.client.get(self.build_url(self.academic_year),
{'class_grade': 'IX'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 2)
response = self.client.get(self.build_url(self.academic_year),
{'class_grade': 'IV'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 0)
def setUpTestData(cls):
cls.calendar = AcademicYearCalendarFactory()
cls.last_year = cls.calendar.academic_year - 1
cls.principal = UserProfileFactory(user_role=UserProfile.UserRoles.PRINCIPAL)
cls.school_unit = RegisteredSchoolUnitFactory(school_principal=cls.principal)
cls.last_year_program = AcademicProgramFactory(school_unit=cls.school_unit, academic_year=cls.last_year)
cls.current_year_program = AcademicProgramFactory(school_unit=cls.school_unit, name=cls.last_year_program.name, academic_year=cls.last_year + 1)
cls.study_class = StudyClassFactory(school_unit=cls.school_unit, academic_program=cls.last_year_program, academic_year=cls.last_year)
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.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.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.principal = UserProfileFactory(
user_role=UserProfile.UserRoles.PRINCIPAL)
cls.school_unit = RegisteredSchoolUnitFactory(
school_principal=cls.principal)
cls.academic_program = AcademicProgramFactory(
school_unit=cls.school_unit)
def test_study_class_create_validate_academic_program(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='******')
program1 = AcademicProgramFactory(school_unit=self.school_unit,
academic_year=2010)
program2 = AcademicProgramFactory(
school_unit=RegisteredSchoolUnitFactory())
for program in [program1, program2]:
self.highschool_request_data['academic_program'] = program.id
response = self.client.post(self.url, self.highschool_request_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data['academic_program'],
['Invalid academic program.'])
def test_academic_programs_at_risk_success(self):
self.client.login(username=self.principal.username, password='******')
academic_program1 = AcademicProgramFactory(
students_at_risk_count=2, school_unit=self.school_unit)
academic_program2 = AcademicProgramFactory(
students_at_risk_count=1, school_unit=self.school_unit)
academic_program3 = AcademicProgramFactory(
students_at_risk_count=3, name='a', school_unit=self.school_unit)
academic_program4 = AcademicProgramFactory(
students_at_risk_count=3, name='b', school_unit=self.school_unit)
AcademicProgramFactory(students_at_risk_count=0,
school_unit=self.school_unit)
AcademicProgramFactory(students_at_risk_count=1,
academic_year=2018,
school_unit=self.school_unit)
AcademicProgramFactory(students_at_risk_count=1)
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data['results']), 4)
for result in response.data['results']:
self.assertCountEqual(result.keys(),
['id', 'name', 'students_at_risk_count'])
self.assertEqual(response.data['results'][0]['id'],
academic_program3.id)
self.assertEqual(response.data['results'][1]['id'],
academic_program4.id)
self.assertEqual(response.data['results'][2]['id'],
academic_program1.id)
self.assertEqual(response.data['results'][3]['id'],
academic_program2.id)
def test_academic_program_create_existing_program(self, mocked_method):
self.client.login(username=self.principal.username, password='******')
AcademicProgramFactory(generic_academic_program=self.generic_academic_program,
school_unit=self.school_unit, academic_year=self.academic_year)
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, {'generic_academic_program': ['You already defined this program this year.']})
def test_academic_programs_averages_second_semester(self, mocked_method):
self.client.login(username=self.principal.username, password='******')
AcademicProgramFactory(avg_sem1=1,
avg_annual=1,
school_unit=self.school_unit)
AcademicProgramFactory(avg_sem1=2,
avg_annual=2,
school_unit=self.school_unit)
AcademicProgramFactory(avg_sem2=3,
avg_annual=3,
school_unit=self.school_unit)
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data['results']), 3)
for result in response.data['results']:
self.assertCountEqual(result.keys(), self.expected_fields)
self.assertEqual(response.data['results'][0]['avg_annual'], 3)
self.assertEqual(response.data['results'][1]['avg_annual'], 2)
self.assertEqual(response.data['results'][2]['avg_annual'], 1)
def test_academic_program_list_success(self):
self.client.login(username=self.principal.username, password='******')
academic_program = AcademicProgramFactory(
academic_year=self.academic_year, school_unit=self.school_unit)
academic_program2 = AcademicProgramFactory(
academic_year=self.academic_year, school_unit=self.school_unit)
AcademicProgramFactory(academic_year=self.academic_year,
school_unit=RegisteredSchoolUnitFactory())
AcademicProgramFactory(academic_year=2000,
school_unit=self.school_unit)
response = self.client.get(self.build_url(self.academic_year))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data['results']), 2)
self.assertEqual(response.data['count'], 2)
for program in response.data['results']:
self.assertIn(program['id'],
[academic_program.id, academic_program2.id])
def test_academic_program_list_search(self):
self.client.login(username=self.principal.username, password='******')
academic_program = AcademicProgramFactory(
academic_year=self.academic_year,
name='program',
school_unit=self.school_unit)
AcademicProgramFactory(academic_year=self.academic_year,
name='other',
school_unit=self.school_unit)
AcademicProgramFactory(academic_year=self.academic_year,
name='program',
school_unit=RegisteredSchoolUnitFactory())
response = self.client.get(self.build_url(self.academic_year),
{'search': 'program'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
self.assertEqual(len(response.data['results']), 1)
self.assertEqual(response.data['results'][0]['id'],
academic_program.id)
def setUpTestData(cls):
cls.current_calendar = AcademicYearCalendarFactory()
cls.academic_program = AcademicProgramFactory()
cls.label1 = Label.objects.get(text=FAILING_1_SUBJECT_LABEL)
cls.label2 = Label.objects.get(text=EXEMPTED_SPORT_LABEL)
cls.label3 = Label.objects.get(text=WORKSHOP_LABEL)
cls.student = UserProfileFactory(
user_role=UserProfile.UserRoles.STUDENT,
student_in_class=StudyClassFactory(
academic_program=cls.academic_program))
cls.student.labels.add(cls.label1, cls.label2, cls.label3)
def test_unregistered_academic_program_list(self):
self.client.login(username=self.principal.username, password='******')
AcademicYearCalendarFactory()
generic_program1 = GenericAcademicProgramFactory(
name='Program B',
category=self.category,
academic_profile=self.academic_profile)
generic_program2 = GenericAcademicProgramFactory(
name='Program A',
category=self.category,
academic_profile=self.academic_profile)
generic_program3 = GenericAcademicProgramFactory(
name='Program C',
category=self.category,
academic_profile=self.academic_profile)
GenericAcademicProgramFactory(name='Program D')
AcademicProgramFactory(school_unit=self.school_unit,
generic_academic_program=generic_program3)
AcademicProgramFactory(school_unit=self.school_unit,
generic_academic_program=generic_program2,
academic_year=2018)
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 2)
self.assertEqual(response.data[0]['id'], generic_program2.id)
self.assertEqual(response.data[1]['id'], generic_program1.id)
# Search by name
response = self.client.get(self.url, {'search': 'Program B'})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['id'], generic_program1.id)
self.assertCountEqual(response.data[0].keys(), ['id', 'name'])
def setUpTestData(cls):
cls.principal = UserProfileFactory(
user_role=UserProfile.UserRoles.PRINCIPAL)
cls.school_unit = RegisteredSchoolUnitFactory(
school_principal=cls.principal)
cls.optional_subjects_weekly_hours = {
'IX': 10,
'X': 8,
'XI': 6,
'XII': 6
}
cls.generic_academic_program = GenericAcademicProgramFactory(
optional_subjects_weekly_hours=cls.optional_subjects_weekly_hours)
cls.academic_program = AcademicProgramFactory(
generic_academic_program=cls.generic_academic_program,
school_unit=cls.school_unit)
def test_study_class_delete_success(self, class_grade, class_grade_arabic,
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='******')
academic_program = None
academic_program_name = None
if class_grade_arabic >= 9:
academic_program = AcademicProgramFactory(
school_unit=self.school_unit)
academic_program_name = academic_program.name
study_class = StudyClassFactory(
school_unit=self.school_unit,
academic_program=academic_program,
academic_program_name=academic_program_name,
class_grade=class_grade,
class_grade_arabic=class_grade_arabic)
response = self.client.delete(self.build_url(study_class.id))
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
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 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]
}
def setUpTestData(cls):
# generate subjects
subject_names = [
'Matematica', 'Limba Romana', 'Limba Engleza', 'Limba Franceza',
'Fizica', 'Chimie', 'Biologie', 'TIC', 'Educatie Fizica',
'Tehnologii generale in electronica -automatizari(M1)'
]
all_subjects = [SubjectFactory(name=i) for i in subject_names]
# declare helper for easier selection of subjects
def select_subjects(*args):
return [s for s in all_subjects if s.name in args]
cls.current_calendar = AcademicYearCalendarFactory()
# Generate a new school
cls.school_unit1 = RegisteredSchoolUnitFactory()
academic_program1 = AcademicProgramFactory(
school_unit=cls.school_unit1)
cls.unit1_class1 = StudyClassFactory(
school_unit=cls.school_unit1,
academic_program=academic_program1,
class_grade='VI',
class_grade_arabic=6,
class_letter='A')
cls.unit1_class2 = StudyClassFactory(
school_unit=cls.school_unit1,
academic_program=academic_program1,
class_grade='VII',
class_grade_arabic=7,
class_letter='Z')
# Add two more classes to test order
cls.unit1_class3 = StudyClassFactory(
school_unit=cls.school_unit1,
academic_program=academic_program1,
class_grade='VI',
class_grade_arabic=6,
class_letter='Z')
cls.unit1_class4 = StudyClassFactory(
school_unit=cls.school_unit1,
academic_program=academic_program1,
class_grade='VII',
class_grade_arabic=7,
class_letter='A')
# Add a fifth class; this will not appear in the results since it doesn't have any `StudentCatalogPerSubject`s
StudyClassFactory(school_unit=cls.school_unit1,
academic_program=academic_program1,
class_grade='X',
class_grade_arabic=10,
class_letter='A')
# generate students and select subjects for the first school and class
cls.unit1_class1._catalogs = []
for student in _gen_students(5):
for subject in select_subjects('Matematica', 'Limba Romana',
'Limba Engleza', 'Limba Franceza'):
cls.unit1_class1._catalogs.append(
StudentCatalogPerSubjectFactory(
study_class=cls.unit1_class1,
subject=subject,
student=student))
# generate students and select subjects for the first school and second class
cls.unit1_class2._catalogs = []
for student in _gen_students(10):
for subject in select_subjects(
'Matematica', 'Fizica',
'Tehnologii generale in electronica -automatizari(M1)'):
cls.unit1_class2._catalogs.append(
StudentCatalogPerSubjectFactory(
study_class=cls.unit1_class2,
subject=subject,
student=student))
# generate students and select subjects for the first school for third and forth class
for student in _gen_students(5):
for subject in select_subjects('Matematica', 'Limba Romana',
'Limba Engleza', 'Biologie'):
StudentCatalogPerSubjectFactory(study_class=cls.unit1_class3,
subject=subject,
student=student)
StudentCatalogPerSubjectFactory(study_class=cls.unit1_class4,
subject=subject,
student=student)
# Generate a new school
cls.school_unit2 = RegisteredSchoolUnitFactory()
academic_program2 = AcademicProgramFactory(
school_unit=cls.school_unit2)
cls.unit2_class1 = StudyClassFactory(
school_unit=cls.school_unit2,
academic_program=academic_program2,
class_grade='VI',
class_letter='A')
cls.unit2_class2 = StudyClassFactory(
school_unit=cls.school_unit2,
academic_program=academic_program2,
class_grade='VII',
class_letter='Z')
# generate students and select subjects for the second school and first class
cls.unit2_class1._catalogs = []
for student in _gen_students(5):
for subject in select_subjects('Matematica', 'Limba Romana',
'Limba Engleza', 'TIC'):
cls.unit2_class1._catalogs.append(
StudentCatalogPerSubjectFactory(
study_class=cls.unit2_class1,
subject=subject,
student=student))
# generate students and select subjects for the second school and class
cls.unit2_class2._catalogs = []
for student in _gen_students(5):
for subject in select_subjects('Matematica', 'Fizica', 'Chimie',
'Educatie Fizica'):
cls.unit2_class2._catalogs.append(
StudentCatalogPerSubjectFactory(
study_class=cls.unit2_class2,
subject=subject,
student=student))
