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 test_get_learning_unit_volumes_management(self, mock_program_manager,
mock_render):
mock_program_manager.return_value = True
learning_unit_year = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_yr)
learning_unit_year.save()
request_factory = RequestFactory()
url = reverse("learning_unit_volumes_management",
args=[learning_unit_year.id])
# GET request
request = request_factory.get(url)
request.user = self.a_superuser
from base.views.learning_unit import learning_unit_volumes_management
learning_unit_volumes_management(request, learning_unit_year.id)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_unit/volumes_management.html')
self.assertEqual(context['tab_active'], 'components')
# POST request
request = request_factory.post(
url, self._get_volumes_data([learning_unit_year]))
request.user = mock.Mock()
learning_unit_volumes_management(request, learning_unit_year.id)
self.assertTrue(mock_render.called)
def test_li_edit_date_person_test_is_eligible_to_modify_end_date_based_on_container_type(
self):
lu = LearningUnitFactory(existing_proposal_in_epc=False)
learning_unit_year_without_proposal = LearningUnitYearFactory(
academic_year=self.academic_year,
subtype=learning_unit_year_subtypes.FULL,
learning_unit=lu,
learning_container_year=self.lcy)
person_faculty_manager = FacultyManagerFactory()
PersonEntityFactory(person=person_faculty_manager,
entity=self.entity_container_yr.entity)
self.context['user'] = person_faculty_manager.user
self.context[
'learning_unit_year'] = learning_unit_year_without_proposal
result = li_edit_date_lu(self.context, self.url_edit, "")
self.assertEqual(
result,
self._get_result_data_expected(ID_LINK_EDIT_DATE_LU,
MSG_NO_ELIGIBLE_TO_MODIFY_END_DATE))
# allowed if _is_person_central_manager or
# _is_learning_unit_year_a_partim or
# negation(_is_container_type_course_dissertation_or_internship),
# test 1st condition true
self.context['user'] = self.central_manager_person.user
result = li_edit_date_lu(self.context, self.url_edit, "")
self.assertEqual(
result,
self._get_result_data_expected(ID_LINK_EDIT_DATE_LU,
url=self.url_edit))
# test 2nd condition true
self.context['user'] = person_faculty_manager.user
learning_unit_year_without_proposal.subtype = learning_unit_year_subtypes.PARTIM
learning_unit_year_without_proposal.save()
self.context[
'learning_unit_year'] = learning_unit_year_without_proposal
self.assertEqual(
li_edit_date_lu(self.context, self.url_edit, ""),
self._get_result_data_expected(ID_LINK_EDIT_DATE_LU,
url=self.url_edit))
# test 3rd condition true
learning_unit_year_without_proposal.learning_container_year.container_type = learning_container_year_types.OTHER_COLLECTIVE
learning_unit_year_without_proposal.learning_container_year.save()
learning_unit_year_without_proposal.subtype = learning_unit_year_subtypes.FULL
learning_unit_year_without_proposal.save()
self.context[
'learning_unit_year'] = learning_unit_year_without_proposal
self.assertEqual(
li_edit_date_lu(self.context, self.url_edit, ""),
self._get_result_data_expected(ID_LINK_EDIT_DATE_LU,
url=self.url_edit))
def test_can_delete_learning_unit_year_with_faculty_manager_role(self):
# Faculty manager can only delete other type than COURSE/INTERNSHIP/DISSERTATION
managers = [
create_person_with_permission_and_group(FACULTY_MANAGER_GROUP, 'can_delete_learningunit'),
create_person_with_permission_and_group(UE_FACULTY_MANAGER_GROUP, 'can_delete_learningunit')
]
entity_version = EntityVersionFactory(entity_type=entity_type.FACULTY, acronym="SST",
start_date=datetime.date(year=1990, month=1, day=1),
end_date=None)
for manager in managers:
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.assertTrue(
base.business.learning_units.perms.is_eligible_to_delete_learning_unit_year(
learning_unit_year,
manager
)
)
# Invalidate cache_property
del manager.is_central_manager
del manager.is_faculty_manager
# With both role, greatest is taken
add_to_group(manager.user, CENTRAL_MANAGER_GROUP)
learning_unit_year.subtype = learning_unit_year_subtypes.FULL
learning_unit_year.save()
self.assertTrue(
base.business.learning_units.perms.is_eligible_to_delete_learning_unit_year(
learning_unit_year,
manager
)
)
def test_find_first_by_exact_acronym(self):
a_learning_unit = LearningUnitFactory()
ldroi1000_learning_unit_year = LearningUnitYearFactory(academic_year=self.an_academic_year,
learning_unit=a_learning_unit, acronym='LDROI1000')
ldroi1000_learning_unit_year.save()
ldroi1000_learning_unit_year_bis = LearningUnitYearFactory(academic_year=self.an_academic_year,
learning_unit=a_learning_unit, acronym='LDROI1000')
ldroi1000_learning_unit_year_bis.save()
self.assertEqual(mdl_base.learning_unit_year.find_first_by_exact_acronym(self.an_academic_year, 'LDROI1000'),
ldroi1000_learning_unit_year)
def test_can_delete_learning_unit_year_with_faculty_manager_role(self):
# Faculty manager can only delete other type than COURSE/INTERNSHIP/DISSERTATION
person = PersonFactory()
add_to_group(person.user, FACULTY_MANAGER_GROUP)
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=person,
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)
EntityContainerYearFactory(
learning_container_year=l_containeryear,
entity=entity_version.entity,
type=entity_container_year_link_type.REQUIREMENT_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,
person))
# Can remove PARTIM COURSE
learning_unit_year.subtype = learning_unit_year_subtypes.PARTIM
learning_unit_year.save()
self.assertTrue(
base.business.learning_units.perms.
is_eligible_to_delete_learning_unit_year(learning_unit_year,
person))
# Invalidate cache_property
del person.is_central_manager
del person.is_faculty_manager
# With both role, greatest is taken
add_to_group(person.user, CENTRAL_MANAGER_GROUP)
learning_unit_year.subtype = learning_unit_year_subtypes.FULL
learning_unit_year.save()
self.assertTrue(
base.business.learning_units.perms.
is_eligible_to_delete_learning_unit_year(learning_unit_year,
person))
def test_learning_unit_check_acronym(self):
learning_unit_container_year = LearningContainerYearFactory(
academic_year=self.academic_years[0])
learning_unit_year = LearningUnitYearFactory(
acronym="LCHIM1210",
learning_container_year=learning_unit_container_year,
subtype=learning_unit_year_subtypes.FULL,
academic_year=self.academic_years[0])
learning_unit_year.save()
get_data = {
'acronym': 'LCHIM1210',
'year_id': self.academic_years[0].id
}
response = self.client.get(self.url, get_data, **KWARGS)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(
str(response.content, encoding='utf8'), {
'valid': True,
'existing_acronym': True,
'existed_acronym': False,
'first_using': str(self.academic_years[0]),
'last_using': ""
})
learning_unit_year = LearningUnitYearFactory(
acronym="LCHIM1211",
learning_container_year=learning_unit_container_year,
subtype=learning_unit_year_subtypes.FULL,
academic_year=self.academic_years[0])
learning_unit_year.save()
get_data = {
'acronym': 'LCHIM1211',
'year_id': self.academic_years[6].id
}
response = self.client.get(self.url, get_data, **KWARGS)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(
str(response.content, encoding='utf8'), {
'valid': True,
'existing_acronym': False,
'existed_acronym': True,
'first_using': "",
'last_using': str(self.academic_years[0])
})
def test_volumes_validation(self):
learning_unit_year = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_yr)
learning_unit_year.save()
kwargs = {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
url = reverse("volumes_validation", args=[learning_unit_year.id])
data = self._get_volumes_data(learning_unit_year)
# TODO inject wrong data
response = self.client.get(url, data, **kwargs)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(str(response.content, encoding='utf8'), {
'errors': [],
})
class LearningUnitYearFindLearningUnitYearByAcademicYearTutorAttributionsTest(
TestCase):
def setUp(self):
self.current_academic_year = create_current_academic_year()
self.learning_unit_year = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year__academic_year=self.current_academic_year,
)
self.tutor = TutorFactory()
AttributionFactory(learning_unit_year=self.learning_unit_year,
tutor=self.tutor)
def test_find_learning_unit_years_by_academic_year_tutor_attributions_case_occurrence_found(
self):
result = find_learning_unit_years_by_academic_year_tutor_attributions(
academic_year=self.current_academic_year, tutor=self.tutor)
self.assertIsInstance(result, QuerySet)
self.assertEqual(result.count(), 1)
def test_find_learning_unit_years_by_academic_year_tutor_attributions_case_distinct_occurrence_found(
self):
"""In this test, we ensure that user see one line per learning unit year despite multiple attribution"""
AttributionFactory(learning_unit_year=self.learning_unit_year,
tutor=self.tutor,
function=COORDINATOR)
AttributionFactory(learning_unit_year=self.learning_unit_year,
tutor=self.tutor,
function=CO_HOLDER)
AttributionFactory(learning_unit_year=self.learning_unit_year,
tutor=self.tutor)
result = find_learning_unit_years_by_academic_year_tutor_attributions(
academic_year=self.current_academic_year, tutor=self.tutor)
self.assertIsInstance(result, QuerySet)
self.assertEqual(result.count(), 1)
def test_find_learning_unit_years_by_academic_year_tutor_attributions_case_no_occurrence_found(
self):
"""In this test, we ensure that if the learning unit year as no learning container, it is not taking account"""
self.learning_unit_year.learning_container_year = None
self.learning_unit_year.save()
result = find_learning_unit_years_by_academic_year_tutor_attributions(
academic_year=self.current_academic_year, tutor=self.tutor)
self.assertIsInstance(result, QuerySet)
self.assertFalse(result.count())
class LearningUnitYearGetEntityTest(TestCase):
def setUp(self):
self.learning_unit_year = LearningUnitYearFactory()
self.requirement_entity = EntityContainerYearFactory(
type=entity_container_year_link_type.REQUIREMENT_ENTITY,
learning_container_year=self.learning_unit_year.
learning_container_year)
def test_get_entity_case_found_entity_type(self):
result = self.learning_unit_year.get_entity(
entity_type=entity_container_year_link_type.REQUIREMENT_ENTITY)
self.assertEqual(result, self.requirement_entity.entity)
def test_get_entity_case_no_learning_container_year(self):
self.learning_unit_year.learning_container_year = None
self.learning_unit_year.save()
result = self.learning_unit_year.get_entity(
entity_type=entity_container_year_link_type.REQUIREMENT_ENTITY)
self.assertIsNone(result)
def test_learning_unit_check_acronym(self):
kwargs = {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
url = reverse('check_acronym', kwargs={'subtype': FULL})
get_data = {'acronym': 'goodacronym', 'year_id': self.academic_years[0].id}
response = self.client.get(url, get_data, **kwargs)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(
str(response.content, encoding='utf8'),
{'valid': False,
'existing_acronym': False,
'existed_acronym': False,
'first_using': "",
'last_using': ""}
)
learning_unit_container_year = LearningContainerYearFactory(
academic_year=self.academic_years[0]
)
learning_unit_year = LearningUnitYearFactory(
acronym="LCHIM1210",
learning_container_year=learning_unit_container_year,
subtype=learning_unit_year_subtypes.FULL,
academic_year=self.academic_years[0]
)
learning_unit_year.save()
get_data = {'acronym': 'LCHIM1210', 'year_id': self.academic_years[0].id}
response = self.client.get(url, get_data, **kwargs)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(
str(response.content, encoding='utf8'),
{'valid': True,
'existing_acronym': True,
'existed_acronym': False,
'first_using': str(self.academic_years[0]),
'last_using': ""}
)
learning_unit_year = LearningUnitYearFactory(
acronym="LCHIM1211",
learning_container_year=learning_unit_container_year,
subtype=learning_unit_year_subtypes.FULL,
academic_year=self.academic_years[0]
)
learning_unit_year.save()
get_data = {'acronym': 'LCHIM1211', 'year_id': self.academic_years[6].id}
response = self.client.get(url, get_data, **kwargs)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(
str(response.content, encoding='utf8'),
{'valid': True,
'existing_acronym': False,
'existed_acronym': True,
'first_using': "",
'last_using': str(self.academic_years[0])}
)
def test_li_edit_date_person_test_is_eligible_to_modify_end_date_based_on_container_type(
self):
lu = LearningUnitFactory(existing_proposal_in_epc=False)
learning_unit_year_without_proposal = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_unit=lu,
)
person_faculty_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')
]
for manager in person_faculty_managers:
manager.user.user_permissions.add(
Permission.objects.get(codename='can_edit_learningunit_date'))
learning_unit_year_without_proposal.subtype = learning_unit_year_subtypes.FULL
learning_unit_year_without_proposal.learning_container_year = self.lcy
learning_unit_year_without_proposal.learning_container_year.container_type = learning_container_year_types.COURSE
learning_unit_year_without_proposal.learning_container_year.save()
learning_unit_year_without_proposal.save()
PersonEntityFactory(
person=manager,
entity=self.requirement_entity,
)
self.context['user'] = manager.user
self.context[
'learning_unit_year'] = learning_unit_year_without_proposal
result = li_edit_date_lu(self.context, self.url_edit, "")
self.assertEqual(
result,
self._get_result_data_expected(
ID_LINK_EDIT_DATE_LU, MSG_NO_ELIGIBLE_TO_MODIFY_END_DATE))
# allowed if _is_person_central_manager or
# _is_learning_unit_year_a_partim or
# negation(_is_container_type_course_dissertation_or_internship),
# test 1st condition true
self.context['user'] = self.central_manager_person.user
result = li_edit_date_lu(self.context, self.url_edit, "")
self.assertEqual(
result,
self._get_result_data_expected(ID_LINK_EDIT_DATE_LU,
url=self.url_edit))
# test 2nd condition true
self.context['user'] = manager.user
learning_unit_year_without_proposal.subtype = learning_unit_year_subtypes.PARTIM
learning_unit_year_without_proposal.save()
self.context[
'learning_unit_year'] = learning_unit_year_without_proposal
self.assertEqual(
li_edit_date_lu(self.context, self.url_edit, ""),
self._get_result_data_expected(ID_LINK_EDIT_DATE_LU,
url=self.url_edit))
# test 3rd condition true
learning_unit_year_without_proposal.learning_container_year.container_type = learning_container_year_types.OTHER_COLLECTIVE
learning_unit_year_without_proposal.learning_container_year.save()
learning_unit_year_without_proposal.subtype = learning_unit_year_subtypes.FULL
learning_unit_year_without_proposal.save()
self.context[
'learning_unit_year'] = learning_unit_year_without_proposal
self.assertEqual(
li_edit_date_lu(self.context, self.url_edit, ""),
self._get_result_data_expected(ID_LINK_EDIT_DATE_LU,
url=self.url_edit))
class HomeTest(TestCase):
def setUp(self):
Group.objects.get_or_create(name='tutors')
self.person = PersonFactory()
self.tutor = TutorFactory(person=self.person)
attribution_permission = Permission.objects.get(
codename='can_access_attribution')
self.person.user.user_permissions.add(attribution_permission)
today = datetime.datetime.today()
self.academic_year = AcademicYearFactory(
year=today.year,
start_date=today - datetime.timedelta(days=5),
end_date=today + datetime.timedelta(days=5))
self.learning_unit_year = LearningUnitYearFactory(
academic_year=self.academic_year)
self.learning_unit_year.learning_container_year = LearningContainerYearFactory(
academic_year=self.learning_unit_year.academic_year,
in_charge=True)
self.learning_unit_year.save()
self.attribution = AttributionFactory(
function=function.CO_HOLDER,
learning_unit_year=self.learning_unit_year,
tutor=self.tutor,
external_id=ATTRIBUTION_EXTERNAL_ID)
self.url = reverse('attribution_home')
self.client.force_login(self.person.user)
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_user_without_permission(self):
a_person = PersonFactory()
self.client.force_login(a_person.user)
response = self.client.get(self.url)
self.assertEqual(response.status_code, ACCESS_DENIED)
self.assertTemplateUsed(response, "access_denied.html")
def test_person_without_global_id(self):
self.person.global_id = None
self.person.save()
response = self.client.get(self.url)
self.assertTemplateUsed(response, 'tutor_charge.html')
self.assertEqual(response.context['user'], self.person.user)
self.assertEqual(response.context['attributions'], None)
self.assertEqual(response.context['year'],
int(self.academic_year.year))
self.assertEqual(response.context['tot_lecturing'], 0)
self.assertEqual(response.context['tot_practical'], 0)
self.assertEqual(response.context['academic_year'], self.academic_year)
self.assertEqual(response.context['global_id'], None)
self.assertEqual(response.context['error'], True)
self.assertIsInstance(response.context['formset'], BaseFormSet)
def test_user_without_person(self):
self.person.delete()
response = self.client.get(self.url)
self.assertTemplateUsed(response, 'tutor_charge.html')
self.assertEqual(response.context['user'], None)
self.assertEqual(response.context['attributions'], None)
self.assertEqual(response.context['year'],
int(self.academic_year.year))
self.assertEqual(response.context['tot_lecturing'], None)
self.assertEqual(response.context['tot_practical'], None)
self.assertEqual(response.context['academic_year'], self.academic_year)
self.assertEqual(response.context['global_id'], None)
self.assertEqual(response.context['error'], False)
self.assertIsInstance(response.context['formset'], BaseFormSet)
def test_user_without_tutor(self):
self.tutor.delete()
response = self.client.get(self.url)
self.assertTemplateUsed(response, 'tutor_charge.html')
self.assertEqual(response.context['user'], self.person.user)
self.assertEqual(response.context['attributions'], None)
self.assertEqual(response.context['year'],
int(self.academic_year.year))
self.assertEqual(response.context['tot_lecturing'], None)
self.assertEqual(response.context['tot_practical'], None)
self.assertEqual(response.context['academic_year'], self.academic_year)
self.assertEqual(response.context['global_id'], None)
self.assertEqual(response.context['error'], False)
self.assertIsInstance(response.context['formset'], BaseFormSet)
def test_without_current_academic_year(self):
self.academic_year.year -= 1
self.academic_year.end_date = datetime.datetime.today(
) - datetime.timedelta(days=3)
self.academic_year.save()
response = self.client.get(self.url)
self.assertTemplateUsed(response, 'tutor_charge.html')
self.assertEqual(response.context['user'], self.person.user)
self.assertEqual(response.context['attributions'], None)
self.assertEqual(response.context['year'],
int(datetime.datetime.now().year))
self.assertEqual(response.context['tot_lecturing'], 0)
self.assertEqual(response.context['tot_practical'], 0)
self.assertEqual(response.context['academic_year'], None)
self.assertEqual(response.context['global_id'], None)
self.assertEqual(response.context['error'], True)
self.assertIsInstance(response.context['formset'], BaseFormSet)
@mock.patch('requests.get',
side_effect=mock_request_none_attribution_charge)
def test_without_attributions(self, mock_requests_get):
response = self.client.get(self.url, mock_requests_get)
self.assertTrue(mock_requests_get.called)
self.assertTemplateUsed(response, 'tutor_charge.html')
self.assertEqual(response.context['user'], self.person.user)
self.assertEqual(response.context['attributions'], None)
self.assertEqual(response.context['year'],
int(self.academic_year.year))
self.assertEqual(response.context['tot_lecturing'], 0)
self.assertEqual(response.context['tot_practical'], 0)
self.assertEqual(response.context['academic_year'], self.academic_year)
self.assertEqual(response.context['global_id'], self.person.global_id)
self.assertEqual(response.context['error'], False)
self.assertIsInstance(response.context['formset'], BaseFormSet)
@override_settings()
def test_when_not_configuration_for_attribution(self):
del settings.ATTRIBUTION_CONFIG
response = self.client.get(self.url)
self.assertTemplateUsed(response, 'tutor_charge.html')
self.assertEqual(response.context['user'], self.person.user)
self.assertEqual(response.context['attributions'], None)
self.assertEqual(response.context['year'],
int(self.academic_year.year))
self.assertEqual(response.context['tot_lecturing'], 0)
self.assertEqual(response.context['tot_practical'], 0)
self.assertEqual(response.context['academic_year'], self.academic_year)
self.assertEqual(response.context['global_id'], self.person.global_id)
self.assertEqual(response.context['error'], True)
self.assertIsInstance(response.context['formset'], BaseFormSet)
@mock.patch('requests.get', side_effect=RequestException)
def test_when_exception_occured_during_request_of_webservice(
self, mock_requests_get):
response = self.client.get(self.url)
self.assertTrue(mock_requests_get.called)
self.assertTemplateUsed(response, 'tutor_charge.html')
self.assertEqual(response.context['user'], self.person.user)
self.assertEqual(response.context['attributions'], None)
self.assertEqual(response.context['year'],
int(self.academic_year.year))
self.assertEqual(response.context['tot_lecturing'], 0)
self.assertEqual(response.context['tot_practical'], 0)
self.assertEqual(response.context['academic_year'], self.academic_year)
self.assertEqual(response.context['global_id'], self.person.global_id)
self.assertEqual(response.context['error'], True)
self.assertIsInstance(response.context['formset'], BaseFormSet)
@override_settings(ATTRIBUTION_CONFIG=get_attribution_config_settings())
@mock.patch('requests.get',
side_effect=mock_request_single_attribution_charge)
def test_for_one_attribution(self, mock_requests_get):
response = self.client.get(self.url)
self.assertTrue(mock_requests_get.called)
self.assertTemplateUsed(response, 'tutor_charge.html')
self.assertEqual(response.context['user'], self.person.user)
self.assertEqual(response.context['year'],
int(self.academic_year.year))
self.assertEqual(response.context['tot_lecturing'],
LEARNING_UNIT_LECTURING_DURATION)
self.assertEqual(response.context['tot_practical'],
LEARNING_UNIT_PRACTICAL_EXERCISES_DURATION)
self.assertEqual(response.context['academic_year'], self.academic_year)
self.assertEqual(response.context['global_id'], self.person.global_id)
self.assertEqual(response.context['error'], False)
self.assertIsInstance(response.context['formset'], BaseFormSet)
self.assertEqual(len(response.context['attributions']), 1)
attribution = response.context['attributions'][0]
self.assertEqual(attribution['acronym'],
self.learning_unit_year.acronym)
self.assertEqual(attribution['title'],
self.learning_unit_year.specific_title)
self.assertEqual(attribution['start_year'],
self.attribution.start_year)
self.assertEqual(attribution['lecturing_allocation_charge'],
str(LEARNING_UNIT_LECTURING_DURATION))
self.assertEqual(attribution['practice_allocation_charge'],
str(LEARNING_UNIT_PRACTICAL_EXERCISES_DURATION))
self.assertEqual(attribution['percentage_allocation_charge'], '75.0')
self.assertEqual(attribution['weight'],
self.learning_unit_year.credits)
self.assertEqual(attribution['url_schedule'], "")
self.assertEqual(
attribution['url_students_list_email'],
'mailto:{}-{}@listes-student.uclouvain.be'.format(
self.learning_unit_year.acronym.lower(),
self.academic_year.year))
self.assertEqual(attribution['function'], self.attribution.function)
self.assertEqual(attribution['year'], self.academic_year.year)
self.assertEqual(attribution['learning_unit_year_url'], "")
self.assertEqual(attribution['learning_unit_year'],
self.learning_unit_year)
self.assertEqual(attribution['tutor_id'], self.tutor.id)
@mock.patch('requests.get',
side_effect=mock_request_multiple_attributions_charge)
def test_for_multiple_attributions(self, mock_requests_get):
an_other_attribution = AttributionFactory(
function=function.CO_HOLDER,
learning_unit_year=self.learning_unit_year,
tutor=self.tutor,
external_id=OTHER_ATTRIBUTION_EXTERNAL_ID)
response = self.client.get(self.url)
self.assertTrue(mock_requests_get.called)
self.assertTemplateUsed(response, 'tutor_charge.html')
self.assertEqual(response.context['user'], self.person.user)
self.assertEqual(response.context['year'],
int(self.academic_year.year))
self.assertEqual(response.context['tot_lecturing'],
LEARNING_UNIT_LECTURING_DURATION)
self.assertEqual(response.context['tot_practical'],
LEARNING_UNIT_PRACTICAL_EXERCISES_DURATION)
self.assertEqual(response.context['academic_year'], self.academic_year)
self.assertEqual(response.context['global_id'], self.person.global_id)
self.assertEqual(response.context['error'], False)
self.assertIsInstance(response.context['formset'], BaseFormSet)
self.assertEqual(len(response.context['attributions']), 2)
@mock.patch('requests.get',
side_effect=mock_request_multiple_attributions_charge)
def test_with_attribution_not_recognized(self, mock_requests_get):
an_other_attribution = AttributionFactory(
learning_unit_year=self.learning_unit_year,
tutor=self.tutor,
external_id=OTHER_ATTRIBUTION_EXTERNAL_ID)
inexisting_external_id = "osis.attribution_8082"
attribution_not_in_json = AttributionFactory(
learning_unit_year=self.learning_unit_year,
tutor=self.tutor,
external_id=inexisting_external_id)
response = self.client.get(self.url)
self.assertTrue(mock_requests_get.called)
self.assertTemplateUsed(response, 'tutor_charge.html')
self.assertEqual(response.context['user'], self.person.user)
self.assertEqual(response.context['year'],
int(self.academic_year.year))
self.assertEqual(response.context['tot_lecturing'],
LEARNING_UNIT_LECTURING_DURATION)
self.assertEqual(response.context['tot_practical'],
LEARNING_UNIT_PRACTICAL_EXERCISES_DURATION)
self.assertEqual(response.context['academic_year'], self.academic_year)
self.assertEqual(response.context['global_id'], self.person.global_id)
self.assertEqual(response.context['error'], False)
self.assertIsInstance(response.context['formset'], BaseFormSet)
self.assertEqual(len(response.context['attributions']), 2)
@mock.patch(
'requests.get',
side_effect=mock_request_multiple_attributions_charge_with_missing_values
)
def test_with_missing_values(self, mock_requests_get):
an_other_attribution = AttributionFactory(
learning_unit_year=self.learning_unit_year,
tutor=self.tutor,
external_id=OTHER_ATTRIBUTION_EXTERNAL_ID)
response = self.client.get(self.url)
self.assertTrue(mock_requests_get.called)
self.assertTemplateUsed(response, 'tutor_charge.html')
self.assertEqual(response.context['user'], self.person.user)
self.assertEqual(response.context['year'],
int(self.academic_year.year))
self.assertEqual(response.context['tot_lecturing'],
LEARNING_UNIT_LECTURING_DURATION)
self.assertEqual(response.context['tot_practical'],
LEARNING_UNIT_PRACTICAL_EXERCISES_DURATION)
self.assertEqual(response.context['academic_year'], self.academic_year)
self.assertEqual(response.context['global_id'], self.person.global_id)
self.assertEqual(response.context['error'], False)
self.assertIsInstance(response.context['formset'], BaseFormSet)
attributions = response.context['attributions']
reduced_list_attributions = map(
lambda attribution: [
attribution["lecturing_allocation_charge"], attribution[
'practice_allocation_charge'], attribution[
'percentage_allocation_charge']
], attributions)
self.assertIn([str(LEARNING_UNIT_LECTURING_DURATION), None, "25.0"],
reduced_list_attributions)
class TestLearningUnitModificationForm(TestCase):
@classmethod
def setUpTestData(cls):
cls.current_academic_year = create_current_academic_year()
cls.organization = OrganizationFactory(type=organization_type.MAIN)
a_campus = CampusFactory(organization=cls.organization)
an_entity = EntityFactory(organization=cls.organization)
cls.an_entity_version = EntityVersionFactory(
entity=an_entity,
entity_type=entity_type.SCHOOL,
parent=None,
end_date=None,
start_date=datetime.date.today() - datetime.timedelta(days=5))
cls.person = PersonEntityFactory(entity=an_entity).person
language = LanguageFactory()
cls.form_data = {
"academic_year": str(cls.current_academic_year.id),
"container_type": str(learning_container_year_types.COURSE),
"subtype": str(learning_unit_year_subtypes.FULL),
"acronym": "OSIS1452",
"credits": "45",
"specific_title": "OSIS",
"first_letter": "L",
"periodicity": learning_unit_periodicity.ANNUAL,
"campus": str(a_campus.id),
"requirement_entity": str(cls.an_entity_version.id),
"allocation_entity": str(cls.an_entity_version.id),
"language": language.pk
}
cls.initial_data = {
"academic_year": str(cls.current_academic_year.id),
"container_type": str(learning_container_year_types.COURSE),
"subtype": str(learning_unit_year_subtypes.FULL),
"acronym": "OSIS1452",
"first_letter": "L",
"status": True
}
cls.faculty_user = UserFactory()
cls.faculty_user.groups.add(
Group.objects.get(name=FACULTY_MANAGER_GROUP))
cls.faculty_person = PersonFactory(user=cls.faculty_user)
cls.faculty_user.user_permissions.add(
Permission.objects.get(codename='can_propose_learningunit'))
PersonEntityFactory(entity=an_entity, person=cls.faculty_person)
def setUp(self):
self.learning_container_year = LearningContainerYearFactory(
academic_year=self.current_academic_year, container_type=COURSE)
self.learning_unit_year = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_year,
learning_unit__periodicity=ANNUAL,
subtype=FULL,
credits=25,
status=False)
self.learning_unit_year_partim_1 = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_year,
learning_unit__periodicity=ANNUAL,
subtype=PARTIM,
credits=20,
status=False)
self.learning_unit_year_partim_2 = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_year,
learning_unit__periodicity=ANNUAL,
subtype=PARTIM,
credits=18,
status=False)
def test_disabled_fields_in_case_of_learning_unit_of_type_full(self):
form = LearningUnitModificationForm(
person=self.person,
learning_unit_year_instance=self.learning_unit_year)
disabled_fields = ("first_letter", "acronym", "academic_year",
"container_type", "subtype")
for field in disabled_fields:
self.assertTrue(form.fields[field].disabled)
def test_disabled_fields_in_case_of_learning_unit_of_type_partim(self):
form = LearningUnitModificationForm(
person=self.person,
learning_unit_year_instance=self.learning_unit_year_partim_1)
disabled_fields = ('first_letter', 'acronym', 'common_title',
'common_title_english', 'requirement_entity',
'allocation_entity', 'language', 'campus',
'container_type', "academic_year",
'internship_subtype',
'additional_requirement_entity_1',
'additional_requirement_entity_2', 'is_vacant',
'team', 'type_declaration_vacant',
'attribution_procedure', "subtype", "status")
for field in form.fields:
if field in disabled_fields:
self.assertTrue(form.fields[field].disabled, field)
else:
self.assertFalse(form.fields[field].disabled, field)
def test_disabled_internship_subtype_in_case_of_container_type_different_than_internship(
self):
form = LearningUnitModificationForm(
person=self.person,
learning_unit_year_instance=self.learning_unit_year)
self.assertTrue(form.fields["internship_subtype"].disabled)
self.learning_unit_year.learning_container_year.container_type = learning_container_year_types.INTERNSHIP
form = LearningUnitModificationForm(
person=self.person,
learning_unit_year_instance=self.learning_unit_year)
self.assertFalse(form.fields["internship_subtype"].disabled)
def test_entity_does_not_exist_for_lifetime_of_learning_unit(self):
an_other_entity = EntityFactory(organization=self.organization)
an_other_entity_version = EntityVersionFactory(
entity=an_other_entity,
entity_type=entity_type.SCHOOL,
parent=None,
end_date=self.current_academic_year.end_date -
datetime.timedelta(days=5),
start_date=datetime.date.today() - datetime.timedelta(days=5))
PersonEntityFactory(person=self.person, entity=an_other_entity)
form_data_with_invalid_requirement_entity = self.form_data.copy()
form_data_with_invalid_requirement_entity["requirement_entity"] = str(
an_other_entity_version.id)
form = LearningUnitModificationForm(
form_data_with_invalid_requirement_entity,
person=self.person,
end_date=self.current_academic_year.end_date,
learning_unit_year_instance=self.learning_unit_year)
self.assertFalse(form.is_valid())
def test_set_status_value(self):
form = LearningUnitModificationForm(
learning_unit_year_instance=self.learning_unit_year_partim_1,
person=self.person)
self.assertEqual(form.fields["status"].initial, False)
self.assertTrue(form.fields["status"].disabled)
def test_partim_can_modify_periodicity(self):
initial_data_with_subtype_partim = self.initial_data.copy()
initial_data_with_subtype_partim[
"subtype"] = learning_unit_year_subtypes.PARTIM
form = LearningUnitModificationForm(
learning_unit_year_instance=self.learning_unit_year_partim_1,
person=self.person)
self.assertFalse(form.fields["periodicity"].disabled)
def test_do_not_set_minimum_credits_for_full_learning_unit_year_if_no_partims(
self):
learning_unit_year_with_no_partims = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_unit__periodicity=ANNUAL,
subtype=FULL)
form = LearningUnitModificationForm(
person=self.person,
learning_unit_year_instance=learning_unit_year_with_no_partims)
self.assertEqual(form.fields["credits"].min_value, None)
def test_entity_does_not_exist_for_lifetime_of_learning_unit_with_no_planned_end(
self):
an_other_entity = EntityFactory(organization=self.organization)
an_other_entity_version = EntityVersionFactory(
entity=an_other_entity,
entity_type=entity_type.SCHOOL,
parent=None,
end_date=self.current_academic_year.end_date -
datetime.timedelta(days=5),
start_date=datetime.date.today() - datetime.timedelta(days=5))
PersonEntityFactory(person=self.person, entity=an_other_entity)
form_data_with_invalid_requirement_entity = self.form_data.copy()
form_data_with_invalid_requirement_entity["requirement_entity"] = str(
an_other_entity_version.id)
form = LearningUnitModificationForm(
form_data_with_invalid_requirement_entity,
person=self.person,
learning_unit_year_instance=self.learning_unit_year)
self.assertFalse(form.is_valid())
def test_when_requirement_and_attribution_entities_are_different_for_disseration_and_internship_subtype(
self):
an_other_entity_version = EntityVersionFactory(
entity__organization=self.organization,
entity_type=entity_type.SCHOOL,
parent=None,
end_date=None,
start_date=datetime.date.today() - datetime.timedelta(days=5))
form_data_with_different_allocation_entity = self.form_data.copy()
form_data_with_different_allocation_entity["allocation_entity"] = str(
an_other_entity_version.id)
for container_type in (learning_container_year_types.DISSERTATION,
learning_container_year_types.INTERNSHIP):
self.learning_container_year.container_type = container_type
self.learning_container_year.save()
form = LearningUnitModificationForm(
form_data_with_different_allocation_entity,
person=self.person,
learning_unit_year_instance=self.learning_unit_year)
self.assertFalse(form.is_valid(), container_type)
def test_when_partim_active_but_modify_parent_to_inactive(self):
# Set status to parent inactive
form_data_parent_with_status_inactive = self.form_data.copy()
form_data_parent_with_status_inactive['status'] = False
# Set status to partim active
self.learning_unit_year_partim_1.status = True
self.learning_unit_year_partim_1.save()
form = LearningUnitModificationForm(
form_data_parent_with_status_inactive,
person=self.person,
end_date=self.current_academic_year.end_date,
learning_unit_year_instance=self.learning_unit_year)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors['status'],
[_('The parent must be active because there are partim active')])
def test_valid_form(self):
form = LearningUnitModificationForm(
self.form_data,
person=self.person,
learning_unit_year_instance=self.learning_unit_year)
self.assertTrue(form.is_valid(), form.errors)
def test_valid_form_with_faculty_manager(self):
form = LearningUnitModificationForm(
self.form_data,
person=self.person,
learning_unit_year_instance=self.learning_unit_year)
self.assertTrue(form.is_valid(), form.errors)
def test_deactivated_fields_in_learning_unit_modification_form(self):
form = LearningUnitModificationForm(
person=self.person,
learning_unit_year_instance=self.learning_unit_year)
self.assertFalse(form.fields["common_title"].disabled)
self.assertFalse(form.fields["common_title_english"].disabled)
self.assertFalse(form.fields["specific_title"].disabled)
self.assertFalse(form.fields["specific_title_english"].disabled)
self.assertFalse(form.fields["faculty_remark"].disabled)
self.assertFalse(form.fields["other_remark"].disabled)
self.assertFalse(form.fields["campus"].disabled)
self.assertFalse(form.fields["status"].disabled)
self.assertFalse(form.fields["credits"].disabled)
self.assertFalse(form.fields["language"].disabled)
self.assertFalse(form.fields["requirement_entity"].disabled)
self.assertFalse(form.fields["allocation_entity"].disabled)
self.assertFalse(
form.fields["additional_requirement_entity_2"].disabled)
self.assertFalse(form.fields["is_vacant"].disabled)
self.assertFalse(form.fields["type_declaration_vacant"].disabled)
self.assertFalse(form.fields["attribution_procedure"].disabled)
self.assertTrue(form.fields["subtype"].disabled)
def test_deactivated_fields_in_learning_unit_modification_form_with_faculty_manager(
self):
form = LearningUnitModificationForm(
person=self.faculty_person,
learning_unit_year_instance=self.learning_unit_year)
self.assertTrue(form.fields["common_title"].disabled)
self.assertTrue(form.fields["common_title_english"].disabled)
self.assertTrue(form.fields["specific_title"].disabled)
self.assertTrue(form.fields["specific_title_english"].disabled)
self.assertFalse(form.fields["faculty_remark"].disabled)
self.assertFalse(form.fields["other_remark"].disabled)
self.assertTrue(form.fields["campus"].disabled)
self.assertTrue(form.fields["status"].disabled)
self.assertTrue(form.fields["credits"].disabled)
self.assertTrue(form.fields["language"].disabled)
self.assertTrue(form.fields["requirement_entity"].disabled)
self.assertTrue(form.fields["allocation_entity"].disabled)
self.assertTrue(
form.fields["additional_requirement_entity_2"].disabled)
self.assertTrue(form.fields["is_vacant"].disabled)
self.assertTrue(form.fields["type_declaration_vacant"].disabled)
self.assertTrue(form.fields["attribution_procedure"].disabled)
self.assertTrue(form.fields["subtype"].disabled)
class TestQuadriConsistency(TestCase):
@classmethod
def setUpTestData(cls):
cls.ay = create_current_academic_year()
def setUp(self):
self.luy_full = LearningUnitYearFactory(
academic_year=self.ay,
subtype=learning_unit_year_subtypes.FULL,
quadrimester=None)
self.learning_component_year_full_lecturing = LearningComponentYearFactory(
learning_unit_year=self.luy_full)
@patch.multiple(LearningComponentYearQuadriStrategy,
__abstractmethods__=set())
def test_is_valid_present(self):
instance = LearningComponentYearQuadriStrategy(
lcy=self.learning_component_year_full_lecturing)
with self.assertRaises(NotImplementedError):
self.assertRaises(NotImplementedError, instance.is_valid())
def test_no_strategy(self):
self.luy_full.credits = self.luy_full.credits + 1
self.luy_full.save()
test_cases = [
{
'vol_q1': 20,
'vol_q2': None,
'vol_tot_annual': 20,
'planned_classes': 1,
'vol_tot_global': 20
},
{
'vol_q1': None,
'vol_q2': 20,
'vol_tot_annual': 20,
'planned_classes': 1,
'vol_tot_global': 20
},
{
'vol_q1': 10,
'vol_q2': 10,
'vol_tot_annual': 20,
'planned_classes': 1,
'vol_tot_global': 20
},
{
'vol_q1': None,
'vol_q2': None,
'vol_tot_annual': None,
'planned_classes': None,
'vol_tot_global': None
},
]
for case in test_cases:
self._update_lecturing_component_volumes(case)
self.assertTrue(
LearningComponentYearQuadriNoStrategy(
lcy=self.learning_component_year_full_lecturing).is_valid())
def test_ok_volumes_for_Q1(self):
self.luy_full.credits = self.luy_full.credits + 1
self.luy_full.quadrimester = quadrimesters.Q1
self.luy_full.save()
test_cases = [
{
'vol_q1': 20,
'vol_q2': None,
'vol_tot_annual': 20,
'planned_classes': 1,
'vol_tot_global': 20
},
]
self._update_lecturing_component_volumes(test_cases[0])
self.assertTrue(
LearningComponentYearQ1Strategy(
lcy=self.learning_component_year_full_lecturing).is_valid())
def test_warning_volumes_for_Q1(self):
self.luy_full.credits = self.luy_full.credits + 1
self.luy_full.quadrimester = quadrimesters.Q1
self.luy_full.save()
test_cases = [
{
'vol_q1': None,
'vol_q2': 20,
'vol_tot_annual': 20,
'planned_classes': 1,
'vol_tot_global': 20
},
]
for case in test_cases:
self._update_lecturing_component_volumes(case)
excepted_error = "{} ({})".format(
_('Volumes of {} are inconsistent').format(
self.learning_component_year_full_lecturing.complete_acronym),
_('Only the volume Q1 must have a value'))
self.assertIn(excepted_error, self.luy_full.warnings)
def _update_lecturing_component_volumes(self, case):
with self.subTest(case=case):
self.learning_component_year_full_lecturing.hourly_volume_partial_q1 = case.get(
'vol_q1')
self.learning_component_year_full_lecturing.hourly_volume_partial_q2 = case.get(
'vol_q2')
self.learning_component_year_full_lecturing.hourly_volume_total_annual = case.get(
'vol_tot_annual')
self.learning_component_year_full_lecturing.planned_classes = case.get(
'planned_classes')
self.learning_component_year_full_lecturing.repartition_volume_requirement_entity = case.get(
'vol_tot_global')
self.learning_component_year_full_lecturing.save()
