def test_delete_partim_from_full(self):
l_container_year = LearningContainerYearFactory(
academic_year=self.academic_year)
l_unit_year = LearningUnitYearFactory(
subtype=learning_unit_year_subtypes.FULL,
learning_container_year=l_container_year,
learning_unit=LearningUnitFactory(start_year=1900),
academic_year=l_container_year.academic_year)
l_unit_partim_1 = LearningUnitYearFactory(
subtype=learning_unit_year_subtypes.PARTIM,
learning_container_year=l_container_year,
learning_unit=LearningUnitFactory(start_year=1900),
academic_year=l_container_year.academic_year)
l_unit_partim_2 = LearningUnitYearFactory(
subtype=learning_unit_year_subtypes.PARTIM,
learning_container_year=l_container_year,
learning_unit=LearningUnitFactory(start_year=1900),
academic_year=l_container_year.academic_year)
deletion.delete_from_given_learning_unit_year(l_unit_year)
with self.assertRaises(ObjectDoesNotExist):
LearningUnitYear.objects.get(id=l_unit_partim_1.id)
with self.assertRaises(ObjectDoesNotExist):
LearningUnitYear.objects.get(id=l_unit_partim_2.id)
def __init__(self, start_year, end_year):
self.start_year = start_year
self.end_year = end_year
self.learning_container = LearningContainerFactory()
self.learning_unit_full = LearningUnitFactory(learning_container=self.learning_container,
start_year=start_year,
end_year=end_year,
periodicity=learning_unit_periodicity.ANNUAL)
self.learning_unit_partim = LearningUnitFactory(learning_container=self.learning_container,
start_year=start_year,
end_year=end_year,
periodicity=learning_unit_periodicity.ANNUAL)
self._setup_entities()
self._setup_common_data()
self.generated_container_years = [
GenerateContainerYear(
academic_year=AcademicYearFactory(year=year),
learning_unit_full=self.learning_unit_full,
learning_unit_partim=self.learning_unit_partim,
entities=self.entities,
campus=self.campus,
language=self.language
)
for year in range(self.start_year, self.end_year + 1)
]
def test_find_by_ids(self):
l_unit_1 = LearningUnitFactory()
l_unit_2 = LearningUnitFactory()
LearningUnitFactory()
LearningUnitFactory()
self.assertEqual(
2, len(learning_unit.find_by_ids((l_unit_1.id, l_unit_2.id))))
def setUpTestData(cls):
cls.learning_unit_is_prerequisite = LearningUnitFactory()
cls.learning_unit_not_prerequisite = LearningUnitFactory()
cls.learning_unit_year_with_prerequisite = LearningUnitYearFactory()
cls.learning_unit_year_without_prerequisite = LearningUnitYearFactory()
cls.prerequisite = PrerequisiteFactory(
learning_unit_year=cls.learning_unit_year_with_prerequisite)
cls.prerequisite_item = PrerequisiteItemFactory(
prerequisite=cls.prerequisite,
learning_unit=cls.learning_unit_is_prerequisite)
def setUp(self):
self.learning_unit_is_prerequisite = LearningUnitFactory()
self.learning_unit_not_prerequisite = LearningUnitFactory()
self.learning_unit_year_with_prerequisite = LearningUnitYearFactory()
self.learning_unit_year_without_prerequisite = LearningUnitYearFactory()
self.prerequisite = PrerequisiteFactory(learning_unit_year=self.learning_unit_year_with_prerequisite)
self.prerequisite_item = PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.learning_unit_is_prerequisite
)
def test_learning_unit_start_end_year_constraint(self):
# Case same year for start/end
LearningUnitFactory(start_year=self.start_year_2017, end_year=self.start_year_2017)
# Case end_year < start year
with self.assertRaises(AttributeError):
LearningUnitFactory(start_year=self.start_year_2017, end_year=self.start_year_2015)
# Case end year > start year
LearningUnitFactory(start_year=self.start_year_2017, end_year=self.end_year_2018)
def test_delete_learning_container_year(self):
learning_container_year = LearningContainerYearFactory()
learning_unit_year_full = LearningUnitYearFactory(
learning_container_year=learning_container_year,
subtype=learning_unit_year_subtypes.FULL,
learning_unit=LearningUnitFactory(start_year=1900),
academic_year=learning_container_year.academic_year)
learning_unit_year_partim = LearningUnitYearFactory(
learning_container_year=learning_container_year,
subtype=learning_unit_year_subtypes.PARTIM,
learning_unit=LearningUnitFactory(start_year=1900),
academic_year=learning_container_year.academic_year)
learning_unit_year_to_delete = LearningUnitYearFactory(
learning_container_year=learning_container_year,
subtype=learning_unit_year_subtypes.PARTIM,
learning_unit=LearningUnitFactory(start_year=1900),
academic_year=learning_container_year.academic_year)
learning_unit_deletion.delete_from_given_learning_unit_year(
learning_unit_year_to_delete)
with self.assertRaises(ObjectDoesNotExist):
LearningUnitYear.objects.get(id=learning_unit_year_to_delete.id)
self.assertEqual(
learning_unit_year_partim,
LearningUnitYear.objects.get(id=learning_unit_year_partim.id))
self.assertEqual(
learning_unit_year_full,
LearningUnitYear.objects.get(id=learning_unit_year_full.id))
self.assertEqual(
learning_container_year,
LearningContainerYear.objects.get(id=learning_container_year.id))
learning_unit_deletion.delete_from_given_learning_unit_year(
learning_unit_year_partim)
with self.assertRaises(ObjectDoesNotExist):
LearningUnitYear.objects.get(id=learning_unit_year_partim.id)
self.assertEqual(
learning_unit_year_full,
LearningUnitYear.objects.get(id=learning_unit_year_full.id))
self.assertEqual(
learning_container_year,
LearningContainerYear.objects.get(id=learning_container_year.id))
learning_unit_deletion.delete_from_given_learning_unit_year(
learning_unit_year_full)
with self.assertRaises(ObjectDoesNotExist):
LearningUnitYear.objects.get(id=learning_unit_year_full.id)
with self.assertRaises(ObjectDoesNotExist):
LearningContainerYear.objects.get(id=learning_container_year.id)
def test_search(self):
a_learning_unit_1 = LearningUnitFactory()
a_learning_unit_2 = LearningUnitFactory()
ldroi1000_learning_unit_year = LearningUnitYearFactory(academic_year=self.an_academic_year,
learning_unit=a_learning_unit_1,
acronym=LDROI1000)
LearningUnitYearFactory(academic_year=self.an_academic_year, learning_unit=a_learning_unit_2, acronym=LAUT5263)
self.assertEqual(list(mdl_base.learning_unit_year.search(self.an_academic_year,
LDROI1000,
None,
a_learning_unit_1)),
[ldroi1000_learning_unit_year])
def setUp(self):
self.learning_unit = LearningUnitFactory()
self.previous_learning_unit = LearningUnitFactory()
self.current_academic_year = create_current_academic_year()
self.previous_academic_year = AcademicYearFactory(
year=settings.YEAR_LIMIT_LUE_MODIFICATION - 1)
self.learning_unit_year = LearningUnitYearFactory(
academic_year=self.next_academic_yr,
subtype=learning_unit_year_subtypes.FULL,
learning_unit=self.learning_unit,
learning_container_year=self.lcy)
self.previous_learning_unit_year = LearningUnitYearFactory(
academic_year=self.previous_academic_year,
learning_unit=self.learning_unit,
learning_container_year__requirement_entity=self.person_entity.
entity)
self.previous_luy_2 = LearningUnitYearFactory(
academic_year=self.previous_academic_year,
subtype=learning_unit_year_subtypes.FULL,
learning_unit=self.previous_learning_unit,
learning_container_year=LearningContainerYearFactory(
academic_year=self.previous_academic_year,
container_type=learning_container_year_types.COURSE))
self.client.force_login(user=self.central_manager_person.user)
self.proposal = ProposalLearningUnitFactory(
learning_unit_year=self.learning_unit_year,
initial_data={
'learning_container_year': {
'common_title': self.lcy.common_title
},
'entities': {
'REQUIREMENT_ENTITY': self.requirement_entity.id
}
},
)
self.previous_proposal = ProposalLearningUnitFactory(
learning_unit_year=self.previous_luy_2)
self.url_edit = reverse('edit_learning_unit',
args=[self.learning_unit_year.id])
self.url_edit_non_editable = reverse(
'edit_learning_unit', args=[self.previous_learning_unit_year.id])
self.context = {
"learning_unit_year": self.learning_unit_year,
"request": self.request,
"user": self.central_manager_person.user,
"proposal": self.proposal
}
def create_learning_unit_years_and_dependencies(self):
l1 = LearningUnitFactory()
learning_unit_years = []
for year in range(4):
ac_year = AcademicYearFactory(year=2000 + year)
l_containeryear = LearningContainerYearFactory(
academic_year=ac_year)
EntityContainerYearFactory(
learning_container_year=l_containeryear,
entity=self.entity_version.entity,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
learning_unit_year = LearningUnitYearFactory(
learning_unit=l1,
academic_year=ac_year,
learning_container_year=l_containeryear)
learning_unit_years.append(learning_unit_year)
learning_unit_years[1].subtype = learning_unit_year_subtypes.FULL
learning_unit_years[1].save()
lcomponent = LearningComponentYearFactory()
LearningClassYearFactory(learning_component_year=lcomponent)
LearningClassYearFactory(learning_component_year=lcomponent)
LearningUnitComponentFactory(learning_unit_year=learning_unit_years[1],
learning_component_year=lcomponent)
return learning_unit_years
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_find_first(self):
a_learning_unit = LearningUnitFactory()
a_learning_unit_year_1 = LearningUnitYearFactory(academic_year=self.an_academic_year,
learning_unit=a_learning_unit,
acronym=LDROI1000)
self.assertEqual(mdl_base.learning_unit_year.find_first(self.an_academic_year, a_learning_unit),
a_learning_unit_year_1)
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_cannot_delete_learning_unit_year_with_administrative_manager_role(self):
manager = AdministrativeManagerFactory()
entity_version = EntityVersionFactory(entity_type=entity_type.FACULTY, acronym="SST",
start_date=datetime.date(year=1990, month=1, day=1),
end_date=None)
PersonEntityFactory(person=manager, entity=entity_version.entity, with_child=True)
# Creation UE
learning_unit = LearningUnitFactory()
l_containeryear = LearningContainerYearFactory(academic_year=self.academic_year,
container_type=learning_container_year_types.COURSE,
requirement_entity=entity_version.entity)
learning_unit_year = LearningUnitYearFactory(learning_unit=learning_unit,
academic_year=self.academic_year,
learning_container_year=l_containeryear,
subtype=learning_unit_year_subtypes.FULL)
# Cannot remove FULL COURSE
self.assertFalse(
base.business.learning_units.perms.is_eligible_to_delete_learning_unit_year(
learning_unit_year,
manager
)
)
# Can remove PARTIM COURSE
learning_unit_year.subtype = learning_unit_year_subtypes.PARTIM
learning_unit_year.save()
self.assertFalse(
base.business.learning_units.perms.is_eligible_to_delete_learning_unit_year(
learning_unit_year,
manager
)
)
def setUpTestData(cls):
cls.academic_year = create_current_academic_year()
cls.learning_unit = LearningUnitFactory(start_year__year=1900)
cls.l_container_year = LearningContainerYearFactory(acronym="LBIR1212", academic_year=cls.academic_year)
cls.user = UserFactory()
def setUp(self):
today = datetime.date.today()
self.academic_yr = AcademicYearFactory(
start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
self.academic_yr_1 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 1),
end_date=today.replace(year=today.year + 2),
year=today.year + 1)
super(AcademicYear, self.academic_yr_1).save()
self.academic_year_6 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 6),
end_date=today.replace(year=today.year + 7),
year=today.year + 6)
super(AcademicYear, self.academic_year_6).save()
self.lunit_container_yr = LearningContainerYearFactory(
academic_year=self.academic_yr)
lu = LearningUnitFactory(end_year=self.academic_yr.year)
self.luy = LearningUnitYearFactory(
academic_year=self.academic_yr,
learning_container_year=self.lunit_container_yr,
subtype=FULL,
learning_unit=lu)
def setUpTestData(cls):
cls.person_fac = FacultyManagerFactory()
cls.academic_yr = create_current_academic_year()
cls.academic_yr_1 = AcademicYearFactory.build(
year=cls.academic_yr.year + 1)
super(AcademicYear, cls.academic_yr_1).save()
cls.academic_yr_2 = AcademicYearFactory.build(
year=cls.academic_yr.year + 2)
super(AcademicYear, cls.academic_yr_2).save()
cls.academic_yr_6 = AcademicYearFactory.build(
year=cls.academic_yr.year + 6)
super(AcademicYear, cls.academic_yr_6).save()
previous_academic_yr = AcademicYearFactory.build(
year=cls.academic_yr.year - 1)
super(AcademicYear, previous_academic_yr).save()
cls.lunit_container_yr = LearningContainerYearFactory(
academic_year=cls.academic_yr)
cls.luy = LearningUnitYearFactory(
academic_year=cls.academic_yr,
learning_container_year=cls.lunit_container_yr,
subtype=FULL,
learning_unit=LearningUnitFactory(
start_year=create_past_academic_year(),
end_year=cls.academic_yr))
academic_years = [
cls.academic_yr, cls.academic_yr_1, cls.academic_yr_2
]
generate_learning_unit_edition_calendars(academic_years)
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 create_learning_unit_years_and_dependencies(self):
acronym = "LDROI1004"
l1 = LearningUnitFactory(
start_year=settings.YEAR_LIMIT_LUE_MODIFICATION)
learning_unit_years = []
for year in range(4):
ac_year = AcademicYearFactory(
year=settings.YEAR_LIMIT_LUE_MODIFICATION + year)
l_containeryear = LearningContainerYearFactory(
academic_year=ac_year)
EntityContainerYearFactory(
learning_container_year=l_containeryear,
entity=self.entity_version.entity,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
learning_unit_year = LearningUnitYearFactory(
acronym=acronym,
learning_unit=l1,
academic_year=ac_year,
learning_container_year=l_containeryear)
learning_unit_years.append(learning_unit_year)
learning_unit_years[1].subtype = learning_unit_year_subtypes.FULL
learning_unit_years[1].save()
lcomponent = LearningComponentYearFactory()
LearningClassYearFactory(learning_component_year=lcomponent)
LearningClassYearFactory(learning_component_year=lcomponent)
return learning_unit_years
def test_li_edit_lu_year_is_learning_unit_year_not_in_range_to_be_modified(
self):
managers = [
create_person_with_permission_and_group(FACULTY_MANAGER_GROUP,
'can_edit_learningunit'),
create_person_with_permission_and_group(UE_FACULTY_MANAGER_GROUP,
'can_edit_learningunit'),
]
later_luy = LearningUnitYearFactory(
academic_year=self.later_academic_year,
learning_unit=LearningUnitFactory(existing_proposal_in_epc=False))
self.context["learning_unit_year"] = later_luy
for manager in managers:
self.context["user"] = manager.user
result = li_edit_lu(
self.context, reverse('edit_learning_unit',
args=[later_luy.id]), "")
self.assertEqual(
result,
self._get_result_data_expected(ID_LINK_EDIT_LU,
MSG_NOT_GOOD_RANGE_OF_YEARS))
def create_learning_unit_years_and_dependencies(self):
academic_year = create_editable_academic_year()
acronym = "LDROI1004"
l1 = LearningUnitFactory(start_year=academic_year.year)
learning_unit_years = []
for year in range(4):
ac_year = AcademicYearFactory(year=academic_year.year + year)
l_containeryear = LearningContainerYearFactory(
academic_year=ac_year,
requirement_entity=self.entity_version.entity,
)
learning_unit_year = LearningUnitYearFactory(
acronym=acronym,
learning_unit=l1,
academic_year=ac_year,
learning_container_year=l_containeryear)
learning_unit_years.append(learning_unit_year)
learning_unit_years[1].subtype = learning_unit_year_subtypes.FULL
learning_unit_years[1].save()
lcomponent = LearningComponentYearFactory()
LearningClassYearFactory(learning_component_year=lcomponent)
LearningClassYearFactory(learning_component_year=lcomponent)
return learning_unit_years
def test_properties_acronym_and_title(self):
a_learning_unit = LearningUnitFactory()
a_learning_unit_year = LearningUnitYearFactory(
learning_unit=a_learning_unit)
self.assertEqual(a_learning_unit.title,
a_learning_unit_year.specific_title)
self.assertEqual(a_learning_unit.acronym, a_learning_unit_year.acronym)
def test_check_delete_learning_unit_with_internship(self):
learning_unit = LearningUnitFactory()
speciality = SpecialityFactory(learning_unit=learning_unit)
msg = learning_unit_deletion.check_learning_unit_deletion(
learning_unit)
self.assertIn(speciality, msg.keys())
def get_data_dict(self, container_type):
learning_container = LearningContainerFactory()
learning_container_yr = LearningContainerYearFactory(
academic_year=self.current_academic_year,
learning_container=learning_container)
entity_version = EntityVersionFactory()
a_learning_unit = LearningUnitFactory()
requirement_entity_container_yr = EntityContainerYearFactory(
learning_container_year=learning_container_yr,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
return {
'new_learning_container_year': learning_container_yr,
'data': {
'quadrimester': '',
'acronym': 'LTATO1200',
'subtype': 'FULL',
'allocation_entity': entity_version,
'additional_requirement_entity_2': None,
'status': True,
'academic_year': self.current_academic_year,
'requirement_entity': entity_version,
'credits': Decimal('15'),
'container_type': container_type,
'session': '',
'additional_requirement_entity_1': None
},
'new_learning_unit': a_learning_unit,
'requirement_entity_containers': [requirement_entity_container_yr],
'status': True,
'academic_year': self.current_academic_year
}
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 setup_learning_unit(start_year, periodicity=learning_unit_periodicity.ANNUAL, end_year=None):
result = None
if start_year:
result = LearningUnitFactory(
start_year=start_year,
periodicity=periodicity,
end_year=end_year)
return result
def test_delete_before_2015(self):
lu = LearningUnitFactory(start_year=self.start_year_2014, end_year=self.start_year_2017)
with self.assertRaises(DatabaseError):
lu.delete()
lu.start_year = self.start_year_2015
lu.delete()
def create_learning_unit_year(acronym, title, academic_year):
learning_unit = LearningUnitFactory(acronym=acronym,
title=title,
start_year=2010)
return LearningUnitYearFactory(acronym=acronym,
title=title,
academic_year=academic_year,
learning_unit=learning_unit)
def setUp(self):
self.learning_unit = LearningUnitFactory()
self.current_academic_year = create_current_academic_year()
self.next_academic_yr = AcademicYearFactory(
year=self.current_academic_year.year + 1)
self.lcy = LearningContainerYearFactory(
academic_year=self.current_academic_year,
container_type=learning_container_year_types.COURSE)
def test_case_update_correctly_saved(self):
learning_unit_to_update = LearningUnitFactory(learning_container=self.learning_container,
start_year=self.current_academic_year.year)
self.form = LearningUnitModelForm(self.post_data, instance=learning_unit_to_update)
self.assertTrue(self.form.is_valid(), self.form.errors)
lu = self.form.save(**self.save_kwargs)
self.assertEqual(lu.faculty_remark, self.quote_1)
self.assertEqual(lu.other_remark, self.quote_2)