def setUpTestData(cls):
cls.academic_year = create_current_academic_year()
cls.education_group = EducationGroupFactory()
EducationGroupYearFactory(education_group=cls.education_group,
academic_year=cls.academic_year)
cls.faculty_manager = PersonWithPermissionsFactory(
'view_admission',
'change_admission',
groups=[TRAINING_MANAGERS_GROUP])
cls.formation = ContinuingEducationTrainingFactory(
education_group=cls.education_group)
PersonTraining(person=cls.faculty_manager,
training=cls.formation).save()
cls.continuing_education_manager = PersonWithPermissionsFactory(
'view_admission',
'change_admission',
'validate_registration',
groups=[MANAGERS_GROUP])
EntityVersionFactory(entity=cls.formation.management_entity)
cls.registration_submitted = AdmissionFactory(
formation=cls.formation,
state=REGISTRATION_SUBMITTED,
academic_year=cls.academic_year)
cls.registration_validated = AdmissionFactory(
formation=cls.formation,
state=VALIDATED,
academic_year=cls.academic_year)
cls.student_worker = PersonWithPermissionsFactory(
'view_admission',
'change_received_file_state',
'validate_registration',
groups=[STUDENT_WORKERS_GROUP])
def setUpTestData(cls):
cls.academic_year = create_current_academic_year()
cls.education_group = EducationGroupFactory()
EducationGroupYearFactory(education_group=cls.education_group,
academic_year=cls.academic_year)
cls.formation = ContinuingEducationTrainingFactory(
education_group=cls.education_group,
additional_information_label='additional_information',
registration_required=True)
cls.education_group_no_registration_required = EducationGroupFactory()
EducationGroupYearFactory(
education_group=cls.education_group_no_registration_required,
academic_year=cls.academic_year)
cls.formation_no_registration_required = ContinuingEducationTrainingFactory(
education_group=cls.education_group_no_registration_required,
registration_required=False)
group = GroupFactory(name=MANAGERS_GROUP)
cls.manager = PersonWithPermissionsFactory('view_admission',
'change_admission')
cls.manager.user.groups.add(group)
group = GroupFactory(name=TRAINING_MANAGERS_GROUP)
cls.training_manager = PersonWithPermissionsFactory(
'view_admission', 'change_admission')
cls.training_manager.user.groups.add(group)
EntityVersionFactory(entity=cls.formation.management_entity)
cls.admission = AdmissionFactory(
formation=cls.formation,
state=SUBMITTED,
person_information__person__gender='M',
academic_year=cls.academic_year,
)
a_person_information = ContinuingEducationPersonFactory(
person__gender='M')
cls.admission_no_admission_required = AdmissionFactory(
formation=cls.formation_no_registration_required,
state=ACCEPTED_NO_REGISTRATION_REQUIRED,
person_information=a_person_information,
academic_year=cls.academic_year,
)
cls.file = SimpleUploadedFile(name='upload_test.pdf',
content=str.encode(FILE_CONTENT),
content_type="application/pdf")
cls.country = CountryFactory()
cls.person_data = {
'last_name': cls.admission.person_information.person.last_name,
'first_name': cls.admission.person_information.person.first_name,
'gender': cls.admission.person_information.person.gender,
'email': cls.admission.person_information.person.email,
}
cls.continuing_education_person_data = {
'birth_date':
cls.admission.person_information.birth_date.strftime('%Y-%m-%d'),
'birth_location':
cls.admission.person_information.birth_location,
'birth_country':
cls.admission.person_information.birth_country.id,
}
def setUpTestData(cls):
group = GroupFactory(name=MANAGERS_GROUP)
cls.manager = PersonWithPermissionsFactory('view_admission', 'change_admission')
cls.manager.user.groups.add(group)
cls.academic_year = AcademicYearFactory(year=2018)
cls.education_group = EducationGroupFactory()
EducationGroupYearFactory(
education_group=cls.education_group,
academic_year=cls.academic_year
)
cls.formation = ContinuingEducationTrainingFactory(
education_group=cls.education_group
)
cls.registrations_to_validate = [
AdmissionFactory(
state=admission_state_choices.REGISTRATION_SUBMITTED,
formation=cls.formation
) for _ in range(2)
]
cls.registration_not_to_validate = AdmissionFactory(
state=admission_state_choices.DRAFT,
diploma_produced=True,
formation=cls.formation
)
cls.diplomas_to_produce = [
AdmissionFactory(
state=admission_state_choices.VALIDATED,
diploma_produced=False,
formation=cls.formation,
ucl_registration_complete=True,
payment_complete=True,
assessment_succeeded=True,
) for _ in range(2)
]
cls.no_diploma_to_produce_because_waiting = AdmissionFactory(
state=admission_state_choices.WAITING,
diploma_produced=True,
formation=cls.formation
)
cls.admissions_to_accept = [
AdmissionFactory(
state=random.choice([admission_state_choices.SUBMITTED, admission_state_choices.WAITING]),
formation=cls.formation
) for _ in range(2)
]
cls.admission_not_to_accept = AdmissionFactory(
state=admission_state_choices.DRAFT,
formation=cls.formation
)
training_group = GroupFactory(name=TRAINING_MANAGERS_GROUP)
cls.training_manager = PersonWithPermissionsFactory('view_admission', 'change_admission')
cls.training_manager.user.groups.add(training_group)
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(current=True)
cls.learning_container_year = LearningContainerYearFactory(
container_type=LearningContainerYearType.COURSE.name,
academic_year=cls.academic_year)
cls.person = PersonWithPermissionsFactory('can_access_learningunit')
cls.learning_unit_year = LearningUnitYearFullFactory(
learning_container_year=cls.learning_container_year,
academic_year=cls.academic_year)
cls.education_group_year = EducationGroupYearFactory(
academic_year=cls.academic_year)
cls.group_element_year = GroupElementYearFactory(
parent=cls.education_group_year,
child_branch=None,
child_leaf=cls.learning_unit_year)
cls.education_group_year_formation_parent = EducationGroupYearFactory(
academic_year=cls.academic_year)
GroupElementYearFactory(
parent=cls.education_group_year_formation_parent,
child_branch=cls.education_group_year)
cls.education_group_year_formation_great_parent_1 = EducationGroupYearFactory(
academic_year=cls.academic_year)
GroupElementYearFactory(
parent=cls.education_group_year_formation_great_parent_1,
child_branch=cls.education_group_year_formation_parent)
cls.education_group_year_formation_great_parent_2 = EducationGroupYearFactory(
academic_year=cls.academic_year)
GroupElementYearFactory(
parent=cls.education_group_year_formation_great_parent_2,
child_branch=cls.education_group_year_formation_parent)
def setUpTestData(cls):
cls.learning_unit_year = LearningUnitYearFullFactory()
cls.lecturing_unit_component = LecturingLearningUnitComponentFactory(
learning_unit_year=cls.learning_unit_year)
cls.practical_unit_component = PracticalLearningUnitComponentFactory(
learning_unit_year=cls.learning_unit_year)
cls.person = PersonWithPermissionsFactory('can_access_learningunit')
def setUpTestData(cls):
cls.language_fr = LanguageFactory(code="FR")
cls.language_en = LanguageFactory(code="EN")
cls.user = UserFactory()
flag, created = Flag.objects.get_or_create(name='learning_achievement_update')
flag.users.add(cls.user)
cls.person = PersonWithPermissionsFactory("can_access_learningunit", "can_create_learningunit", user=cls.user)
cls.person_entity = PersonEntityFactory(person=cls.person)
EntityVersionFactory(entity=cls.person_entity.entity)
cls.academic_years = AcademicYearFactory.produce_in_future(quantity=5)
cls.max_la_number = 2*len(cls.academic_years)
cls.learning_unit = LearningUnitFactory(start_year=cls.academic_years[0], end_year=cls.academic_years[-1])
cls.learning_container = LearningContainerFactory()
cls.learning_unit_years = [LearningUnitYearFactory(
academic_year=academic_year,
subtype=learning_unit_year_subtypes.FULL,
learning_container_year=LearningContainerYearFactory(
academic_year=academic_year,
learning_container=cls.learning_container,
requirement_entity=cls.person_entity.entity
),
learning_unit=cls.learning_unit,
acronym="TEST0000"
) for academic_year in cls.academic_years]
cls.learning_component_years = [LearningComponentYearFactory(
learning_unit_year=luy,
) for luy in cls.learning_unit_years]
def setUpTestData(cls):
cls.program_manager = ProgramManagerFactory(
person=PersonWithPermissionsFactory("can_access_student")
)
cls.students_db = StudentFactory.create_batch(10)
cls.url = reverse("students")
def setUpTestData(cls):
academic_year = AcademicYearFactory(current=True)
cls.education_group_parent = EducationGroupYearFactory(
acronym="Parent", academic_year=academic_year)
cls.education_group_child_1 = EducationGroupYearFactory(
acronym="Child_1", academic_year=academic_year)
cls.education_group_child_2 = EducationGroupYearFactory(
acronym="Child_2", academic_year=academic_year)
GroupElementYearFactory(parent=cls.education_group_parent,
child_branch=cls.education_group_child_1)
GroupElementYearFactory(parent=cls.education_group_parent,
child_branch=cls.education_group_child_2)
cls.education_group_language_parent = \
EducationGroupLanguageFactory(education_group_year=cls.education_group_parent)
cls.education_group_language_child_1 = \
EducationGroupLanguageFactory(education_group_year=cls.education_group_child_1)
cls.user = PersonWithPermissionsFactory(
"can_access_education_group").user
cls.url = reverse("education_group_read",
args=[
cls.education_group_parent.id,
cls.education_group_child_1.id
])
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(year=2018)
cls.education_group = EducationGroupFactory()
EducationGroupYearFactory(education_group=cls.education_group,
academic_year=cls.academic_year)
cls.formation_1 = ContinuingEducationTrainingFactory(
education_group=cls.education_group)
cls.education_group = EducationGroupFactory()
EducationGroupYearFactory(education_group=cls.education_group,
academic_year=cls.academic_year)
cls.formation_2 = ContinuingEducationTrainingFactory(
education_group=cls.education_group)
group = GroupFactory(name='continuing_education_managers')
cls.manager = PersonWithPermissionsFactory('view_admission',
'change_admission')
cls.manager.user.groups.add(group)
EntityVersionFactory(entity=cls.formation_1.management_entity)
cls.admission_archived = AdmissionFactory(formation=cls.formation_1,
state=WAITING,
archived=True)
cls.admission_no_registration_required_archived = AdmissionFactory(
formation=cls.formation_1,
state=ACCEPTED_NO_REGISTRATION_REQUIRED,
archived=True)
cls.registration_1_unarchived = AdmissionFactory(
formation=cls.formation_2, state=ACCEPTED, archived=False)
cls.registration_2_archived = AdmissionFactory(
formation=cls.formation_2, state=ACCEPTED, archived=True)
def test_is_faculty_manager_case_cannot_modify_data_outside_period(
self, mock_calendar_opened):
person = PersonWithPermissionsFactory()
perm = AdmissionConditionPerms(person.user, self.training)
with self.assertRaises(PermissionDenied):
perm._is_eligible()
def test_disabled_fields_for_training_managers(self):
self.training_manager = PersonWithPermissionsFactory(
groups='continuing_education_training_managers')
self.client.force_login(self.training_manager.user)
form = ContinuingEducationTrainingForm(data=None,
user=self.training_manager.user)
self.assertTrue(form['active'].field.disabled)
def test_is_eligible_to_edit_general_information(self, mock_is_eligible):
person = PersonWithPermissionsFactory()
self.assertTrue(
is_eligible_to_edit_admission_condition(person,
self.common_bachelor))
self.assertTrue(mock_is_eligible.called)
def test_is_eligible_case_raising_exception(self, mock_is_eligible):
person = PersonWithPermissionsFactory()
perm = CommonEducationGroupStrategyPerms(person.user,
TrainingFactory())
with self.assertRaises(PermissionDenied):
perm.is_eligible(raise_exception=True)
def setUp(self):
current_ac = create_current_academic_year()
self.education_group1 = EducationGroupFactory()
self.education_group2 = EducationGroupFactory()
self.education_group_year1 = EducationGroupYearFactory(
education_group=self.education_group1,
academic_year=current_ac,
)
self.education_group_year2 = EducationGroupYearFactory(
education_group=self.education_group2,
academic_year=current_ac,
)
self.person = PersonWithPermissionsFactory("delete_educationgroup")
PersonEntityFactory(person=self.person, entity=self.education_group_year1.management_entity)
PersonEntityFactory(person=self.person, entity=self.education_group_year2.management_entity)
self.url = reverse('delete_education_group', args=[self.education_group_year1.id,
self.education_group_year1.education_group.id])
self.url2 = reverse('delete_education_group', args=[self.education_group_year2.id,
self.education_group_year2.education_group.id])
self.client.force_login(user=self.person.user)
self.academic_calendar = AcademicCalendarFactory(
reference=EDUCATION_GROUP_EDITION,
start_date=timezone.now(),
end_date=timezone.now() + timedelta(weeks=+1),
academic_year=current_ac,
)
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(year=2018)
cls.education_group = EducationGroupFactory()
EducationGroupYearFactory(
education_group=cls.education_group,
academic_year=cls.academic_year
)
cls.formation = ContinuingEducationTrainingFactory(
education_group=cls.education_group
)
group = GroupFactory(name=TRAINING_MANAGERS_GROUP)
cls.training_manager = PersonWithPermissionsFactory('view_admission', 'change_admission')
cls.training_manager.user.groups.add(group)
cls.registration_to_validate = AdmissionFactory(
formation=cls.formation,
state=REGISTRATION_SUBMITTED,
)
cls.admission_diploma_to_produce = AdmissionFactory(
formation=cls.formation,
state=VALIDATED,
)
cls.admission_to_validate = AdmissionFactory(
formation=cls.formation,
state=admission_state_choices.SUBMITTED,
)
def setUpTestData(cls):
cls.perm_patcher = mock.patch(
"base.business.education_groups.perms.AdmissionConditionPerms.is_eligible",
return_value=True)
cls.education_group_year = EducationGroupYearFactory(
academic_year=AcademicYearFactory(current=True))
cls.person = PersonWithPermissionsFactory("can_access_education_group")
def setUpTestData(cls):
cls.program_manager = ProgramManagerFactory(
person=PersonWithPermissionsFactory("can_access_student")
)
cls.student_m = StudentFactory(person=PersonFactory(last_name='Durant', first_name='Thomas', gender='M'))
cls.student_f = StudentFactory(person=PersonFactory(last_name='Durant', first_name='Alice', gender='F'))
cls.url = reverse("students")
def setUpTestData(cls):
cls.manager = PersonWithPermissionsFactory('view_admission',
'change_admission')
cls.education_group_1 = EducationGroupFactory()
cls.continuing_education_training_1 = ContinuingEducationTrainingFactory(
education_group=cls.education_group_1, training_aid=False)
cls.education_group_2 = EducationGroupFactory()
def test_true_if_person_has_both_roles(self, mock_permission):
mock_permission.return_value = True
person_with_both_roles = PersonWithPermissionsFactory(
'change_educationgroupcontent',
groups=(PROGRAM_MANAGER_GROUP, FACULTY_MANAGER_GROUP))
self.assertTrue(
can_update_group_element_year(person_with_both_roles.user,
self.group_element_year))
def test_has_person_the_right_to_add_education_group(self):
person_without_right = PersonFactory()
self.assertFalse(
check_permission(person_without_right, "base.add_educationgroup"))
person_with_right = PersonWithPermissionsFactory("add_educationgroup")
self.assertTrue(
check_permission(person_with_right, "base.add_educationgroup"))
def setUpTestData(cls):
cls.education_group_year = EducationGroupYearFactory()
cls.user = UserFactory()
cls.person = PersonWithPermissionsFactory(
'can_access_education_group',
'add_educationgroupachievement',
user=cls.user
)
PersonEntityFactory(person=cls.person, entity=cls.education_group_year.management_entity)
def setUpTestData(cls):
cls.current_academic_year = create_current_academic_year()
cls.education_group = EducationGroupFactory()
EducationGroupYearFactory(
education_group=cls.education_group,
academic_year=cls.current_academic_year
)
cls.formation = ContinuingEducationTrainingFactory(
education_group=cls.education_group
)
group = GroupFactory(name='continuing_education_training_managers')
cls.training_manager = PersonWithPermissionsFactory('view_admission', 'change_admission')
cls.training_manager.user.groups.add(group)
PersonTraining(person=cls.training_manager, training=cls.formation).save()
group_manager = GroupFactory(name='continuing_education_managers')
cls.manager = PersonWithPermissionsFactory('view_admission', 'change_admission', 'validate_registration')
cls.manager.user.groups.add(group_manager)
def test_inject_admission_to_epc_but_no_iufc_manager(self):
continuing_education_training_manager = PersonWithPermissionsFactory(
'view_admission',
'change_admission',
'validate_registration',
groups=[TRAINING_MANAGERS_GROUP, STUDENT_WORKERS_GROUP])
self.client.force_login(continuing_education_training_manager.user)
response = self.client.get(self.url)
self.assertRedirects(response, "/login/?next={}".format(self.url))
def setUp(self):
self.person_1 = test_person.create_person("person_1",
last_name="test",
email="*****@*****.**")
self.person_2 = test_person.create_person("person_2",
last_name="test",
email="*****@*****.**")
self.persons = [self.person_1, self.person_2]
self.person_3 = PersonWithPermissionsFactory(
"can_receive_emails_about_automatic_postponement")
self.academic_year = test_academic_year.create_academic_year()
test_academic_year.create_academic_year(year=self.academic_year.year -
1)
self.learning_unit_year = LearningUnitYearFactory(
acronym="TEST",
specific_title="Cours de test",
academic_year=self.academic_year)
self.offer_year = test_offer_year.create_offer_year(
"SINF2MA", "Master en Sciences Informatique", self.academic_year)
self.exam_enrollment_1 = test_exam_enrollment.create_exam_enrollment_with_student(
1, "64641200", self.offer_year, self.learning_unit_year)
self.exam_enrollment_2 = test_exam_enrollment.create_exam_enrollment_with_student(
2, "60601200", self.offer_year, self.learning_unit_year)
self.msg_list = [
'The partim TEST_A has been deleted for the year ' +
str(self.academic_year.year),
'The partim TEST_B has been deleted for the year ' +
str(self.academic_year.year),
'The class TEST_C has been deleted for the year ' +
str(self.academic_year.year),
'The class TEST_A_C1 has been deleted for the year ' +
str(self.academic_year.year),
'The class TEST_A_C2 has been deleted for the year ' +
str(self.academic_year.year),
'The class TEST_B_C1 has been deleted for the year ' +
str(self.academic_year.year),
'The class TEST_B_C2 has been deleted for the year ' +
str(self.academic_year.year),
'The learning unit TEST has been successfully deleted for all years'
]
self.egys_to_postpone = EducationGroupYear.objects.all()
self.egys_already_existing = EducationGroupYear.objects.all()
self.egys_ending_this_year = EducationGroupYear.objects.all()
self.luys_to_postpone = LearningUnitYear.objects.all()
self.luys_already_existing = LearningUnitYear.objects.all()
self.luys_ending_this_year = LearningUnitYear.objects.all()
add_message_template_html()
add_message_template_txt()
def test_valid_form_for_continuing_education_managers(self):
self.manager = PersonWithPermissionsFactory(
groups='continuing_education_managers')
self.client.force_login(self.manager.user)
data = self.formation.__dict__
data['formation'] = self.formation.pk
form = ContinuingEducationTrainingForm(data=data,
user=self.manager.user)
self.assertTrue(form.is_valid(), form.errors)
def test_fields_disabled_for_continuing_training_manager(self):
training_manager_group = GroupFactory(name=TRAINING_MANAGERS_GROUP)
manager = PersonWithPermissionsFactory('view_admission',
'change_admission')
manager.user.groups.add(training_manager_group)
form = RegistrationForm(data={}, user=manager.user)
self.assertTrue(form.fields['registration_file_received'].disabled)
self.assertTrue(form.fields['ucl_registration_complete'].disabled)
def setUpTestData(cls):
cls.learning_unit_year = LearningUnitYearFullFactory(
learning_container_year__container_type=COURSE)
cls.lecturing_component = LecturingLearningComponentYearFactory(
learning_unit_year=cls.learning_unit_year)
cls.practical_component = PracticalLearningComponentYearFactory(
learning_unit_year=cls.learning_unit_year)
cls.person = PersonWithPermissionsFactory('can_access_learningunit')
cls.tutor = TutorFactory(person=cls.person)
cls.url = reverse("add_attribution", args=[cls.learning_unit_year.id])
def setUpTestData(cls):
cls.continuing_education_manager = PersonWithPermissionsFactory(
'view_admission',
'change_admission',
'validate_registration',
groups=[MANAGERS_GROUP])
cls.admission = AdmissionFactory()
EducationGroupYearFactory(
education_group=cls.admission.formation.education_group)
cls.url = reverse('injection_to_epc', args=[cls.admission.pk])
def setUpTestData(cls):
continuing_education_group_type = EducationGroupTypeFactory(
name=education_group_types.TrainingType.AGGREGATION.name, )
current_acad_year = create_current_academic_year()
cls.next_acad_year = AcademicYearFactory(year=current_acad_year.year +
1)
cls.previous_acad_year = AcademicYearFactory(
year=current_acad_year.year - 1)
cls.formation_AAAA = EducationGroupYearFactory(
acronym="AAAA",
partial_acronym="AAAA",
academic_year=cls.next_acad_year,
education_group_type=continuing_education_group_type)
cls.formation_BBBB = EducationGroupYearFactory(
acronym="BBBB",
partial_acronym="BBBB",
academic_year=cls.next_acad_year,
education_group_type=continuing_education_group_type)
cls.formation_ABBB = EducationGroupYearFactory(
acronym="ABBB",
partial_acronym="ABBB",
academic_year=cls.next_acad_year,
education_group_type=continuing_education_group_type)
cls.current_academic_formation = EducationGroupYearFactory(
acronym="DDDD",
partial_acronym="DDDD",
academic_year=current_acad_year,
education_group_type=continuing_education_group_type)
group = GroupFactory(name='continuing_education_managers')
cls.manager = PersonWithPermissionsFactory('view_admission',
'change_admission')
cls.manager.user.groups.add(group)
group = GroupFactory(name='continuing_education_training_managers')
cls.training_manager = PersonWithPermissionsFactory(
'view_admission', 'change_admission')
cls.training_manager.user.groups.add(group)
cls.entity_version = EntityVersionFactory(
entity=cls.formation_AAAA.management_entity, )
cls.continuing_education_training = ContinuingEducationTrainingFactory(
education_group=cls.formation_AAAA.education_group)
def test_fields_enabled_if_not_continuing_training_manager(self):
for group in [MANAGERS_GROUP, STUDENT_WORKERS_GROUP]:
manager_group = GroupFactory(name=group)
person_not_manager = PersonWithPermissionsFactory(
'view_admission', 'change_admission')
person_not_manager.user.groups.add(manager_group)
form = RegistrationForm(data={}, user=person_not_manager.user)
self.assertFalse(
form.fields['registration_file_received'].disabled)
self.assertFalse(form.fields['ucl_registration_complete'].disabled)
