def test_is_eligible_for_cancel_of_proposal_wrong_state(self):
generated_container = GenerateContainer(
start_year=self.academic_yr.year, end_year=self.academic_yr.year)
generated_container_first_year = generated_container.generated_container_years[
0]
an_requirement_entity = generated_container_first_year.requirement_entity_container_year
luy = generated_container_first_year.learning_unit_year_full
faculty_managers = [
create_person_with_permission_and_group(
FACULTY_MANAGER_GROUP, 'can_propose_learningunit'),
create_person_with_permission_and_group(
UE_FACULTY_MANAGER_GROUP, 'can_propose_learningunit')
]
a_proposal = ProposalLearningUnitFactory(
learning_unit_year=luy,
type=proposal_type.ProposalType.MODIFICATION.name,
state=proposal_state.ProposalState.CENTRAL.name,
initial_data={
"learning_container_year": {
"requirement_entity": an_requirement_entity.id,
}
})
for manager in faculty_managers:
PersonEntityFactory(person=manager, entity=an_requirement_entity)
self.assertFalse(
perms.is_eligible_for_cancel_of_proposal(a_proposal, manager))
def setUp(self):
self.current_academic_year = create_current_academic_year()
self.generated_ac_years = GenerateAcademicYear(
self.current_academic_year.year + 1,
self.current_academic_year.year + 10)
# Creation of a LearingContainerYear and all related models - FOR 6 years
self.learn_unit_structure = GenerateContainer(
self.current_academic_year.year,
self.current_academic_year.year + 6)
# Build in Generated Container [first index = start Generate Container ]
self.generated_container_year = self.learn_unit_structure.generated_container_years[
0]
# Update All full learning unit year acronym
LearningUnitYear.objects.filter(learning_unit=self.learn_unit_structure.learning_unit_full)\
.update(acronym=FULL_ACRONYM)
# Update All partim learning unit year acronym
LearningUnitYear.objects.filter(learning_unit=self.learn_unit_structure.learning_unit_partim) \
.update(acronym=FULL_ACRONYM + SUBDIVISION_ACRONYM)
self.learning_unit_year_full = LearningUnitYear.objects.get(
learning_unit=self.learn_unit_structure.learning_unit_full,
academic_year=self.current_academic_year)
self.learning_unit_year_partim = LearningUnitYear.objects.get(
learning_unit=self.learn_unit_structure.learning_unit_partim,
academic_year=self.current_academic_year)
self.person = PersonFactory()
for entity in self.learn_unit_structure.entities:
PersonEntityFactory(person=self.person, entity=entity)
def setUp(self):
self.user = UserFactory()
generatorContainer = GenerateContainer(datetime.date.today().year,
datetime.date.today().year)
self.partim = generatorContainer.generated_container_years[
0].learning_unit_year_partim
self.learning_unit_year_1 = generatorContainer.generated_container_years[
0].learning_unit_year_full
self.entity_1 = generatorContainer.entities[0]
self.entity_version_1 = EntityVersionFactory(entity=self.entity_1,
acronym="AGRO")
self.entity_2 = generatorContainer.entities[0]
self.entity_version_2 = EntityVersionFactory(entity=self.entity_2,
acronym="DRT")
self.learning_unit_year_1.entities = {
REQUIREMENT_ENTITY: self.entity_version_1,
ALLOCATION_ENTITY: self.entity_version_1,
ADDITIONAL_REQUIREMENT_ENTITY_1: self.entity_version_2
}
self.academic_year = self.learning_unit_year_1.academic_year
self.proposal = ProposalLearningUnitFactory(
learning_unit_year=self.learning_unit_year_1,
initial_data={"learning_unit": {
"faculty_remark": "First remark"
}})
def setUp(self):
self.current_academic_year = create_current_academic_year()
self.generated_ac_years = GenerateAcademicYear(
self.current_academic_year.year + 1,
self.current_academic_year.year + 10)
# Creation of a LearingContainerYear and all related models
self.learn_unit_structure = GenerateContainer(
self.current_academic_year.year, self.current_academic_year.year)
# Build in Generated Container [first index = start Generate Container ]
self.generated_container_year = self.learn_unit_structure.generated_container_years[
0]
# Update Full learning unit year acronym
self.learning_unit_year_full = LearningUnitYear.objects.get(
learning_unit=self.learn_unit_structure.learning_unit_full,
academic_year=self.current_academic_year)
self.learning_unit_year_full.acronym = FULL_ACRONYM
self.learning_unit_year_full.learning_container_year.acronym = FULL_ACRONYM
self.learning_unit_year_full.learning_container_year.save()
self.learning_unit_year_full.save()
# Update Partim learning unit year acronym
self.learning_unit_year_partim = LearningUnitYear.objects.get(
learning_unit=self.learn_unit_structure.learning_unit_partim,
academic_year=self.current_academic_year,
learning_container_year=self.learning_unit_year_full.
learning_container_year)
self.learning_unit_year_partim.acronym = FULL_ACRONYM + SUBDIVISION_ACRONYM
self.learning_unit_year_partim.save()
def test_when_proposal_of_type_modification_and_accepted_with_partim(self):
old_academic_year = AcademicYearFactory(
year=datetime.date.today().year - 2)
current_academic_year = AcademicYearFactory(
year=datetime.date.today().year)
generator_container = GenerateContainer(old_academic_year,
current_academic_year)
generator_container.generated_container_years[
0].learning_unit_year_full.learning_unit.end_year = None
LearningUnitYearPartimFactory(
learning_container_year=generator_container.
generated_container_years[0].learning_unit_year_full.
learning_container_year,
academic_year=generator_container.generated_container_years[0].
learning_unit_year_full.academic_year)
proposal = ProposalLearningUnitFactory(
state=proposal_state.ProposalState.ACCEPTED.name,
type=proposal_type.ProposalType.MODIFICATION.name,
learning_unit_year=generator_container.
generated_container_years[0].learning_unit_year_full,
initial_data=copy_learning_unit_data(
generator_container.generated_container_years[0].
learning_unit_year_full))
consolidate_proposal(proposal)
partim = proposal.learning_unit_year.get_partims_related()
self.assertEqual(proposal.learning_unit_year.acronym,
partim[0].acronym[:-1])
def test_is_eligible_for_cancel_of_proposal_wrong_state(self):
generated_container = GenerateContainer(
start_year=self.academic_yr.year, end_year=self.academic_yr.year)
generated_container_first_year = generated_container.generated_container_years[
0]
an_requirement_entity = generated_container_first_year.requirement_entity_container_year.entity
luy = generated_container_first_year.learning_unit_year_full
a_person = self.create_person_with_permission_and_group(
FACULTY_MANAGER_GROUP, 'can_propose_learningunit')
a_proposal = ProposalLearningUnitFactory(
learning_unit_year=luy,
type=proposal_type.ProposalType.MODIFICATION.name,
state=proposal_state.ProposalState.CENTRAL.name,
initial_data={
"entities": {
entity_container_year_link_type.REQUIREMENT_ENTITY:
an_requirement_entity.id,
}
})
PersonEntityFactory(person=a_person, entity=an_requirement_entity)
self.assertFalse(
perms.is_eligible_for_cancel_of_proposal(a_proposal, a_person))
def setUp(self):
self.current_academic_year = AcademicYearFactory(year=2017)
self.learning_container_luy1 = LearningContainerYearFactory(
academic_year=self.current_academic_year)
self.learning_unit_yr_1 = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_luy1,
credits=50)
self.learning_unit_yr_2 = LearningUnitYearFactory()
self.proposal_creation_1 = ProposalLearningUnitFactory(
state=proposal_state.ProposalState.ACCEPTED.name,
type=proposal_type.ProposalType.CREATION.name,
)
self.proposal_creation_2 = ProposalLearningUnitFactory(
state=proposal_state.ProposalState.ACCEPTED.name,
type=proposal_type.ProposalType.CREATION.name,
)
direct_parent_type = EducationGroupTypeFactory(
name='Bachelor', category=education_group_categories.TRAINING)
self.an_education_group_parent = EducationGroupYearFactory(
academic_year=self.current_academic_year,
education_group_type=direct_parent_type,
acronym=ROOT_ACRONYM)
self.group_element_child = GroupElementYearFactory(
parent=self.an_education_group_parent,
child_branch=None,
child_leaf=self.learning_unit_yr_1)
self.an_education_group = EducationGroupYearFactory(
academic_year=self.current_academic_year,
acronym=PARENT_ACRONYM,
title=PARENT_TITLE,
partial_acronym=PARENT_PARTIAL_ACRONYM)
self.group_element_child2 = GroupElementYearFactory(
parent=self.an_education_group,
child_branch=self.group_element_child.parent,
)
generatorContainer = GenerateContainer(datetime.date.today().year - 2,
datetime.date.today().year)
self.learning_unit_year_with_entities = generatorContainer.generated_container_years[
0].learning_unit_year_full
entities = [
EntityVersionFactory(
start_date=datetime.datetime(1900, 1, 1),
end_date=None,
entity_type=entity_type.FACULTY,
entity__organization__type=organization_type.MAIN)
for _ in range(4)
]
self.learning_unit_year_with_entities.entities = {
'REQUIREMENT_ENTITY': entities[0],
'ALLOCATION_ENTITY': entities[1]
}
self.proposal_creation_3 = ProposalLearningUnitFactory(
learning_unit_year=self.learning_unit_year_with_entities,
state=proposal_state.ProposalState.ACCEPTED.name,
type=proposal_type.ProposalType.CREATION.name,
)
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):
self.start_year = 2010
self.end_year = 2020
self.generated_ac_years = GenerateAcademicYear(self.start_year, self.end_year)
self.generated_container = GenerateContainer(self.start_year, self.end_year)
self.first_learning_unit_year = self.generated_container.generated_container_years[0].learning_unit_year_full
self.learning_unit_with_context = get_with_context(
learning_container_year_id=self.first_learning_unit_year.learning_container_year)[0]
def setUp(self):
current_academic_year = create_current_academic_year()
generated_container = GenerateContainer(start_year=current_academic_year.year,
end_year=current_academic_year.year)
generated_container_first_year = generated_container.generated_container_years[0]
self.luy = generated_container_first_year.learning_unit_year_full
self.language_fr = LanguageFactory(code='FR')
self.language_en = LanguageFactory(code='EN')
def setUp(self):
yr = timezone.now().year
generator_learning_container = GenerateContainer(start_year=yr - 1,
end_year=yr)
self.a_learning_unit_year = generator_learning_container.generated_container_years[
0].learning_unit_year_full
self.entity_1 = generator_learning_container.entities[0]
self.entity_version_1 = EntityVersionFactory(
entity=self.entity_1, acronym=ENTITY_REQUIREMENT_ACRONYM)
def setUp(self):
self.user = UserFactory()
generatorContainer = GenerateContainer(datetime.date.today().year-2, datetime.date.today().year)
self.previous_learning_unit_year = generatorContainer.generated_container_years[0].learning_unit_year_full
self.partim = generatorContainer.generated_container_years[0].learning_unit_year_partim
self.learning_unit_year_1 = generatorContainer.generated_container_years[1].learning_unit_year_full
self.academic_year = self.learning_unit_year_1.academic_year
self.previous_academic_year = self.previous_learning_unit_year.academic_year
def setUpTestData(cls):
cls.initial_language = LanguageFactory(code='FR')
cls.initial_campus = CampusFactory(name='Louvain-la-Neuve', organization__type=organization_type.MAIN)
cls.current_academic_year = create_current_academic_year()
# Creation of a LearningContainerYear and all related models
cls.learn_unit_structure = GenerateContainer(cls.current_academic_year, cls.current_academic_year)
start_year = AcademicYearFactory(year=cls.current_academic_year.year - 3)
end_year = AcademicYearFactory(year=cls.current_academic_year.year + 7)
cls.acs = GenerateAcademicYear(start_year=start_year, end_year=end_year).academic_years
def setUpTestData(cls):
yr = timezone.now().year
cls.start_year = AcademicYearFactory(year=yr - 1)
cls.end_year = AcademicYearFactory(year=yr)
generator_learning_container = GenerateContainer(
start_year=cls.start_year, end_year=cls.end_year)
cls.a_learning_unit_year = generator_learning_container.generated_container_years[
0].learning_unit_year_full
cls.entity_1 = generator_learning_container.entities[0]
cls.entity_version_1 = EntityVersionFactory(
entity=cls.entity_1, acronym=ENTITY_REQUIREMENT_ACRONYM)
def setUp(self):
self.generated_container = GenerateContainer(self.start_year,
self.end_year)
self.luy_full = self.generated_container.generated_container_years[
0].learning_unit_year_full
self.component_full_lecturing = LearningComponentYear.objects.filter(
type=LECTURING, learning_unit_year=self.luy_full).first()
self.luy_full.quadrimester = None
self.luy_full.save()
self.luy_full.get_partims_related().update(quadrimester=None)
def setUpTestData(cls):
cls.start_year = AcademicYearFactory(year=2010)
cls.end_year = AcademicYearFactory(year=2020)
cls.generated_ac_years = GenerateAcademicYear(cls.start_year,
cls.end_year)
cls.generated_container = GenerateContainer(cls.start_year,
cls.end_year)
cls.first_learning_unit_year = cls.generated_container.generated_container_years[
0].learning_unit_year_full
cls.learning_unit_with_context = get_with_context(
learning_container_year_id=cls.first_learning_unit_year.
learning_container_year)[0]
def test_access_edit_learning_unit_proposal_of_current_academic_year_as_faculty_manager(self):
a_person = self.create_person_with_permission_and_group(FACULTY_MANAGER_GROUP)
generated_container = GenerateContainer(start_year=self.academic_yr.year,
end_year=self.academic_yr.year)
generated_container_first_year = generated_container.generated_container_years[0]
luy = generated_container_first_year.learning_unit_year_full
an_requirement_entity = generated_container_first_year.requirement_entity_container_year.entity
PersonEntityFactory(entity=an_requirement_entity, person=a_person)
a_proposal = ProposalLearningUnitFactory(learning_unit_year=luy,
type=proposal_type.ProposalType.MODIFICATION.name,
state=proposal_state.ProposalState.FACULTY.name)
self.assertFalse(perms.is_eligible_to_edit_proposal(a_proposal, a_person))
def setUpTestData(cls):
cls.education_group_year = EducationGroupYearFactory()
cls.child_leaves = GroupElementYearChildLeafFactory.create_batch(
2, parent=cls.education_group_year, is_mandatory=True)
for node, acronym in zip(
cls.child_leaves,
["LCORS124" + str(i) for i in range(0, len(cls.child_leaves))]):
node.child_leaf.acronym = acronym
node.child_leaf.save()
cls.luy_children = [child.child_leaf for child in cls.child_leaves]
cls.workbook_contains = \
EducationGroupYearLearningUnitsContainedToExcel(cls.education_group_year, CustomXlsForm({}))._to_workbook()
cls.sheet_contains = cls.workbook_contains.worksheets[0]
generator_container = GenerateContainer(
cls.education_group_year.academic_year,
cls.education_group_year.academic_year)
cls.luy = generator_container.generated_container_years[
0].learning_unit_year_full
cls.lecturing_component = LecturingLearningComponentYearFactory(
learning_unit_year=cls.luy)
cls.practical_component = PracticalLearningComponentYearFactory(
learning_unit_year=cls.luy)
cls.person_1 = PersonFactory(last_name='Dupont',
first_name="Marcel",
email="*****@*****.**")
cls.person_2 = PersonFactory(last_name='Marseillais',
first_name="Pol",
email="*****@*****.**")
cls.tutor_1 = TutorFactory(person=cls.person_1)
cls.tutor_2 = TutorFactory(person=cls.person_2)
cls.attribution_1 = AttributionNewFactory(
tutor=cls.tutor_1,
learning_container_year=cls.luy.learning_container_year)
cls.charge_lecturing = AttributionChargeNewFactory(
attribution=cls.attribution_1,
learning_component_year=cls.lecturing_component)
cls.charge_practical = AttributionChargeNewFactory(
attribution=cls.attribution_1,
learning_component_year=cls.practical_component)
cls.attribution_2 = AttributionNewFactory(
tutor=cls.tutor_2,
learning_container_year=cls.luy.learning_container_year)
cls.charge_lecturing = AttributionChargeNewFactory(
attribution=cls.attribution_2,
learning_component_year=cls.lecturing_component)
cls.charge_practical = AttributionChargeNewFactory(
attribution=cls.attribution_2,
learning_component_year=cls.practical_component)
cls.gey = GroupElementYearChildLeafFactory(child_leaf=cls.luy)
def test_update_case_correct_data(self):
now = datetime.datetime.now()
learn_unit_structure = GenerateContainer(now.year, now.year)
self.post_data['periodicity'] = ANNUAL
learn_unit_year = LearningUnitYear.objects.get(
learning_unit=learn_unit_structure.learning_unit_full,
academic_year=AcademicYear.objects.get(year=now.year))
form = _instanciate_form(
learn_unit_year.academic_year,
post_data=self.post_data,
person=self.person,
learning_unit_instance=learn_unit_year.learning_unit)
self.assertTrue(form.is_valid(), form.errors)
def setUp(self):
generator_container = GenerateContainer(datetime.date.today().year-2, datetime.date.today().year)
self.learning_unit_yr_1 = generator_container.generated_container_years[0].learning_unit_year_full
self.learning_unit_yr_1.entities = {
entity_container_year_link_type.REQUIREMENT_ENTITY: EntityVersionFactory(acronym=ACRONYM_REQUIREMENT),
entity_container_year_link_type.ALLOCATION_ENTITY: EntityVersionFactory(acronym=ACRONYM_ALLOCATION)
}
component_1 = LearningUnitComponentFactory(learning_unit_year=self.learning_unit_yr_1)
self.attribution_1 = AttributionChargeNewFactory(learning_component_year=component_1.learning_component_year)
self.learning_unit_yr_1.attribution_charge_news = attribution_charge_new. \
find_attribution_charge_new_by_learning_unit_year(self.learning_unit_yr_1)
self.user = UserFactory()
def setUp(self):
self.start_year = 2010
self.end_year = 2020
self.generated_ac_years = GenerateAcademicYear(self.start_year, self.end_year)
self.generated_container = GenerateContainer(self.start_year, self.end_year)
self.luy_full = self.generated_container.generated_container_years[0].learning_unit_year_full
self.learning_component_year_full_lecturing = LearningComponentYear.objects.filter(
type=LECTURING,
learningunitcomponent__learning_unit_year=self.luy_full
).first()
self.entity_component_year_full_lecturing_requirement = EntityComponentYear.objects.get(
learning_component_year=self.learning_component_year_full_lecturing,
entity_container_year__type=REQUIREMENT_ENTITY
)
def test_can_central_manager_modify_end_date_full(self):
a_person = self.create_person_with_permission_and_group(
CENTRAL_MANAGER_GROUP)
generated_container = GenerateContainer(
start_year=self.academic_yr.year, end_year=self.academic_yr.year)
generated_container_first_year = generated_container.generated_container_years[
0]
luy = generated_container_first_year.learning_unit_year_full
requirement_entity = generated_container_first_year.requirement_entity_container_year.entity
PersonEntityFactory(entity=requirement_entity, person=a_person)
for proposal_needed_container_type in ALL_TYPES:
self.lunit_container_yr.container_type = proposal_needed_container_type
self.lunit_container_yr.save()
self.assertTrue(
perms.is_eligible_for_modification_end_date(luy, a_person))
def test_access_edit_learning_unit_proposal_as_faculty_manager(self):
generated_container = GenerateContainer(start_year=self.academic_yr_1,
end_year=self.academic_yr_1)
generated_container_first_year = generated_container.generated_container_years[
0]
an_requirement_entity = generated_container_first_year.requirement_entity_container_year
luy = generated_container_first_year.learning_unit_year_full
faculty_managers = [
create_person_with_permission_and_group(FACULTY_MANAGER_GROUP),
create_person_with_permission_and_group(UE_FACULTY_MANAGER_GROUP)
]
a_proposal = ProposalLearningUnitFactory(
state=proposal_state.ProposalState.CENTRAL.name,
type=proposal_type.ProposalType.SUPPRESSION.name,
learning_unit_year=luy)
generate_modification_transformation_proposal_calendars([
self.academic_yr, self.academic_yr_1, self.academic_yr_2,
self.academic_yr_6
])
for manager in faculty_managers:
a_proposal.state = proposal_state.ProposalState.CENTRAL.name
a_proposal.save()
PersonEntityFactory(entity=an_requirement_entity, person=manager)
self.assertFalse(perms.is_eligible_to_edit_proposal(None, manager))
self.assertFalse(
perms.is_eligible_to_edit_proposal(a_proposal, manager))
a_proposal.state = proposal_state.ProposalState.FACULTY.name
a_proposal.save()
self.assertTrue(
perms.is_eligible_to_edit_proposal(a_proposal, manager))
for tag in ProposalType.choices():
a_proposal.type = tag[0]
a_proposal.save()
if a_proposal.type != ProposalType.MODIFICATION:
self.assertTrue(
perms.is_eligible_to_edit_proposal(
a_proposal, manager))
else:
self.assertFalse(
perms.is_eligible_to_edit_proposal(
a_proposal, manager))
def setUp(self):
self.academic_years = GenerateAcademicYear(
CRUCIAL_YEAR_FOR_CREDITS_VALIDATION - 1,
CRUCIAL_YEAR_FOR_CREDITS_VALIDATION + 1).academic_years
self.learn_unit_structure = GenerateContainer(
self.academic_years[0].year, self.academic_years[2].year)
self.learning_unit_year_2017 = LearningUnitYear.objects.get(
learning_unit=self.learn_unit_structure.learning_unit_full,
academic_year=self.academic_years[0])
self.learning_unit_year_2018 = LearningUnitYear.objects.get(
learning_unit=self.learn_unit_structure.learning_unit_full,
academic_year=self.academic_years[1])
self.learning_unit_year_2019 = LearningUnitYear.objects.get(
learning_unit=self.learn_unit_structure.learning_unit_full,
academic_year=self.academic_years[2])
self.person = PersonFactory()
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 test_access_edit_learning_unit_proposal_as_central_manager(self):
a_person = self.create_person_with_permission_and_group(
CENTRAL_MANAGER_GROUP)
generated_container = GenerateContainer(
start_year=self.academic_yr.year, end_year=self.academic_yr.year)
generated_container_first_year = generated_container.generated_container_years[
0]
luy = generated_container_first_year.learning_unit_year_full
requirement_entity = generated_container_first_year.requirement_entity_container_year.entity
PersonEntityFactory(entity=requirement_entity, person=a_person)
self.assertFalse(perms.is_eligible_to_edit_proposal(None, a_person))
a_proposal = ProposalLearningUnitFactory(learning_unit_year=luy)
self.assertTrue(
perms.is_eligible_to_edit_proposal(a_proposal, a_person))
def setUpTestData(cls):
cls.user = UserFactory()
cls.old_academic_year = AcademicYearFactory(
year=datetime.date.today().year - 2)
cls.current_academic_year = AcademicYearFactory(
year=datetime.date.today().year)
generatorContainer = GenerateContainer(cls.old_academic_year,
cls.current_academic_year)
cls.previous_learning_unit_year = generatorContainer.generated_container_years[
0].learning_unit_year_full
cls.partim = generatorContainer.generated_container_years[
0].learning_unit_year_partim
cls.learning_unit_year_1 = generatorContainer.generated_container_years[
1].learning_unit_year_full
cls.academic_year = cls.learning_unit_year_1.academic_year
cls.previous_academic_year = cls.previous_learning_unit_year.academic_year
def setUp(self):
self.start_year = 2010
self.end_year = 2020
self.generated_ac_years = GenerateAcademicYear(self.start_year, self.end_year)
self.generated_container = GenerateContainer(self.start_year, self.end_year)
self.generated_container_year = self.generated_container.generated_container_years[0]
self.learning_container_year = self.generated_container.generated_container_years[0].learning_container_year
self.learning_units_with_context = get_with_context(
learning_container_year_id=self.learning_container_year)
self.learning_unit_year_full = self.generated_container_year.learning_unit_year_full
self.learning_unit_year_partim = self.generated_container_year.learning_unit_year_partim
self.central_manager = PersonFactory()
self.central_manager.user.groups.add(Group.objects.get(name=CENTRAL_MANAGER_GROUP))
self.faculty_manager = PersonFactory()
self.faculty_manager.user.groups.add(Group.objects.get(name=FACULTY_MANAGER_GROUP))
def test_is_eligible_for_cancel_of_proposal_for_creation(self):
generated_container = GenerateContainer(start_year=self.academic_yr.year,
end_year=self.academic_yr.year)
generated_container_first_year = generated_container.generated_container_years[0]
an_requirement_entity = generated_container_first_year.requirement_entity_container_year.entity
luy = generated_container_first_year.learning_unit_year_full
a_person = self.create_person_with_permission_and_group(FACULTY_MANAGER_GROUP,
'can_propose_learningunit')
a_proposal = ProposalLearningUnitFactory(learning_unit_year=luy,
type=proposal_type.ProposalType.CREATION.name,
state=proposal_state.ProposalState.FACULTY.name)
PersonEntityFactory(person=a_person, entity=an_requirement_entity)
self.assertTrue(perms.is_eligible_for_cancel_of_proposal(a_proposal, a_person))
def test_access_edit_learning_unit_proposal_as_faculty_manager(self):
generated_container = GenerateContainer(
start_year=self.academic_yr_1.year,
end_year=self.academic_yr_1.year)
generated_container_first_year = generated_container.generated_container_years[
0]
an_requirement_entity = generated_container_first_year.requirement_entity_container_year.entity
luy = generated_container_first_year.learning_unit_year_full
a_person = self.create_person_with_permission_and_group(
FACULTY_MANAGER_GROUP)
self.assertFalse(perms.is_eligible_to_edit_proposal(None, a_person))
a_proposal = ProposalLearningUnitFactory(
state=proposal_state.ProposalState.CENTRAL.name,
type=proposal_type.ProposalType.SUPPRESSION.name,
learning_unit_year=luy)
self.assertFalse(
perms.is_eligible_to_edit_proposal(a_proposal, a_person))
PersonEntityFactory(entity=an_requirement_entity, person=a_person)
self.assertFalse(
perms.is_eligible_to_edit_proposal(a_proposal, a_person))
a_proposal.state = proposal_state.ProposalState.CENTRAL.name
a_proposal.save()
self.assertFalse(
perms.is_eligible_to_edit_proposal(a_proposal, a_person))
a_proposal.state = proposal_state.ProposalState.FACULTY.name
a_proposal.save()
self.assertTrue(
perms.is_eligible_to_edit_proposal(a_proposal, a_person))
for a_type, _ in proposal_type.CHOICES:
a_proposal.type = a_type
a_proposal.save()
if a_proposal.type != ProposalType.MODIFICATION:
self.assertTrue(
perms.is_eligible_to_edit_proposal(a_proposal, a_person))
else:
self.assertFalse(
perms.is_eligible_to_edit_proposal(a_proposal, a_person))