def setUpTestData(cls):
today = datetime.date.today()
FacultyManagerGroupFactory()
cls.faculty_user = factory_user.UserFactory()
cls.faculty_person = FacultyManagerFactory('can_propose_learningunit',
'can_create_learningunit',
user=cls.faculty_user)
cls.super_user = factory_user.SuperUserFactory()
cls.person = factory_person.CentralManagerFactory(user=cls.super_user)
start_year = AcademicYearFactory(year=get_current_year())
end_year = AcademicYearFactory(year=get_current_year() + 7)
cls.academic_years = GenerateAcademicYear(start_year,
end_year).academic_years
cls.current_academic_year = cls.academic_years[0]
cls.next_academic_year = cls.academic_years[1]
generate_creation_or_end_date_proposal_calendars(cls.academic_years)
cls.language = LanguageFactory(code='FR')
cls.organization = organization_factory.OrganizationFactory(
type=organization_type.MAIN)
cls.campus = campus_factory.CampusFactory(
organization=cls.organization, is_administration=True)
cls.entity = EntityFactory(organization=cls.organization)
cls.entity_version = EntityVersionFactory(
entity=cls.entity,
entity_type=entity_type.FACULTY,
start_date=today.replace(year=1900),
end_date=None)
PersonEntityFactory(person=cls.faculty_person, entity=cls.entity)
PersonEntityFactory(person=cls.person, entity=cls.entity)
def setUp(self):
self.education_group_year = TrainingFactory(
academic_year=create_current_academic_year())
self.education_group_type = EducationGroupTypeFactory(
category=education_group_categories.TRAINING)
EntityVersionFactory(
entity=self.education_group_year.administration_entity)
EntityVersionFactory(
entity=self.education_group_year.management_entity)
self.list_acs = GenerateAcademicYear(get_current_year(),
get_current_year() +
40).academic_years
self.data = {
'title': 'Métamorphose',
'title_english': 'Transfiguration',
'education_group_type': self.education_group_type.pk,
'credits': 42,
'acronym': 'CRSCHOIXDVLD',
'partial_acronym': 'LDVLD101R',
'management_entity': MainEntityVersionFactory().pk,
'administration_entity': MainEntityVersionFactory().pk,
'main_teaching_campus': "",
'academic_year': create_current_academic_year().pk,
'active': ACTIVE,
'schedule_type': DAILY,
"internship": internship_presence.NO,
"primary_language": LanguageFactory().pk,
"start_year": 2010,
"constraint_type": "",
}
def setUp(self):
self.academic_years = GenerateAcademicYear(
start_year=get_current_year(), end_year=get_current_year() + 10)
self.generate_container = GenerateContainer(
start_year=get_current_year(), end_year=get_current_year() + 10)
self.generated_container_year = self.generate_container.generated_container_years[
0]
self.container_year = self.generated_container_year.learning_container_year
self.learning_unit_year = self.generated_container_year.learning_unit_year_full
self.learning_unit_year_partim = self.generated_container_year.learning_unit_year_partim
self.person = PersonFactory()
edit_learning_unit_permission = Permission.objects.get(
codename="can_edit_learningunit")
self.person.user.user_permissions.add(edit_learning_unit_permission)
self.url = reverse('learning_unit_volumes_management',
kwargs={
'learning_unit_year_id':
self.learning_unit_year.id,
'form_type': 'full'
})
self.client.force_login(self.person.user)
self.user = self.person.user
PersonEntityFactory(entity=self.generate_container.entities[0],
person=self.person)
def setUp(self):
today = datetime.date.today()
self.faculty_user = factory_user.UserFactory()
self.faculty_user.groups.add(
Group.objects.get(name=FACULTY_MANAGER_GROUP))
self.faculty_person = factory_person.PersonFactory(
user=self.faculty_user)
self.faculty_user.user_permissions.add(
Permission.objects.get(codename='can_propose_learningunit'))
self.faculty_user.user_permissions.add(
Permission.objects.get(codename='can_create_learningunit'))
self.super_user = factory_user.SuperUserFactory()
self.person = factory_person.PersonFactory(user=self.super_user)
self.academic_years = GenerateAcademicYear(get_current_year(),
get_current_year() +
7).academic_years
self.current_academic_year = self.academic_years[0]
self.next_academic_year = self.academic_years[1]
self.language = LanguageFactory(code='FR')
self.organization = organization_factory.OrganizationFactory(
type=organization_type.MAIN)
self.campus = campus_factory.CampusFactory(
organization=self.organization, is_administration=True)
self.entity = EntityFactory(organization=self.organization)
self.entity_version = EntityVersionFactory(
entity=self.entity,
entity_type=entity_type.FACULTY,
start_date=today.replace(year=1900),
end_date=None)
PersonEntityFactory(person=self.faculty_person, entity=self.entity)
PersonEntityFactory(person=self.person, entity=self.entity)
def setUpTestData(cls):
start_year = AcademicYearFactory(year=get_current_year())
end_year = AcademicYearFactory(year=get_current_year() + 40)
cls.list_acs = GenerateAcademicYear(start_year,
end_year).academic_years
# Create user and attached it to management entity
cls.person = PersonFactory()
cls.user = cls.person.user
cls.management_entity_version = MainEntityVersionFactory()
cls.education_group_type = EducationGroupTypeFactory(
category=education_group_categories.TRAINING,
name=education_group_types.TrainingType.BACHELOR)
def setUp(self):
current_year = get_current_year()
self.academic_years = [
AcademicYearFactory(year=i)
for i in range(current_year, current_year + 7)
]
self.education_group = EducationGroupFactory(end_year=None)
def setUp(self):
self.data = {
'form-TOTAL_FORMS': '2',
'form-INITIAL_FORMS': '0',
'form-MAX_NUM_FORMS': '2',
'form-0-hourly_volume_total_annual': 20,
'form-0-hourly_volume_partial_q1': 10,
'form-0-hourly_volume_partial_q2': 10,
'form-1-hourly_volume_total_annual': 20,
'form-1-hourly_volume_partial_q1': 10,
'form-1-hourly_volume_partial_q2': 10,
}
generator = GenerateContainer(get_current_year(), get_current_year())
self.learning_unit_year = generator[0].learning_unit_year_full
self.entity_container_years = generator[
0].list_repartition_volume_entities
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(year=get_current_year() + 1)
cls.next_academic_year_1 = AcademicYearFactory(
year=cls.academic_year.year + 1)
cls.next_academic_year_2 = AcademicYearFactory(
year=cls.academic_year.year + 2)
cls.education_group_year = EducationGroupYearFactory(
academic_year=cls.academic_year,
education_group__end_year=cls.next_academic_year_2)
cls.education_group_year_child = EducationGroupYearFactory(
academic_year=cls.academic_year,
education_group__end_year=cls.next_academic_year_2)
cls.group_element_year = GroupElementYearFactory(
parent=cls.education_group_year,
child_branch=cls.education_group_year_child)
AuthorizedRelationshipFactory(
parent_type=cls.education_group_year.education_group_type,
child_type=cls.group_element_year.child_branch.
education_group_type,
)
cls.person = CentralManagerFactory()
cls.url = reverse("group_element_year_update",
kwargs={
"root_id": cls.education_group_year.id,
"education_group_year_id":
cls.education_group_year.id,
"group_element_year_id":
cls.group_element_year.id
})
cls.post_valid_data = {'action': 'edit'}
def setUpTestData(cls):
current_year = get_current_year()
cls.academic_years = [
AcademicYearFactory(year=i)
for i in range(current_year, current_year + 7)
]
cls.luys = [LearningUnitYearFactory() for _ in range(10)]
def setUpTestData(cls):
current_year = get_current_year()
cls.academic_years = [
AcademicYearFactory(year=i)
for i in range(current_year, current_year + 7)
]
cls.egys = [EducationGroupYearFactory() for _ in range(10)]
def setUpTestData(cls):
current_year = get_current_year()
cls.academic_years = [
AcademicYearFactory(year=i)
for i in range(current_year, current_year + 7)
]
cls.learning_unit = LearningUnitFactory(end_year=None)
def test_apply_learning_unit_year_postponement(self):
""" Postpone to N+6 in Learning Unit Admin """
current_year = get_current_year()
academic_years = GenerateAcademicYear(current_year, current_year + 6)
lu = LearningUnitFactory(end_year=None)
LearningUnitYearFactory(academic_year=academic_years[0],
learning_unit=lu)
postpone_url = reverse('admin:base_learningunit_changelist')
self.client.force_login(SuperUserFactory())
response = self.client.post(
postpone_url,
data={
'action': 'apply_learning_unit_year_postponement',
'_selected_action': [lu.pk]
})
msg = [m.message for m in get_messages(response.wsgi_request)]
self.assertEqual(
msg[0],
ngettext(
"%(count)d learning unit has been postponed with success",
"%(count)d learning units have been postponed with success", 6)
% {'count': 6})
def setUp(self):
current_year = get_current_year()
self.academic_years = [
AcademicYearFactory(year=i)
for i in range(current_year, current_year + 7)
]
self.learning_unit = LearningUnitFactory(end_year=None)
def test_apply_education_group_year_postponement(self):
""" Postpone to N+6 in Education Group Admin """
current_year = get_current_year()
academic_years = GenerateAcademicYear(current_year, current_year + 6)
eg = EducationGroupFactory(end_year=None)
EducationGroupYearFactory(academic_year=academic_years[0],
education_group=eg)
postpone_url = reverse('admin:base_educationgroup_changelist')
self.client.force_login(SuperUserFactory())
response = self.client.post(
postpone_url,
data={
'action': 'apply_education_group_year_postponement',
'_selected_action': [eg.pk]
})
msg = [m.message for m in get_messages(response.wsgi_request)]
self.assertEqual(
msg[0],
ngettext(
"%(count)d education group has been postponed with success.",
"%(count)d education groups have been postponed with success.",
6) % {'count': 6})
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(year=get_current_year())
cls.central_manager = GroupFactory(name='central_managers')
cls.education_group_type = EducationGroupTypeFactory(
category=education_group_categories.TRAINING)
cls.form_class = TrainingEducationGroupYearForm
cls.hops_form_class = HopsEducationGroupYearModelForm
super(TestTrainingEducationGroupYearForm,
cls).setUpTestData(education_group_type=cls.education_group_type)
def setUp(self):
self.data = {
'component-TOTAL_FORMS': '2',
'component-INITIAL_FORMS': '0',
'component-MAX_NUM_FORMS': '2',
'component-0-hourly_volume_total_annual': 20,
'component-0-hourly_volume_partial_q1': 10,
'component-0-hourly_volume_partial_q2': 10,
'component-1-hourly_volume_total_annual': 20,
'component-1-hourly_volume_partial_q1': 10,
'component-1-hourly_volume_partial_q2': 10,
'component-0-planned_classes': 1,
'component-1-planned_classes': 1,
}
generator = GenerateContainer(get_current_year(), get_current_year())
self.learning_unit_year = generator[0].learning_unit_year_full
self.entity_container_years = generator[0].list_repartition_volume_entities
self.person = PersonFactory()
def test_configuration_form(self):
year = get_current_year()
form = PartnershipConfigurationForm()
for field in [
'partnership_creation_update_min_year', 'partnership_api_year'
]:
choices = list(form.fields[field].choices)
# Should have null + 3 years
self.assertEqual(len(choices), 4)
# Should be current year first
self.assertIn(str(year), choices[1][1])
def setUpTestData(cls):
start_year = AcademicYearFactory(year=get_current_year())
end_year = AcademicYearFactory(year=get_current_year() + 10)
AcademicCalendarFactory(
data_year=start_year,
start_date=datetime.datetime(start_year.year - 2, 9, 15),
end_date=datetime.datetime(start_year.year + 1, 9, 14),
reference=LEARNING_UNIT_EDITION_FACULTY_MANAGERS
)
cls.academic_years = GenerateAcademicYear(start_year=start_year, end_year=end_year)
generate_learning_unit_edition_calendars(cls.academic_years)
cls.generate_container = GenerateContainer(start_year=start_year, end_year=end_year)
cls.generated_container_year = cls.generate_container.generated_container_years[0]
cls.container_year = cls.generated_container_year.learning_container_year
cls.learning_unit_year = cls.generated_container_year.learning_unit_year_full
cls.learning_unit_year_partim = cls.generated_container_year.learning_unit_year_partim
cls.person = CentralManagerFactory()
cls.url = reverse('learning_unit_volumes_management', kwargs={
'learning_unit_year_id': cls.learning_unit_year.id,
'form_type': 'full'
})
PersonEntityFactory(entity=cls.generate_container.entities[0], person=cls.person)
cls.data = get_valid_formset_data(cls.learning_unit_year.acronym)
cls.partim_formset_data = get_valid_formset_data(cls.learning_unit_year_partim.acronym, is_partim=True)
cls.formset_data = get_valid_formset_data(cls.learning_unit_year_partim.acronym)
cls.data.update({
**cls.formset_data,
'LDROI1200A-0-volume_total': 3,
'LDROI1200A-0-volume_q2': 3,
'LDROI1200A-0-volume_requirement_entity': 2,
'LDROI1200A-0-volume_total_requirement_entities': 3,
})
def setUpTestData(cls):
cls.academic_years = AcademicYearFactory.produce()
cls.luys = LearningUnitYearFactory.create_batch(
4, academic_year__current=True)
cls.url = reverse("learning_units_summary")
cls.get_data = {
"academic_year": get_current_year(),
}
cls.tuples_xls_status_value_with_xls_method_function = ((
"xls_teaching_material",
"base.views.learning_units.search.educational_information.generate_xls_teaching_material"
), )
cls.person = PersonWithPermissionsFactory("can_access_learningunit")
def test_fetch_education_group_to_postpone_to_N6(self):
EducationGroupYearFactory(
education_group=self.education_group,
academic_year=self.academic_years[-4],
)
education_group_to_postpone = EducationGroupYearFactory(
education_group=self.education_group,
academic_year=self.academic_years[-3],
)
self.assertEqual(EducationGroupYear.objects.count(), 2)
result, errors = EducationGroupAutomaticPostponement().postpone()
self.assertEqual(len(result), 2)
self.assertEqual(EducationGroupYear.objects.count(), 4)
self.assertEqual(result[-1].academic_year.year, get_current_year() + 6)
self.assertEqual(result[-1].education_group,
education_group_to_postpone.education_group)
self.assertFalse(errors)
def setUpTestData(cls):
cls.current_year = get_current_year()
cls.academic_years = [
AcademicYearFactory(year=i)
for i in range(cls.current_year, cls.current_year + 7)
]
def setUpTestData(cls):
cls.current_year = AcademicYearFactory(year=get_current_year())
cls.previous_year = AcademicYearFactory(year=get_current_year() - 1)
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(year=get_current_year())
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(year=get_current_year())
cls.central_manager = GroupFactory(name='central_managers')
def setUpTestData(cls):
# Performance fix: don't bother recreating linked objects
class PartnershipFactory(BasePartnershipFactory):
partner = PartnerFactory()
ucl_entity = EntityWithVersionFactory(organization=None)
class PartnershipAgreementFactory(BasePartnershipAgreementFactory):
media = MediaFactory()
# Years :
current_year = get_current_year()
cls.academic_year_less_3 = AcademicYearFactory(year=current_year - 3)
cls.academic_year_less_2 = AcademicYearFactory(year=current_year - 2)
cls.academic_year_less_1 = AcademicYearFactory(year=current_year - 1)
cls.current_academic_year = AcademicYearFactory(year=current_year)
cls.academic_year_more_1 = AcademicYearFactory(year=current_year + 1)
# Partnerships :
cls.partnership_no_agreement = PartnershipFactory(
years__academic_year=cls.academic_year_less_3)
cls.partnership_missing_before = PartnershipFactory(years=[])
cls.partnership_missing_after = PartnershipFactory(years=[])
cls.partnership_missing_middle = PartnershipFactory(years=[])
cls.partnership_missing_before_middle_after = PartnershipFactory(
years=[], )
cls.partnership_full = PartnershipFactory(years=[])
cls.partnership_no_years = PartnershipFactory(years=[])
cls.partnership_with_adjacent = PartnershipFactory(years=[])
cls.partnership_with_extra_agreements_before = PartnershipFactory(
years=[], )
# missing before :
PartnershipYearFactory(
partnership=cls.partnership_missing_before,
academic_year=cls.academic_year_less_3,
)
PartnershipYearFactory(
partnership=cls.partnership_missing_before,
academic_year=cls.academic_year_more_1,
)
PartnershipAgreementFactory(
partnership=cls.partnership_missing_before,
start_academic_year=cls.academic_year_less_2,
end_academic_year=cls.academic_year_more_1,
status=AgreementStatus.VALIDATED.name,
)
# missing after :
PartnershipYearFactory(
partnership=cls.partnership_missing_after,
academic_year=cls.academic_year_less_3,
)
PartnershipYearFactory(
partnership=cls.partnership_missing_after,
academic_year=cls.academic_year_more_1,
)
PartnershipAgreementFactory(
partnership=cls.partnership_missing_after,
start_academic_year=cls.academic_year_less_3,
end_academic_year=cls.current_academic_year,
status=AgreementStatus.VALIDATED.name,
)
# missing middle :
PartnershipYearFactory(
partnership=cls.partnership_missing_middle,
academic_year=cls.academic_year_less_3,
)
PartnershipYearFactory(
partnership=cls.partnership_missing_middle,
academic_year=cls.academic_year_more_1,
)
PartnershipAgreementFactory(
partnership=cls.partnership_missing_middle,
start_academic_year=cls.academic_year_less_3,
end_academic_year=cls.academic_year_less_2,
status=AgreementStatus.VALIDATED.name,
)
PartnershipAgreementFactory(
partnership=cls.partnership_missing_middle,
start_academic_year=cls.current_academic_year,
end_academic_year=cls.academic_year_more_1,
status=AgreementStatus.VALIDATED.name,
)
# missing before middle after :
PartnershipYearFactory(
partnership=cls.partnership_missing_before_middle_after,
academic_year=cls.academic_year_less_3,
)
PartnershipYearFactory(
partnership=cls.partnership_missing_before_middle_after,
academic_year=cls.academic_year_more_1,
)
PartnershipAgreementFactory(
partnership=cls.partnership_missing_before_middle_after,
start_academic_year=cls.academic_year_less_2,
end_academic_year=cls.academic_year_less_2,
status=AgreementStatus.VALIDATED.name,
)
PartnershipAgreementFactory(
partnership=cls.partnership_missing_before_middle_after,
start_academic_year=cls.current_academic_year,
end_academic_year=cls.current_academic_year,
status=AgreementStatus.VALIDATED.name,
)
# full :
PartnershipYearFactory(
partnership=cls.partnership_full,
academic_year=cls.academic_year_less_3,
)
PartnershipYearFactory(
partnership=cls.partnership_full,
academic_year=cls.academic_year_more_1,
)
PartnershipAgreementFactory(
partnership=cls.partnership_full,
start_academic_year=cls.academic_year_less_3,
end_academic_year=cls.academic_year_more_1,
status=AgreementStatus.VALIDATED.name,
)
# with adjacent :
PartnershipYearFactory(
partnership=cls.partnership_with_adjacent,
academic_year=cls.academic_year_less_3,
)
PartnershipYearFactory(
partnership=cls.partnership_with_adjacent,
academic_year=cls.academic_year_more_1,
)
PartnershipAgreementFactory(
partnership=cls.partnership_with_adjacent,
start_academic_year=cls.academic_year_less_3,
end_academic_year=cls.academic_year_less_1,
status=AgreementStatus.VALIDATED.name,
)
PartnershipAgreementFactory(
partnership=cls.partnership_with_adjacent,
start_academic_year=cls.current_academic_year,
end_academic_year=cls.academic_year_more_1,
status=AgreementStatus.VALIDATED.name,
)
# with extra agreements before :
PartnershipYearFactory(
partnership=cls.partnership_with_extra_agreements_before,
academic_year=cls.academic_year_less_2,
)
PartnershipYearFactory(
partnership=cls.partnership_with_extra_agreements_before,
academic_year=cls.academic_year_more_1,
)
PartnershipAgreementFactory(
partnership=cls.partnership_with_extra_agreements_before,
start_academic_year=cls.academic_year_less_3,
end_academic_year=cls.academic_year_more_1,
status=AgreementStatus.VALIDATED.name,
)
