class TestIsEligibleToCreateModificationProposal(TestCase):
@classmethod
def setUpTestData(cls):
cls.current_academic_year = create_current_academic_year()
cls.past_academic_year = AcademicYearFactory(
start_date=cls.current_academic_year.start_date -
datetime.timedelta(days=365),
end_date=cls.current_academic_year.end_date -
datetime.timedelta(days=365),
year=cls.current_academic_year.year - 1)
cls.person = PersonFactory()
def setUp(self):
self.luy = LearningUnitYearFakerFactory(
learning_container_year__academic_year=self.current_academic_year,
learning_container_year__container_type=COURSE,
subtype=FULL)
self.entity_container_year = EntityContainerYearFactory(
learning_container_year=self.luy.learning_container_year,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
self.person_entity = PersonEntityFactory(
person=self.person, entity=self.entity_container_year.entity)
def test_cannot_propose_modification_of_past_learning_unit(self):
past_luy = LearningUnitYearFakerFactory(
learning_container_year__academic_year=self.past_academic_year)
self.assertFalse(
is_eligible_to_create_modification_proposal(past_luy, self.person))
def test_cannot_propose_modification_of_partim(self):
self.luy.subtype = PARTIM
self.luy.save()
self.assertFalse(
is_eligible_to_create_modification_proposal(self.luy, self.person))
def test_can_only_propose_modification_for_course_internship_and_dissertation(
self):
other_types = (OTHER_COLLECTIVE, OTHER_INDIVIDUAL, MASTER_THESIS,
EXTERNAL)
for luy_container_type in other_types:
with self.subTest(luy_container_type=luy_container_type):
self.luy.learning_container_year.container_type = luy_container_type
self.luy.learning_container_year.save()
self.assertFalse(
is_eligible_to_create_modification_proposal(
self.luy, self.person))
def test_can_only_propose_modification_for_luy_which_is_not_currently_in_proposition(
self):
ProposalLearningUnitFactory(learning_unit_year=self.luy)
self.assertFalse(
is_eligible_to_create_modification_proposal(self.luy, self.person))
def test_can_only_propose_modification_for_lu_which_is_not_in_proposition_on_different_year(
self):
past_luy_with_proposal = LearningUnitYearFakerFactory(
learning_container_year__academic_year=self.past_academic_year,
learning_unit=self.luy.learning_unit)
ProposalLearningUnitFactory(learning_unit_year=past_luy_with_proposal)
self.assertFalse(
is_eligible_to_create_modification_proposal(self.luy, self.person))
def test_cannot_propose_modification_for_luy_for_which_person_is_not_linked_to_entity(
self):
self.person_entity.delete()
self.assertFalse(
is_eligible_to_create_modification_proposal(self.luy, self.person))
def test_all_requirements_are_met_to_propose_modification(self):
for luy_container_type in FACULTY_UPDATABLE_CONTAINER_TYPES:
with self.subTest(luy_container_type=luy_container_type):
self.luy.learning_container_year.container_type = luy_container_type
self.luy.learning_container_year.save()
self.assertTrue(
is_eligible_to_create_modification_proposal(
self.luy, self.person))
class TestLearningAchievementView(TestCase):
def setUp(self):
self.language_fr = LanguageFactory(code="FR")
self.user = UserFactory()
self.person = PersonFactory(user=self.user)
self.person_entity = PersonEntityFactory(person=self.person)
self.academic_year = create_current_academic_year()
self.learning_unit_year = LearningUnitYearFactory(
academic_year=self.academic_year,
subtype=learning_unit_year_subtypes.FULL,
learning_container_year__requirement_entity=self.person_entity.
entity,
)
self.client.force_login(self.user)
self.achievement_fr = LearningAchievementFactory(
language=self.language_fr,
learning_unit_year=self.learning_unit_year,
order=0)
self.reverse_learning_unit_yr = reverse(
'learning_unit', args=[self.learning_unit_year.id])
flag, created = Flag.objects.get_or_create(
name='learning_achievement_update')
flag.users.add(self.user)
def test_operation_method_not_allowed(self):
request_factory = RequestFactory()
request = request_factory.post(
reverse('achievement_management',
args=[self.achievement_fr.learning_unit_year.id]),
data={
'achievement_id': self.achievement_fr.id,
'action': DELETE
})
request.user = self.user
with self.assertRaises(PermissionDenied):
management(request, self.achievement_fr.learning_unit_year.id)
def test_delete_redirection(self):
request_factory = RequestFactory()
request = request_factory.post(
reverse('achievement_management',
args=[self.achievement_fr.learning_unit_year.id]),
data={
'achievement_id': self.achievement_fr.id,
'action': DELETE
})
self.user.user_permissions.add(
Permission.objects.get(codename="can_access_learningunit"))
self.user.user_permissions.add(
Permission.objects.get(codename="can_create_learningunit"))
request.user = self.user
response = management(request,
self.achievement_fr.learning_unit_year.id)
self.assertEqual(response.status_code, 302)
self.assertEqual(
response.url, "/learning_units/{}/specifications/".format(
self.achievement_fr.learning_unit_year.id))
def test_delete_permission_denied(self):
self.person_entity.delete()
request_factory = RequestFactory()
request = request_factory.post(
reverse('achievement_management',
args=[self.achievement_fr.learning_unit_year.id]),
data={
'achievement_id': self.achievement_fr.id,
'action': DELETE
})
self.user.user_permissions.add(
Permission.objects.get(codename="can_access_learningunit"))
self.user.user_permissions.add(
Permission.objects.get(codename="can_create_learningunit"))
request.user = self.user
with self.assertRaises(PermissionDenied):
management(request, self.achievement_fr.learning_unit_year.id)
def test_create_not_allowed(self):
request_factory = RequestFactory()
request = request_factory.get(self.reverse_learning_unit_yr)
request.user = self.user
with self.assertRaises(PermissionDenied):
create(request, self.learning_unit_year.id, self.achievement_fr.id)
request = request_factory.post(self.reverse_learning_unit_yr)
request.user = self.user
with self.assertRaises(PermissionDenied):
create(request, self.learning_unit_year.id, self.achievement_fr.id)
def test_create_first_not_allowed(self):
request_factory = RequestFactory()
request = request_factory.get(self.reverse_learning_unit_yr)
request.user = self.user
with self.assertRaises(PermissionDenied):
create_first(request, self.learning_unit_year.id)
request = request_factory.post(self.reverse_learning_unit_yr)
request.user = self.user
with self.assertRaises(PermissionDenied):
create_first(request, self.learning_unit_year.id)
class TestLearningUnitModificationProposal(TestCase):
def setUp(self):
today = datetime.date.today()
self.person = PersonFactory()
an_organization = OrganizationFactory(type=organization_type.MAIN)
self.learning_unit_year = LearningUnitYearFakerFactory(acronym="LOSIS1212",
subtype=learning_unit_year_subtypes.FULL)
self.learning_unit_year.academic_year.start_date = today - datetime.timedelta(days=15)
self.learning_unit_year.academic_year.end_date = today + datetime.timedelta(days=15)
self.learning_unit_year.academic_year.year = today.year
self.learning_unit_year.academic_year.save()
self.learning_unit_year.learning_container_year.container_type = learning_container_year_types.COURSE
self.learning_unit_year.learning_container_year.save()
self.learning_unit_year.learning_container_year.campus.organization = an_organization
self.learning_unit_year.learning_container_year.campus.is_administration = True
self.learning_unit_year.learning_container_year.campus.save()
an_entity = EntityFactory(organization=an_organization)
self.entity_version = EntityVersionFactory(entity=an_entity, entity_type=entity_type.SCHOOL,
start_date=today - datetime.timedelta(days=25),
end_date=today.replace(year=today.year + 1))
self.requirement_entity = EntityContainerYearFactory(
learning_container_year=self.learning_unit_year.learning_container_year,
entity=self.entity_version.entity,
type=entity_container_year_link_type.REQUIREMENT_ENTITY
)
self.allocation_entity = EntityContainerYearFactory(
learning_container_year=self.learning_unit_year.learning_container_year,
entity=self.entity_version.entity,
type=entity_container_year_link_type.ALLOCATION_ENTITY
)
self.additional_entity_1= EntityContainerYearFactory(
learning_container_year=self.learning_unit_year.learning_container_year,
entity=self.entity_version.entity,
type=entity_container_year_link_type.ADDITIONAL_REQUIREMENT_ENTITY_1
)
self.additional_entity_2 = EntityContainerYearFactory(
learning_container_year=self.learning_unit_year.learning_container_year,
entity=self.entity_version.entity,
type=entity_container_year_link_type.ADDITIONAL_REQUIREMENT_ENTITY_2
)
self.person_entity = PersonEntityFactory(person=self.person, entity=an_entity, with_child=True)
self.client.force_login(self.person.user)
self.url = reverse('learning_unit_modification_proposal', args=[self.learning_unit_year.id])
self.form_data = {
"academic_year": self.learning_unit_year.academic_year.id,
"first_letter": self.learning_unit_year.acronym[0],
"acronym": self.learning_unit_year.acronym[1:],
"title": self.learning_unit_year.title,
"title_english": self.learning_unit_year.title_english,
"container_type": self.learning_unit_year.learning_container_year.container_type,
"internship_subtype": "",
"credits": self.learning_unit_year.credits,
"periodicity": self.learning_unit_year.learning_unit.periodicity,
"status": self.learning_unit_year.status,
"language": self.learning_unit_year.learning_container_year.language.id,
"quadrimester": "",
"campus": self.learning_unit_year.learning_container_year.campus.id,
"requirement_entity": self.entity_version.id,
"allocation_entity": self.entity_version.id,
"additional_entity_1": self.entity_version.id,
"additional_entity_2": self.entity_version.id,
"folder_entity": self.entity_version.id,
"folder_id": "1",
}
def test_user_not_logged(self):
self.client.logout()
response = self.client.get(self.url)
self.assertRedirects(response, '/login/?next={}'.format(self.url))
def test_with_non_existent_learning_unit_year(self):
self.learning_unit_year.delete()
response = self.client.get(self.url)
self.assertEqual(response.status_code, HttpResponseNotFound.status_code)
self.assertTemplateUsed(response, "page_not_found.html")
def test_with_none_person(self):
self.person.delete()
response = self.client.get(self.url)
self.assertEqual(response.status_code, HttpResponseNotFound.status_code)
self.assertTemplateUsed(response, "page_not_found.html")
def test_get_request(self):
response = self.client.get(self.url)
self.assertEqual(response.status_code, HttpResponse.status_code)
self.assertTemplateUsed(response, 'proposal/learning_unit_modification.html')
self.assertEqual(response.context['learning_unit_year'], self.learning_unit_year)
self.assertEqual(response.context['experimental_phase'], True)
self.assertEqual(response.context['person'], self.person)
self.assertIsInstance(response.context['form'], LearningUnitProposalModificationForm)
form_initial = response.context['form'].initial
self.assertEqual(form_initial['academic_year'], self.learning_unit_year.academic_year.pk)
self.assertEqual(form_initial['first_letter'], self.learning_unit_year.acronym[0])
self.assertEqual(form_initial['acronym'], self.learning_unit_year.acronym[1:])
self.assertEqual(form_initial['title'], self.learning_unit_year.title)
self.assertEqual(form_initial['container_type'], self.learning_unit_year.
learning_container_year.container_type)
self.assertEqual(form_initial['subtype'], self.learning_unit_year.subtype)
self.assertEqual(form_initial['credits'], self.learning_unit_year.credits)
self.assertEqual(form_initial['periodicity'], self.learning_unit_year.learning_unit.periodicity)
self.assertEqual(form_initial['status'], self.learning_unit_year.status)
self.assertEqual(form_initial['language'], self.learning_unit_year.learning_container_year.language)
self.assertEqual(form_initial['requirement_entity'], self.entity_version)
self.assertEqual(form_initial['allocation_entity'], self.entity_version)
self.assertEqual(form_initial['additional_entity_1'], self.entity_version)
self.assertEqual(form_initial['additional_entity_2'], self.entity_version)
self.assertEqual(form_initial['campus'], self.learning_unit_year.learning_container_year.campus)
def test_post_request_with_invalid_form(self):
response = self.client.post(self.url, data={})
self.assertEqual(response.status_code, HttpResponse.status_code)
self.assertTemplateUsed(response, 'proposal/learning_unit_modification.html')
self.assertEqual(response.context['learning_unit_year'], self.learning_unit_year)
self.assertEqual(response.context['experimental_phase'], True)
self.assertEqual(response.context['person'], self.person)
self.assertIsInstance(response.context['form'], LearningUnitProposalModificationForm)
def test_post_request(self):
response = self.client.post(self.url, data=self.form_data)
redirected_url = reverse('learning_unit', args=[self.learning_unit_year.id])
self.assertRedirects(response, redirected_url, fetch_redirect_response=False)
folder = proposal_folder.find_by_entity_and_folder_id(self.entity_version.entity, 1)
a_proposal_learning_unit = proposal_learning_unit.find_by_learning_unit_year(self.learning_unit_year)
self.assertTrue(folder)
self.assertTrue(a_proposal_learning_unit)
self.assertEqual(a_proposal_learning_unit.author, self.person)
messages = [str(message) for message in get_messages(response.wsgi_request)]
self.assertIn(_("success_modification_proposal").format(proposal_type.ProposalType.MODIFICATION.name,
self.learning_unit_year.acronym),
list(messages))
def test_transformation_proposal_request(self):
self.form_data["acronym"] = "OSIS1452"
self.client.post(self.url, data=self.form_data)
a_proposal_learning_unit = proposal_learning_unit.find_by_learning_unit_year(self.learning_unit_year)
self.assertEqual(a_proposal_learning_unit.type, proposal_type.ProposalType.TRANSFORMATION.name)
def test_modification_proposal_request(self):
self.form_data["title"] = "New title"
self.form_data["title_english"] = "New english title"
self.client.post(self.url, data=self.form_data)
a_proposal_learning_unit = proposal_learning_unit.find_by_learning_unit_year(self.learning_unit_year)
self.assertEqual(a_proposal_learning_unit.type, proposal_type.ProposalType.MODIFICATION.name)
def test_transformation_and_modification_proposal_request(self):
self.form_data["acronym"] = "OSIS1452"
self.form_data["title"] = "New title"
self.form_data["title_english"] = "New english title"
self.client.post(self.url, data=self.form_data)
a_proposal_learning_unit = proposal_learning_unit.find_by_learning_unit_year(self.learning_unit_year)
self.assertEqual(a_proposal_learning_unit.type, proposal_type.ProposalType.TRANSFORMATION_AND_MODIFICATION.name)
def test_learning_unit_must_be_full(self):
self.learning_unit_year.subtype = learning_unit_year_subtypes.PARTIM
self.learning_unit_year.save()
response = self.client.get(self.url)
self.assertEqual(response.status_code, HttpResponseForbidden.status_code)
self.assertTemplateUsed(response, "access_denied.html")
def test_proposal_already_exists(self):
ProposalLearningUnitFactory(learning_unit_year=self.learning_unit_year)
response = self.client.get(self.url)
self.assertEqual(response.status_code, HttpResponseForbidden.status_code)
self.assertTemplateUsed(response, "access_denied.html")
def test_academic_year_inferior_to_current(self):
today = datetime.date.today()
self.learning_unit_year.academic_year = \
AcademicYearFakerFactory(year=today.year-1, start_date=today.replace(day=1, year=today.year-1),
end_date=today.replace(day=20, year=today.year-1))
self.learning_unit_year.save()
response = self.client.get(self.url)
self.assertEqual(response.status_code, HttpResponseForbidden.status_code)
self.assertTemplateUsed(response, "access_denied.html")
def test_not_linked_to_entity(self):
self.person_entity.delete()
response = self.client.get(self.url)
self.assertEqual(response.status_code, HttpResponseForbidden.status_code)
self.assertTemplateUsed(response, "access_denied.html")
def test_not_linked_to_requirement_entity(self):
today = datetime.date.today()
an_entity = EntityFactory(organization=OrganizationFactory(type=organization_type.MAIN))
an_entity_version = EntityVersionFactory(entity=an_entity, entity_type=entity_type.SCHOOL,
start_date=today - datetime.timedelta(days=25),
end_date=today.replace(year=today.year + 1))
self.requirement_entity.entity = an_entity_version.entity
self.requirement_entity.save()
response = self.client.get(self.url)
self.assertEqual(response.status_code, HttpResponseForbidden.status_code)
self.assertTemplateUsed(response, "access_denied.html")
def test_linked_to_parent_entity(self):
today = datetime.date.today()
parent_entity = EntityFactory(organization=OrganizationFactory(type=organization_type.MAIN))
EntityVersionFactory(entity=parent_entity, entity_type=entity_type.SCHOOL,
start_date=today - datetime.timedelta(days=25),
end_date=today.replace(year=today.year + 1))
self.entity_version.parent = parent_entity
self.entity_version.save()
self.person_entity.entity = parent_entity
self.person_entity.save()
response = self.client.get(self.url)
self.assertEqual(response.status_code, HttpResponse.status_code)
self.assertTemplateUsed(response, 'proposal/learning_unit_modification.html')
def test_linked_to_child_entity(self):
today = datetime.date.today()
child_entity = EntityFactory(organization=OrganizationFactory(type=organization_type.MAIN))
EntityVersionFactory(entity=child_entity, entity_type=entity_type.SCHOOL,
start_date=today - datetime.timedelta(days=25),
end_date=today.replace(year=today.year + 1),
parent=self.entity_version.entity)
self.person_entity.entity = child_entity
self.person_entity.save()
response = self.client.get(self.url)
self.assertEqual(response.status_code, HttpResponseForbidden.status_code)
self.assertTemplateUsed(response, "access_denied.html")