def setUp(self):
today = date.today()
self.academic_year = AcademicYearFactory(year=today.year, start_date=today)
# Creation Container / UE and components related
self.l_container = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1210",
in_charge=True)
_create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
acronym="LBIR1210",subtype=learning_unit_year_subtypes.FULL)
_create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
acronym="LBIR1210A", subtype=learning_unit_year_subtypes.PARTIM)
_create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
acronym="LBIR1210B", subtype=learning_unit_year_subtypes.PARTIM)
# Creation Tutors
self.tutor_1 = TutorFactory(person=PersonFactory(first_name="Tom", last_name="Dupont", global_id='00012345'))
self.tutor_2 = TutorFactory(person=PersonFactory(first_name="Paul", last_name="Durant", global_id='08923545'))
# Creation Attribution and Attributions Charges - Tutor 1 - Holder
attribution_tutor_1 = AttributionNewFactory(learning_container_year=self.l_container, tutor=self.tutor_1,
function=function.HOLDER)
_create_attribution_charge(self.academic_year, attribution_tutor_1, "LBIR1210", Decimal(15.5), Decimal(10))
_create_attribution_charge(self.academic_year, attribution_tutor_1, "LBIR1210A", None, Decimal(5))
# Creation Attribution and Attributions Charges - Tutor 2 - Co-holder
attribution_tutor_2 = AttributionNewFactory(learning_container_year=self.l_container, tutor=self.tutor_2,
function=function.CO_HOLDER)
_create_attribution_charge(self.academic_year, attribution_tutor_2, "LBIR1210B", Decimal(7.5))
def test_post_overview_with_lecturing_and_practical_component_partim(self):
lbira2101a_next = _create_learning_container_with_components("LBIRA2101A", self.application_academic_year,
volume_lecturing=20, volume_practical_exercices=20,
subtype=learning_unit_year_subtypes.PARTIM)
lbira2101a_current = _create_learning_container_with_components(
"LBIRA2101A", self.current_academic_year,
volume_lecturing=20, volume_practical_exercices=20,
subtype=learning_unit_year_subtypes.PARTIM)
_link_components_and_learning_unit_year_to_container(lbira2101a_current, "LBIRA2101",
subtype=learning_unit_year_subtypes.FULL)
_link_components_and_learning_unit_year_to_container(lbira2101a_next, "LBIRA2101",
subtype=learning_unit_year_subtypes.FULL)
self.attribution.delete()
self.attribution = AttributionNewFactory(
global_id=self.tutor.person.global_id,
applications=[_get_application_example(lbira2101a_next, "10", "10")]
)
url = reverse('applications_overview')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
context = response.context[0]
self.assertEqual(len(context['applications']), 1)
self.assertEqual(context['applications'][0]['acronym'], lbira2101a_next.acronym)
with self.assertRaises(KeyError):
context['applications'][0]['PRACTICAL_EXERCISES']
with self.assertRaises(KeyError):
context['applications'][0]['LECTURING']
def setUp(self):
self.academic_year = AcademicYearFactory(year=2017)
external_id = tutor_application_epc.LEARNING_CONTAINER_YEAR_PREFIX_EXTERNAL_ID + '35654987_2017'
self.lbir1200 = LearningUnitYearFactory(
academic_year=self.academic_year,
acronym="LBIR1200",
learning_container_year__academic_year=self.academic_year,
learning_container_year__acronym="LBIR1200",
learning_container_year__external_id=external_id)
self.lagro2630 = LearningUnitYearFactory(
academic_year=self.academic_year,
acronym="LAGRO2630",
learning_container_year__academic_year=self.academic_year,
learning_container_year__acronym="LAGRO2630",
)
# Creation Person/Tutor
Group.objects.create(name="tutors")
person = PersonFactory(global_id="98363454")
external_id = tutor_application_epc.TUTOR_PREFIX_EXTERNAL_ID + '2089590559'
self.tutor = TutorFactory(external_id=external_id, person=person)
# Create two tutor applications
applications = [
_get_application_example(self.lbir1200, '30.5', '40.5'),
_get_application_example(self.lagro2630, '12.5', '0')
]
self.attribution = AttributionNewFactory(global_id=person.global_id,
applications=applications)
def setUp(self):
# Create academic year
self.academic_year = AcademicYearFactory(year=2017)
# Create several learning container year - 2017
self.lbir1200_2017 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1200")
LearningUnitYearFactory(academic_year=self.academic_year, learning_container_year=self.lbir1200_2017)
self.lbir1250_2017 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1250")
LearningUnitYearFactory(academic_year=self.academic_year, learning_container_year=self.lbir1250_2017)
self.lbir1300_2017 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1300")
LearningUnitYearFactory(academic_year=self.academic_year, learning_container_year=self.lbir1300_2017)
self.lagro1200_2017 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LAGRO1200")
LearningUnitYearFactory(academic_year=self.academic_year, learning_container_year=self.lagro1200_2017)
# Create several learning container year - 2016
self.academic_year_2016 = AcademicYearFactory(year=2016)
self.lbir1200_2016 = LearningContainerYearFactory(academic_year=self.academic_year_2016, acronym="LBIR1200")
LearningUnitYearFactory(academic_year=self.academic_year_2016, learning_container_year=self.lbir1200_2016)
self.lbir1250_2016 = LearningContainerYearFactory(academic_year=self.academic_year_2016, acronym="LBIR1250")
LearningUnitYearFactory(academic_year=self.academic_year_2016, learning_container_year=self.lbir1250_2016)
# Creation Person/Tutor
Group.objects.create(name="tutors")
person = PersonFactory(global_id="98363454")
self.tutor = TutorFactory(person=person)
applications = [
_get_application_example(self.lbir1200_2017, '3.5', '35.6'), # Application 2017
_get_application_example(self.lbir1300_2017, '7.5', '25'), # Application 2017
_get_application_example(self.lbir1200_2016, '2', '30'), # Application 2016
]
self.attribution = AttributionNewFactory(global_id=person.global_id,
attributions=_get_attributions_default(),
applications=applications)
def setUp(self):
# Creation Person/Tutor
Group.objects.create(name="tutors")
self.person = PersonFactory(global_id="98363454")
TutorFactory(person=self.person)
_create_multiple_academic_year()
self.current_academic_year = create_current_academic_year()
# Creation Json which will be store on attribution
attributions = _get_attributions_dict(self.current_academic_year.year)
self.attrib = AttributionNewFactory(global_id=self.person.global_id,
attributions=attributions)
def setUp(self):
# Create Group tutor
Group.objects.create(name="tutors")
# Create user
user = UserFactory(username="******")
person = PersonFactory(global_id="578945612", user=user)
self.tutor = TutorFactory(person=person)
# Add permission and log into app
add_permission(user, "can_access_attribution_application")
self.client.force_login(user)
# Create current academic year
self.current_academic_year = create_current_academic_year()
# Create application year
# Application is always next year
self.application_academic_year = AcademicYearFactory(
year=self.current_academic_year.year + 1
)
# Create Event to allow teacher to register
start_date = datetime.datetime.today() - datetime.timedelta(days=10)
end_date = datetime.datetime.today() + datetime.timedelta(days=15)
self.academic_calendar = AcademicCalendarFactory(
academic_year=self.current_academic_year,
reference=academic_calendar_type.TEACHING_CHARGE_APPLICATION,
start_date=start_date,
end_date=end_date
)
self.agro_entity = EntityFactory()
self.agro_entity_version = EntityVersionFactory(entity=self.agro_entity, acronym="AGRO",
entity_type='FACULTY',
start_date=self.academic_calendar.start_date,
end_date=self.academic_calendar.end_date)
self.drt_entity = EntityFactory()
self.drt_entity_version = EntityVersionFactory(entity=self.drt_entity, acronym="DRT",
entity_type='FACULTY',
start_date=self.academic_calendar.start_date,
end_date=self.academic_calendar.end_date)
# Creation context with multiple learning container year
self._create_multiple_learning_container_year()
self.attribution = AttributionNewFactory(
global_id=person.global_id,
applications=self._get_default_application_list(),
attributions=self._get_default_attribution_list()
)
def test_delete_all_learning_units_year_case_success_have_attribution_new_without_charge(
self):
learning_unit_years = self.learning_unit_year_list
ly1 = learning_unit_years[1]
AttributionNewFactory(
learning_container_year=ly1.learning_container_year)
request_factory = RequestFactory()
request = request_factory.post(
reverse(delete_all_learning_units_year, args=[ly1.id]))
request.user = self.user
setattr(request, 'session', 'session')
setattr(request, '_messages', FallbackStorage(request))
response = delete_all_learning_units_year(request, ly1.id)
msg_level = [m.level for m in get_messages(request)]
msg = [m.message for m in get_messages(request)]
self.assertEqual(len(msg), 5)
self.assertIn(messages.SUCCESS, msg_level)
for y in range(4):
self.assertFalse(
LearningUnitYear.objects.filter(
pk=learning_unit_years[y].pk).exists())
# Check redirection to identification
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, reverse('learning_units'))
def test_post_overview_with_lecturing_and_practical_component_partim(self):
self.attribution.delete()
self.attribution = AttributionNewFactory(
global_id=self.tutor.person.global_id,
applications=[_get_application_example(self.lbira2101_next, "10", "10")]
)
url = reverse('applications_overview')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertEqual(len(context['applications']), 1)
self.assertEqual(context['applications'][0]['acronym'], self.lbira2101_next.acronym)
with self.assertRaises(KeyError):
context['applications'][0]['PRACTICAL_EXERCISES']
with self.assertRaises(KeyError):
context['applications'][0]['LECTURING']
def test_find_no_teachers_for_year(self):
AttributionNewFactory(global_id="123456789",
attributions=[{
'year': YEAR_2017,
'acronym': LCHM1111
}])
results = mdl_attribution.attribution_new.find_teachers(
LCHM1111, YEAR_2016)
self.assertEqual(len(results), 0)
def test_get_2_teachers_in_order(self):
acronym_LCHM1111 = 'LCHM1111'
acronym_LDVLP2627 = 'LDVLP2627'
acronym_LDROI1110 = 'LDROI1110'
# Create first teacher with one attribution on LCHM1111 and others
person_first_alphabetical_order = PersonFactory(global_id='12345678',
last_name='Antonelli')
attribution_teacher_1_LCHM1111 = {
'year': 2017,
'acronym': acronym_LCHM1111
}
attributions_teacher1 = [
attribution_teacher_1_LCHM1111, {
'year': 2016,
'acronym': acronym_LDVLP2627
}, {
'year': 2017,
'acronym': acronym_LDVLP2627
}, {
'year': 2017,
'acronym': acronym_LDROI1110
}
]
AttributionNewFactory(
global_id=person_first_alphabetical_order.global_id,
attributions=attributions_teacher1)
# Create second teacher with one attribution on LCHM1111
person_second_alphabetical_order = PersonFactory(global_id='987654321',
last_name='Barnet')
attribution_teacher_2_LCHM1111 = {
'year': 2017,
'acronym': acronym_LCHM1111
}
attributions_teacher2 = [attribution_teacher_2_LCHM1111]
AttributionNewFactory(
global_id=person_second_alphabetical_order.global_id,
attributions=attributions_teacher2)
#
attributions_result = attribution.get_teachers(acronym_LCHM1111, 2017)
self.assertEqual(len(attributions_result), 2)
self.assertEqual(attributions_result[0][attribution.PERSON_KEY],
person_first_alphabetical_order)
def test_two_attribution_function_to_same_learning_unit(self):
new_attrib = AttributionNewFactory(learning_container_year=self.l_container, tutor=self.tutor_1,
function=function.COORDINATOR)
_create_attribution_charge(self.academic_year, new_attrib, "LBIR1210", Decimal(0), Decimal(0))
attrib_list = attribution_json._compute_list()
self.assertIsInstance(attrib_list, list)
self.assertEqual(len(attrib_list), 2)
attrib_tutor_1 = next(
(attrib for attrib in attrib_list if attrib['global_id'] == self.tutor_1.person.global_id),
None
)
self.assertEqual(len(attrib_tutor_1['attributions']), 3)
def build_attributions_for_2_teachers_on_a_learning_unit(an_acronym, yr):
attributionLCHM1111 = {'year': yr, 'acronym': an_acronym}
AttributionNewFactory(global_id="123456789",
attributions=[
attributionLCHM1111, {
'year': YEAR_2016,
'acronym': 'LDVLP2627'
}, {
'year': yr,
'acronym': 'LDVLP2627'
}, {
'year': yr,
'acronym': 'LDROI1110'
}
])
AttributionNewFactory(global_id="987654321",
attributions=[
attributionLCHM1111, {
'year': YEAR_2016,
'acronym': 'LAGRO1256'
}
])
def test_delete_all_learning_units_year_case_error_have_attributionnew_with_charge(
self):
learning_unit_years = self.learning_unit_year_list
ly1 = learning_unit_years[1]
attrib_new_1 = AttributionNewFactory(
learning_container_year=ly1.learning_container_year)
learning_component_year_1 = LearningComponentYearFactory(
learning_unit_year=ly1)
AttributionChargeNewFactory(
attribution=attrib_new_1,
learning_component_year=learning_component_year_1)
request_factory = RequestFactory()
request = request_factory.post(
reverse(delete_all_learning_units_year, args=[ly1.id]))
request.user = self.user
setattr(request, 'session', 'session')
setattr(request, '_messages', FallbackStorage(request))
response = delete_all_learning_units_year(request, ly1.id)
# Get message from context
msg = [m.message for m in get_messages(request)]
msg_level = [m.level for m in get_messages(request)]
self.assertEqual(len(msg), 1)
self.assertIn(messages.ERROR, msg_level)
# Check error message
subtype = _('The partim') if ly1.is_partim() else _(
'The learning unit')
self.assertIn(
_("%(subtype)s %(acronym)s is assigned to %(tutor)s for the year %(year)s"
) % {
'subtype': subtype,
'acronym': ly1.acronym,
'tutor': attrib_new_1.tutor,
'year': ly1.academic_year
}, msg)
# Check that record is not deleted
self.assertTrue(LearningUnitYear.objects.filter(pk=ly1.pk).exists())
# Check redirection to identification
self.assertEqual(response.status_code, 302)
self.assertEqual(
response.url,
reverse('learning_unit', kwargs={'learning_unit_year_id': ly1.pk}))
def setUpTestData(cls):
tutor = TutorFactory(person=PersonFactory())
cls.attribution = AttributionNewFactory(
tutor=tutor,
substitute=PersonFactory()
)
cls.luy = LearningUnitYearFactory()
cls.attribution_charge = AttributionChargeNewFactory(
attribution=cls.attribution,
learning_component_year__learning_unit_year=cls.luy
)
cls.person = PersonFactory()
url_kwargs = {
'acronym': cls.luy.acronym,
'year': cls.luy.academic_year.year
}
cls.url = reverse('learning_unit_api_v1:learningunitattributions_read', kwargs=url_kwargs)
def test_get_results_coordinator_without_volume(self):
AttributionNew.objects.all().delete()
attribution_without_volume = AttributionNewFactory(
learning_container_year=self.luy.learning_container_year,
function=Functions.COORDINATOR.name,
)
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
attribution_annotated = AttributionNew.objects.annotate(
first_name=F('tutor__person__first_name'),
middle_name=F('tutor__person__middle_name'),
last_name=F('tutor__person__last_name'),
email=F('tutor__person__email'),
global_id=F('tutor__person__global_id'),
).get(id=attribution_without_volume.pk)
serializer = LearningUnitAttributionSerializer([attribution_annotated], many=True)
self.assertEqual(response.data, serializer.data)
def setUp(self):
self.country = CountryFactory()
self.academic_yr = AcademicYearFactory(year=timezone.now().year)
self.start_date = self.academic_yr.start_date
self.end_date = self.academic_yr.end_date
self.list_learning_unit_container_year = self._create_list_containers(4)
self.list_learning_unit_year = self._create_list_learning_units_from_containers(
self.list_learning_unit_container_year)
self.list_entity_version = self._create_list_entities_version()
self._add_entities_to_containers(
self.list_entity_version,
self.list_learning_unit_container_year
)
self.tutor = TutorFactory()
self.attribution = AttributionNewFactory(tutor=self.tutor)
self.learning_component = LearningComponentYearFactory(learning_unit_year=self.list_learning_unit_year[0])
self.attribution_charge_new = \
AttributionChargeNewFactory(attribution=self.attribution,
learning_component_year=self.learning_component)
def test_check_related_partims_deletion(self):
l_container_year = LearningContainerYearFactory()
LearningUnitYearFactory(
acronym="LBIR1212",
learning_container_year=l_container_year,
academic_year=self.academic_year, subtype=learning_unit_year_subtypes.FULL,
learning_unit=self.learning_unit)
msg = deletion._check_related_partims_deletion(l_container_year)
self.assertEqual(len(msg.values()), 0)
l_unit_2 = LearningUnitYearFactory(acronym="LBIR1213", learning_container_year=l_container_year,
academic_year=self.academic_year, subtype=learning_unit_year_subtypes.PARTIM)
LearningUnitEnrollmentFactory(learning_unit_year=l_unit_2)
LearningUnitEnrollmentFactory(learning_unit_year=l_unit_2)
LearningUnitEnrollmentFactory(learning_unit_year=l_unit_2)
group_1 = GroupElementYearFactory(child_branch=None, child_leaf=l_unit_2)
group_2 = GroupElementYearFactory(child_branch=None, child_leaf=l_unit_2)
component = LearningComponentYearFactory(learning_unit_year=l_unit_2)
attribution_1 = AttributionNewFactory(learning_container_year=l_unit_2.learning_container_year)
attribution_2 = AttributionNewFactory(learning_container_year=l_unit_2.learning_container_year)
AttributionChargeNewFactory(learning_component_year=component,
attribution=attribution_1)
AttributionChargeNewFactory(learning_component_year=component,
attribution=attribution_1)
AttributionChargeNewFactory(learning_component_year=component,
attribution=attribution_2)
msg = deletion._check_related_partims_deletion(l_container_year)
msg = list(msg.values())
self.assertEqual(len(msg), 5)
self.assertIn(_("There is %(count)d enrollments in %(subtype)s %(acronym)s for the year %(year)s")
% {'subtype': _('The partim'),
'acronym': l_unit_2.acronym,
'year': l_unit_2.academic_year,
'count': 3},
msg)
msg_delete_tutor = _("%(subtype)s %(acronym)s is assigned to %(tutor)s for the year %(year)s")
self.assertIn(msg_delete_tutor % {'subtype': _('The partim'),
'acronym': l_unit_2.acronym,
'year': l_unit_2.academic_year,
'tutor': attribution_1.tutor},
msg)
self.assertIn(msg_delete_tutor % {'subtype': _('The partim'),
'acronym': l_unit_2.acronym,
'year': l_unit_2.academic_year,
'tutor': attribution_2.tutor},
msg)
msg_delete_offer_type = _('%(subtype)s %(acronym)s is included in the group %(group)s for the year %(year)s')
self.assertIn(msg_delete_offer_type
% {'subtype': _('The partim'),
'acronym': l_unit_2.acronym,
'group': group_1.parent.partial_acronym,
'year': l_unit_2.academic_year},
msg)
self.assertIn(msg_delete_offer_type
% {'subtype': _('The partim'),
'acronym': l_unit_2.acronym,
'group': group_2.parent.partial_acronym,
'year': l_unit_2.academic_year},
msg)
class TutorApplicationTest(TestCase):
def setUp(self):
# Create academic year
self.academic_year = AcademicYearFactory(year=2017)
# Create several learning container year - 2017
self.lbir1200_2017 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1200")
LearningUnitYearFactory(academic_year=self.academic_year, learning_container_year=self.lbir1200_2017)
self.lbir1250_2017 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1250")
LearningUnitYearFactory(academic_year=self.academic_year, learning_container_year=self.lbir1250_2017)
self.lbir1300_2017 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1300")
LearningUnitYearFactory(academic_year=self.academic_year, learning_container_year=self.lbir1300_2017)
self.lagro1200_2017 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LAGRO1200")
LearningUnitYearFactory(academic_year=self.academic_year, learning_container_year=self.lagro1200_2017)
# Create several learning container year - 2016
self.academic_year_2016 = AcademicYearFactory(year=2016)
self.lbir1200_2016 = LearningContainerYearFactory(academic_year=self.academic_year_2016, acronym="LBIR1200")
LearningUnitYearFactory(academic_year=self.academic_year_2016, learning_container_year=self.lbir1200_2016)
self.lbir1250_2016 = LearningContainerYearFactory(academic_year=self.academic_year_2016, acronym="LBIR1250")
LearningUnitYearFactory(academic_year=self.academic_year_2016, learning_container_year=self.lbir1250_2016)
# Creation Person/Tutor
Group.objects.create(name="tutors")
person = PersonFactory(global_id="98363454")
self.tutor = TutorFactory(person=person)
applications = [
_get_application_example(self.lbir1200_2017, '3.5', '35.6'), # Application 2017
_get_application_example(self.lbir1300_2017, '7.5', '25'), # Application 2017
_get_application_example(self.lbir1200_2016, '2', '30'), # Application 2016
]
self.attribution = AttributionNewFactory(global_id=person.global_id,
attributions=_get_attributions_default(),
applications=applications)
def test_get_application_list(self):
global_id = self.tutor.person.global_id
application_list = tutor_application.get_application_list(global_id, self.academic_year)
self.assertIsInstance(application_list, list)
self.assertEqual(len(application_list), 2)
application_list_in_2016 = tutor_application.get_application_list(global_id, self.academic_year_2016)
self.assertIsInstance(application_list_in_2016, list)
self.assertEqual(len(application_list_in_2016), 1)
def test_get_application_list_order_by(self):
self.attribution.applications = [
_get_application_example(self.lbir1200_2017, '3.5', '35.6'), # Application 2017
_get_application_example(self.lbir1250_2017, '5', '7', tutor_application_epc.UPDATE_OPERATION),
_get_application_example(self.lbir1300_2017, '7.5', '25') # Application 2017
]
self.attribution.save()
global_id = self.tutor.person.global_id
application_list = tutor_application.get_application_list(global_id, self.academic_year)
self.assertIsInstance(application_list, list)
self.assertEqual(len(application_list), 3)
# Check order
self.assertEqual(application_list[0]['acronym'], self.lbir1200_2017.acronym)
self.assertEqual(application_list[1]['acronym'], self.lbir1300_2017.acronym)
self.assertEqual(application_list[2]['acronym'], self.lbir1250_2017.acronym)
def test_get_application(self):
global_id = self.tutor.person.global_id
application_searched = tutor_application.get_application(global_id, self.lbir1200_2017)
self.assertTrue(application_searched)
self.assertIsInstance(application_searched, dict)
self.assertEqual(application_searched['acronym'], self.lbir1200_2017.acronym)
def test_get_application_not_found(self):
global_id = self.tutor.person.global_id
application_searched = tutor_application.get_application(global_id, self.lagro1200_2017)
self.assertFalse(application_searched)
def test_create_or_update_application_creation_on_existing_user(self):
application_to_create = _get_application_example(self.lbir1250_2017, '30', '20')
global_id = self.tutor.person.global_id
tutor_application.create_or_update_application(global_id, application_to_create)
application_list = tutor_application.get_application_list(global_id, self.academic_year)
self.assertEqual(len(application_list), 3) # We should have 3 applications now
# We should found the newest created
self.assertTrue(next(app for app in application_list if
app.get('acronym') == self.lbir1250_2017.acronym))
def test_create_or_update_application_creation_on_new_user(self):
# Create new tutor
new_tutor = TutorFactory(person=PersonFactory(global_id="59898988"))
# Submit tutor application
application_to_create = _get_application_example(self.lbir1250_2017, '30', '20')
global_id = new_tutor.person.global_id
tutor_application.create_or_update_application(global_id, application_to_create)
application_list = tutor_application.get_application_list(global_id, self.academic_year)
self.assertEqual(len(application_list), 1) # We should have 1 application
def test_create_or_update_application_update(self):
application_to_update = _get_application_example(self.lbir1200_2017, '0', '10')
global_id = self.tutor.person.global_id
tutor_application.create_or_update_application(global_id, application_to_update)
application_list = tutor_application.get_application_list(global_id, self.academic_year)
self.assertEqual(len(application_list), 2) # We should have 2 applications
application_updated = next(app for app in application_list if
app.get('acronym') == self.lbir1200_2017.acronym)
self.assertTrue(application_updated)
self.assertEqual(application_updated.get('acronym'), self.lbir1200_2017.acronym)
self.assertEqual(application_updated.get('charge_lecturing_asked'), Decimal(0))
self.assertEqual(application_updated.get('charge_practical_asked'), Decimal(10))
def test_get_application_list_with_none_lecturing_charge(self):
new_tutor = TutorFactory(person=PersonFactory(global_id="59898988"))
application_to_create = _get_application_example(self.lbir1200_2017, None, "15")
global_id = new_tutor.person.global_id
tutor_application.create_or_update_application(global_id, application_to_create)
application_list = tutor_application.get_application_list(global_id, self.academic_year)
application_created = application_list[0]
self.assertTrue(application_created)
self.assertEqual(application_created.get('acronym'), self.lbir1200_2017.acronym)
self.assertEqual(application_created.get('charge_lecturing_asked'), Decimal(0))
self.assertEqual(application_created.get('charge_practical_asked'), Decimal(15))
def test_get_application_list_with_none_practical_charge(self):
new_tutor = TutorFactory(person=PersonFactory(global_id="59898988"))
application_to_create = _get_application_example(self.lbir1200_2017, "15", None)
global_id = new_tutor.person.global_id
tutor_application.create_or_update_application(global_id, application_to_create)
application_list = tutor_application.get_application_list(global_id, self.academic_year)
application_created = application_list[0]
self.assertTrue(application_created)
self.assertEqual(application_created.get('acronym'), self.lbir1200_2017.acronym)
self.assertEqual(application_created.get('charge_lecturing_asked'), Decimal(15))
self.assertEqual(application_created.get('charge_practical_asked'), Decimal(0))
def test_pending_flag(self):
global_id = self.tutor.person.global_id
application_searched = tutor_application.get_application(global_id, self.lbir1200_2017)
self.assertTrue(application_searched)
tutor_application.set_pending_flag(global_id, application_searched, tutor_application_epc.UPDATE_OPERATION)
# Research in order to verify that have pending state
application_searched = tutor_application.get_application(global_id, self.lbir1200_2017)
self.assertEqual(application_searched['pending'], tutor_application_epc.UPDATE_OPERATION)
self.assertTrue(application_searched['updated_at'])
def test_validate_application(self):
global_id = self.tutor.person.global_id
application_to_create = _get_application_example(self.lbir1250_2017, '30', '20')
application_to_create['pending'] = tutor_application_epc.UPDATE_OPERATION
tutor_application.create_or_update_application(global_id, application_to_create)
# Check pending state
application_searched_not_validated = tutor_application.get_application(global_id, self.lbir1250_2017)
self.assertEqual(application_searched_not_validated['pending'], tutor_application_epc.UPDATE_OPERATION)
self.assertTrue(application_searched_not_validated['updated_at'])
sleep(1) # Wait 1 sec for testing updated_at field
# Validate
tutor_application.validate_application(global_id, self.lbir1250_2017.acronym,
self.lbir1250_2017.academic_year.year)
application_searched_validated = tutor_application.get_application(global_id, self.lbir1250_2017)
self.assertRaises(KeyError, lambda: application_searched_validated['pending'])
self.assertTrue(application_searched_validated['updated_at'])
self.assertTrue(application_searched_validated['updated_at'] >
application_searched_not_validated['updated_at'])
def test_delete_application(self):
global_id = self.tutor.person.global_id
# Before delete
application_searched = tutor_application.get_application(global_id, self.lbir1200_2017)
self.assertTrue(application_searched)
# Delete process
acronym_to_delete = self.lbir1200_2017.acronym
year_to_delete = self.lbir1200_2017.academic_year.year
tutor_application.delete_application(global_id, acronym_to_delete, year_to_delete)
# After delete
application_searched = tutor_application.get_application(global_id, self.lbir1200_2017)
self.assertFalse(application_searched)
class AttributionTest(TestCase):
def setUp(self):
# Creation Person/Tutor
Group.objects.create(name="tutors")
self.person = PersonFactory(global_id="98363454")
TutorFactory(person=self.person)
_create_multiple_academic_year()
self.current_academic_year = create_current_academic_year()
# Creation Json which will be store on attribution
attributions = _get_attributions_dict(self.current_academic_year.year)
self.attrib = AttributionNewFactory(global_id=self.person.global_id,
attributions=attributions)
def test_get_attribution_list(self):
attribution_list = attribution.get_attribution_list(
self.person.global_id, self.current_academic_year)
self.assertEqual(len(attribution_list), 3)
previous_year = self.current_academic_year.year - 1
academic_year_2016 = AcademicYear.objects.get(year=previous_year)
attribution_list = attribution.get_attribution_list(
self.person.global_id, academic_year_2016)
self.assertEqual(len(attribution_list), 1)
attribution_list = attribution.get_attribution_list(
self.person.global_id)
self.assertEqual(len(attribution_list), 3)
def test_get_attribution_list_empty(self):
academic_year = AcademicYearFactory(year=1990)
attribution_list = attribution.get_attribution_list(
self.person.global_id, academic_year)
self.assertFalse(attribution_list)
def test_get_attribution_order(self):
attribution_list = attribution.get_attribution_list(
self.person.global_id, self.current_academic_year)
self.assertEqual(len(attribution_list), 3)
self.assertEqual(attribution_list[0]['acronym'], "LAGRO1530")
self.assertEqual(attribution_list[1]['acronym'], "LBIR1200")
self.assertEqual(attribution_list[2]['acronym'], "LBIR1300")
def test_computes_volumes_total(self):
attribution_list = attribution.get_attribution_list(
self.person.global_id, self.current_academic_year)
volumes_total = attribution.get_volumes_total(attribution_list)
self.assertTrue(volumes_total)
self.assertEqual(
volumes_total.get(learning_component_year_type.LECTURING),
Decimal(53.5))
self.assertEqual(
volumes_total.get(
learning_component_year_type.PRACTICAL_EXERCISES),
Decimal(21.5))
def test_append_team_and_volume_delcared_vacant(self):
# Create Container Year and component
_create_learning_container_with_components(
acronym="LBIR1300",
academic_year=self.current_academic_year,
volume_lecturing=Decimal(15.5),
volume_practical_exercices=Decimal(5))
_create_learning_container_with_components(
acronym="LBIR1200",
academic_year=self.current_academic_year,
volume_lecturing=Decimal(30),
volume_practical_exercices=Decimal(75))
_create_learning_container_with_components("LAGRO1530",
self.current_academic_year,
Decimal(30), Decimal(30))
attribution_list = attribution.get_attribution_list(
self.person.global_id, self.current_academic_year)
self.assertEqual(attribution_list[0]['acronym'], "LAGRO1530")
self.assertEqual(attribution_list[0]['volume_lecturing_vacant'],
Decimal(30))
self.assertEqual(
attribution_list[0]['volume_practical_exercices_vacant'],
Decimal(30))
self.assertEqual(attribution_list[0]['team'], False)
self.assertEqual(attribution_list[1]['acronym'], "LBIR1200")
self.assertEqual(attribution_list[1]['volume_lecturing_vacant'],
Decimal(30))
self.assertEqual(
attribution_list[1]['volume_practical_exercices_vacant'],
Decimal(75))
self.assertEqual(attribution_list[1]['team'], False)
self.assertEqual(attribution_list[2]['acronym'], "LBIR1300")
self.assertEqual(attribution_list[2]['volume_lecturing_vacant'],
Decimal(15.5))
self.assertEqual(
attribution_list[2]['volume_practical_exercices_vacant'],
Decimal(5))
self.assertEqual(attribution_list[2]['team'], False)
def test_append_start_end_academic_year(self):
attribution_list = attribution.get_attribution_list(
self.person.global_id, self.current_academic_year)
self.assertEqual(attribution_list[0]['acronym'], "LAGRO1530")
self.assertTrue(attribution_list[0]['start_academic_year'])
self.assertEqual(attribution_list[0]['start_academic_year'].year, 2015)
self.assertEqual(attribution_list[0]['end_academic_year'].year,
self.current_academic_year.year)
self.assertEqual(attribution_list[1]['acronym'], "LBIR1200")
self.assertTrue(attribution_list[1]['start_academic_year'])
self.assertEqual(attribution_list[1]['start_academic_year'].year, 2013)
self.assertRaises(
KeyError,
lambda: attribution_list[1]['end_academic_year']) # No end year
self.assertEqual(attribution_list[2]['acronym'], "LBIR1300")
self.assertTrue(attribution_list[2]['start_academic_year'])
self.assertEqual(attribution_list[2]['start_academic_year'].year, 2015)
self.assertEqual(attribution_list[2]['end_academic_year'].year,
self.current_academic_year.year + 1)
def test_get_attribution_list_about_to_expire(self):
_create_learning_container_with_components("LAGRO1530",
self.current_academic_year,
Decimal(30), Decimal(30))
next_academic_year = AcademicYear.objects.get(
year=self.current_academic_year.year + 1)
_create_learning_container_with_components("LAGRO1530",
next_academic_year,
Decimal(30), Decimal(30))
attribution_list_about_to_expired = attribution.get_attribution_list_about_to_expire(
self.person.global_id, self.current_academic_year)
self.assertEqual(len(attribution_list_about_to_expired), 1)
self.assertTrue(attribution_list_about_to_expired[0]['is_renewable'])
self.assertIsNone(
attribution_list_about_to_expired[0]['not_renewable_reason'])
def test_get_attribution_list_about_to_expire_volume_pratical_lower(self):
_create_learning_container_with_components("LAGRO1530",
self.current_academic_year,
Decimal(30), Decimal(30))
next_academic_year = AcademicYear.objects.get(
year=self.current_academic_year.year + 1)
_create_learning_container_with_components("LAGRO1530",
next_academic_year,
Decimal(1), Decimal(30))
attribution_list_about_to_expired = attribution.get_attribution_list_about_to_expire(
self.person.global_id, self.current_academic_year)
self.assertEqual(len(attribution_list_about_to_expired), 1)
self.assertFalse(attribution_list_about_to_expired[0]['is_renewable'])
self.assertEqual(
attribution_list_about_to_expired[0]['not_renewable_reason'],
_("The vacant volume of the next academic year is lower than the current one"
))
def test_get_attribution_list_about_to_expire_volume_lecturing__lower(
self):
_create_learning_container_with_components("LAGRO1530",
self.current_academic_year,
Decimal(30), Decimal(30))
next_academic_year = AcademicYear.objects.get(
year=self.current_academic_year.year + 1)
_create_learning_container_with_components("LAGRO1530",
next_academic_year,
Decimal(30), Decimal(1))
attribution_list_about_to_expired = attribution.get_attribution_list_about_to_expire(
self.person.global_id, self.current_academic_year)
self.assertEqual(len(attribution_list_about_to_expired), 1)
self.assertFalse(attribution_list_about_to_expired[0]['is_renewable'])
self.assertEqual(
attribution_list_about_to_expired[0]['not_renewable_reason'],
_("The vacant volume of the next academic year is lower than the current one"
))
def test_get_attribution_list_about_to_expire_volume_zero_is_renewable(
self):
self.attrib.attributions = [{
'year': self.current_academic_year.year,
'acronym': 'LAGRO1530',
'title': 'Agrochimie élémentaire',
'weight': '5.00',
'LECTURING': '0',
'PRACTICAL_EXERCISES': '0',
'function': 'HOLDER',
'start_year': 2015,
'end_year': self.current_academic_year.year,
'is_substitute': False
}]
self.attrib.save()
_create_learning_container_with_components("LAGRO1530",
self.current_academic_year,
Decimal(30), Decimal(30))
next_academic_year = AcademicYear.objects.get(
year=self.current_academic_year.year + 1)
_create_learning_container_with_components("LAGRO1530",
next_academic_year,
Decimal(30), Decimal(30))
attribution_list_about_to_expired = attribution.get_attribution_list_about_to_expire(
self.person.global_id, self.current_academic_year)
self.assertEqual(len(attribution_list_about_to_expired), 1)
self.assertTrue(attribution_list_about_to_expired[0]['is_renewable'])
self.assertEqual(
attribution_list_about_to_expired[0]['not_renewable_reason'], None)
def test_get_attribution_list_with_substitute_is_not_renewable(self):
self.attrib.attributions = [{
'year': self.current_academic_year.year,
'acronym': 'LAGRO1530',
'title': 'Agrochimie élémentaire',
'weight': '5.00',
'LECTURING': '0',
'PRACTICAL_EXERCISES': '0',
'function': 'HOLDER',
'start_year': 2015,
'end_year': self.current_academic_year.year,
'is_substitute': True
}]
self.attrib.save()
_create_learning_container_with_components("LAGRO1530",
self.current_academic_year,
Decimal(30), Decimal(30))
next_academic_year = AcademicYear.objects.get(
year=self.current_academic_year.year + 1)
_create_learning_container_with_components("LAGRO1530",
next_academic_year,
Decimal(30), Decimal(30))
attribution_list_about_to_expired = attribution.get_attribution_list_about_to_expire(
self.person.global_id, self.current_academic_year)
self.assertEqual(len(attribution_list_about_to_expired), 1)
self.assertFalse(attribution_list_about_to_expired[0]['is_renewable'])
self.assertEqual(
attribution_list_about_to_expired[0]['not_renewable_reason'],
_('A substitute can not renew his function of substitute'))
def test_get_attribution_list_about_to_expire_already_applied(self):
_create_learning_container_with_components("LAGRO1530",
self.current_academic_year,
Decimal(30), Decimal(30))
next_academic_year = AcademicYear.objects.get(
year=self.current_academic_year.year + 1)
_create_learning_container_with_components("LAGRO1530",
next_academic_year,
Decimal(30), Decimal(30))
application = [{
'remark': 'This is the remarks',
'course_summary': 'This is the course summary',
'charge_lecturing_asked': 30,
'charge_practical_asked': 30,
'acronym': "LAGRO1530",
'year': next_academic_year.year,
'is_substitute': False
}]
self.attrib.applications = application
self.attrib.save()
attribution_list_about_to_expired = attribution.get_attribution_list_about_to_expire(
self.person.global_id, self.current_academic_year)
self.assertEqual(len(attribution_list_about_to_expired), 1)
self.assertFalse(attribution_list_about_to_expired[0]['is_renewable'])
self.assertEqual(
attribution_list_about_to_expired[0]['not_renewable_reason'],
_('An application has already been submitted'))
def test_calculate_effective_volume(self):
vol_tot = 10.0
planned_classes = 2
data = {'PLANNED_CLASSES': planned_classes, 'VOLUME_TOTAL': vol_tot}
self.assertEqual(attribution._calculate_effective_volume(data),
vol_tot * planned_classes)
def test_calculate_effective_volume_incorrect(self):
vol_tot = 10.0
planned_classes = -1
data = {'PLANNED_CLASSES': planned_classes, 'VOLUME_TOTAL': vol_tot}
self.assertEqual(attribution._calculate_effective_volume(data),
attribution.NO_CHARGE)
def test_calculate_effective_volume_no_volume_provided(self):
self.assertEqual(
attribution._calculate_effective_volume({'PLANNED_CLASSES': 1}),
attribution.NO_CHARGE)
def test_calculate_effective_volume_case_negative_volume(self):
vol_tot = -10.0
planned_classes = 1
data = {'PLANNED_CLASSES': planned_classes, 'VOLUME_TOTAL': vol_tot}
self.assertEqual(attribution._calculate_effective_volume(data),
attribution.NO_CHARGE)
def test_get_teachers_parameter_none(self):
self.assertIsNone(attribution.get_teachers(None, None))
self.assertIsNone(attribution.get_teachers('LCHM1111', None))
academic_year = AcademicYearFactory()
self.assertIsNone(attribution.get_teachers(None, academic_year))
def test_get_teachers_no_teacher_found(self):
self.assertIsNone(attribution.get_teachers('LCHM1111', 2017))
def test_get_2_teachers_in_order(self):
acronym_LCHM1111 = 'LCHM1111'
acronym_LDVLP2627 = 'LDVLP2627'
acronym_LDROI1110 = 'LDROI1110'
# Create first teacher with one attribution on LCHM1111 and others
person_first_alphabetical_order = PersonFactory(global_id='12345678',
last_name='Antonelli')
attribution_teacher_1_LCHM1111 = {
'year': 2017,
'acronym': acronym_LCHM1111
}
attributions_teacher1 = [
attribution_teacher_1_LCHM1111, {
'year': 2016,
'acronym': acronym_LDVLP2627
}, {
'year': 2017,
'acronym': acronym_LDVLP2627
}, {
'year': 2017,
'acronym': acronym_LDROI1110
}
]
AttributionNewFactory(
global_id=person_first_alphabetical_order.global_id,
attributions=attributions_teacher1)
# Create second teacher with one attribution on LCHM1111
person_second_alphabetical_order = PersonFactory(global_id='987654321',
last_name='Barnet')
attribution_teacher_2_LCHM1111 = {
'year': 2017,
'acronym': acronym_LCHM1111
}
attributions_teacher2 = [attribution_teacher_2_LCHM1111]
AttributionNewFactory(
global_id=person_second_alphabetical_order.global_id,
attributions=attributions_teacher2)
#
attributions_result = attribution.get_teachers(acronym_LCHM1111, 2017)
self.assertEqual(len(attributions_result), 2)
self.assertEqual(attributions_result[0][attribution.PERSON_KEY],
person_first_alphabetical_order)
def test_update_learning_unit_volume_no_components(self):
"""When no components found on database, the key 'lecturing_vol' / 'practical_exercises_vol' is set to 0.0"""
l_container = LearningContainerYearFactory(
acronym='LAGRO1530', academic_year=self.current_academic_year)
LearningUnitYearFactory(acronym='LAGRO1530',
academic_year=self.current_academic_year,
learning_container_year=l_container)
an_attribution = {
'year': 2017,
'acronym': 'LAGRO1530',
'title': 'Chimie complexe',
'weight': '5.00',
'LECTURING': '22.5',
'PRACTICAL_EXERCISES': '5.0',
'function': 'HOLDER',
'start_year': 2015,
'end_year': 2020
}
attribution.update_learning_unit_volume(an_attribution,
self.current_academic_year)
self.assertEqual(an_attribution['lecturing_vol'], Decimal(0.0))
self.assertEqual(an_attribution['practical_exercises_vol'],
Decimal(0.0))
def test_calculate_component_volume(self):
an_attribution = {
'year': 2017,
'acronym': 'LAGRO1530',
'title': 'Chimie complexe',
'weight': '5.00',
'LECTURING': '22.5',
'PRACTICAL_EXERCISES': '5.0',
'function': 'HOLDER',
'start_year': 2015,
'end_year': 2020
}
l_component_lecturing = LearningComponentYearFactory(
type=learning_component_year_type.LECTURING)
l_component_other = LearningComponentYearFactory(type=None)
components_computed = {
l_component_lecturing: {
'VOLUME_TOTAL': Decimal(15),
'PLANNED_CLASSES': 5
},
l_component_other: {
'VOLUME_TOTAL': Decimal(1),
'PLANNED_CLASSES': 1
}
}
attribution._calculate_component_volume(an_attribution,
components_computed)
self.assertEqual(an_attribution['lecturing_vol'],
Decimal(75)) # VOLUME_TOTAL * PLANNED_CLASSES
self.assertRaises(KeyError,
lambda: an_attribution['practical_exercises_vol'])
def test_get_attribution_vacant_none(self):
learning_container_yr = LearningContainerYearFactory()
self.assertIsNone(
attribution.get_attribution_vacant(learning_container_yr))
def test_format_no_volume(self):
attributions_without_volume = [{'year': 2018, 'acronym': 'LBIR1200'}]
attributions_formalized = attribution._format_str_volume_to_decimal(
attributions_without_volume)
self.assertEqual(attributions_formalized[0]['LECTURING'], 0.0)
self.assertEqual(attributions_formalized[0]['PRACTICAL_EXERCISES'],
0.0)
class TestTutorApplicationEpc(TestCase):
def setUp(self):
self.academic_year = AcademicYearFactory(year=2017)
external_id = tutor_application_epc.LEARNING_CONTAINER_YEAR_PREFIX_EXTERNAL_ID + '35654987_2017'
self.lbir1200 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1200",
external_id=external_id)
self.lagro2630 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LAGRO2630")
# Creation Person/Tutor
Group.objects.create(name="tutors")
person = PersonFactory(global_id="98363454")
external_id = tutor_application_epc.TUTOR_PREFIX_EXTERNAL_ID + '2089590559'
self.tutor = TutorFactory(external_id=external_id, person=person)
# Create two tutor applications
applications = [_get_application_example(self.lbir1200, '30.5', '40.5'),
_get_application_example(self.lagro2630, '12.5', '0')]
self.attribution = AttributionNewFactory(
global_id=person.global_id,
applications=applications
)
def test_extract_learning_container_year_epc_info(self):
learning_container_info = tutor_application_epc._extract_learning_container_year_epc_info('LBIR1200', 2017)
self.assertIsInstance(learning_container_info, dict)
self.assertEqual(learning_container_info['reference'], '35654987')
self.assertEqual(learning_container_info['year'], 2017)
def test_extract_learning_container_year_epc_info_empty(self):
learning_container_info = tutor_application_epc._extract_learning_container_year_epc_info('LBIR1250', 2017)
self.assertIsInstance(learning_container_info, dict)
self.assertFalse(learning_container_info)
def test_extract_learning_container_year_epc_info_with_external_id_empty(self):
self.lbir1200.external_id = None
self.lbir1200.save()
learning_container_info = tutor_application_epc._extract_learning_container_year_epc_info('LBIR1200', 2017)
self.assertIsInstance(learning_container_info, dict)
self.assertFalse(learning_container_info)
def test_convert_to_epc_application(self):
person = self.tutor.person
application = _get_application_example(self.lbir1200, '30.5', '40.5')
epc_message = tutor_application_epc._convert_to_epc_application(application=application)
self.assertTrue(epc_message)
self.assertEqual(epc_message['remark'], application['remark'])
self.assertEqual(epc_message['course_summary'], application['course_summary'])
self.assertEqual(epc_message['lecturing_allocation'], application['charge_lecturing_asked'])
self.assertEqual(epc_message['practical_allocation'], application['charge_practical_asked'])
self.assertIsInstance(epc_message['learning_container_year'], dict)
self.assertEqual(epc_message['learning_container_year']['reference'], '35654987')
self.assertEqual(epc_message['learning_container_year']['year'], 2017)
def test_process_message_delete_operation(self):
person = self.tutor.person
self.assertEqual(len(self.attribution.applications), 2)
body = {
'operation': tutor_application_epc.DELETE_OPERATION,
'global_id': person.global_id,
'learning_container_year': {
'acronym': 'LBIR1200',
'year': 2017
}
}
body_encoded = bytearray(json.dumps(body), "utf-8")
tutor_application_epc.process_message(body_encoded)
# Check if the application is removed
self.attribution.refresh_from_db()
self.assertEqual(len(self.attribution.applications), 1)
attribution_left = self.attribution.applications[0]
self.assertEqual(attribution_left['acronym'], self.lagro2630.acronym)
def test_process_message_update_operation(self):
person = self.tutor.person
_set_all_application_in_pending_state(self.attribution.applications)
self.attribution.save()
## Check if all are in pending
self.assertEqual(len(self.attribution.applications), 2)
self.assertEqual(self.attribution.applications[0]['pending'], tutor_application_epc.UPDATE_OPERATION)
self.assertEqual(self.attribution.applications[1]['pending'], tutor_application_epc.UPDATE_OPERATION)
body = {
'operation': tutor_application_epc.UPDATE_OPERATION,
'global_id': person.global_id,
'learning_container_year': {
'acronym': 'LBIR1200',
'year': 2017
}
}
body_encoded = bytearray(json.dumps(body), "utf-8")
tutor_application_epc.process_message(body_encoded)
# Check if the application is removed
self.attribution.refresh_from_db()
applications_not_pending = [application for application in self.attribution.applications if
not "pending" in application]
self.assertEqual(len(applications_not_pending), 1)
def test_process_message_with_error_operation(self):
person = self.tutor.person
_set_all_application_in_pending_state(self.attribution.applications)
self.attribution.save()
## Check if all are in pending
self.assertEqual(len(self.attribution.applications), 2)
self.assertEqual(self.attribution.applications[0]['pending'], tutor_application_epc.UPDATE_OPERATION)
self.assertEqual(self.attribution.applications[1]['pending'], tutor_application_epc.UPDATE_OPERATION)
body = {
'operation': tutor_application_epc.UPDATE_OPERATION,
'global_id': person.global_id,
'learning_container_year': {
'acronym': 'LBIR1200',
'year': 2017
},
tutor_application_epc.ERROR_EPC_FIELD: 'An error occured in EPC'
}
body_encoded = bytearray(json.dumps(body), "utf-8")
tutor_application_epc.process_message(body_encoded)
# Check if the application is removed
self.attribution.refresh_from_db()
applications_not_pending = [application for application in self.attribution.applications if
not "pending" in application]
self.assertEqual(len(applications_not_pending), 0) # No changed
class TestTutorApplicationEpc(TestCase):
def setUp(self):
self.academic_year = AcademicYearFactory(year=2017)
external_id = tutor_application_osis.LEARNING_CONTAINER_YEAR_PREFIX_EXTERNAL_ID + '35654987_2017'
self.lbir1200 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1200",
external_id=external_id)
self.lagro2630 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LAGRO2630")
self.bio = LearningContainerYearFactory(academic_year=self.academic_year, acronym="BIO5213")
# Creation Person/Tutor
Group.objects.create(name="tutors")
person = PersonFactory(global_id="98363454")
external_id = tutor_application_osis.TUTOR_PREFIX_EXTERNAL_ID + '2089590559'
self.tutor = TutorFactory(external_id=external_id, person=person)
# Create two tutor applications
applications = [_get_application_example(self.lbir1200, '30.5', '40.5'),
_get_application_example(self.lagro2630, '12.5', '10.5'),
_get_application_example(self.bio, '10.5', '9.5')]
self.attribution_new = AttributionNewFactory(
global_id=person.global_id,
applications=applications
)
def test_process_message_update_operation(self):
person = self.tutor.person
_set_all_application_in_pending_state(self.attribution_new.applications)
self.attribution_new.save()
self.assertEqual(len(self.attribution_new.applications), 3)
self.assertEqual(self.attribution_new.applications[0]['pending'], tutor_application_osis.UPDATE_OPERATION)
self.assertEqual(self.attribution_new.applications[1]['pending'], tutor_application_osis.UPDATE_OPERATION)
body = [{
'global_id': person.global_id,
'tutor_applications': [{
'acronym': 'LBIR1200',
'year': self.academic_year.year,
'charge_lecturing_asked': '0',
'charge_practical_asked': '0',
'last_changed': "2020-12-08 09:58:57+00:00"
}]
}]
body_encoded = bytearray(json.dumps(body), "utf-8")
tutor_application_osis.process_message(body_encoded)
self.attribution_new.refresh_from_db()
self.assertEqual(self.attribution_new.applications[0]['charge_lecturing_asked'], '0')
def test_process_message_no_update_operation(self):
person = self.tutor.person
_set_all_application_in_pending_state(self.attribution_new.applications)
self.attribution_new.save()
self.assertEqual(len(self.attribution_new.applications), 3)
self.assertEqual(self.attribution_new.applications[0]['pending'], tutor_application_osis.UPDATE_OPERATION)
self.assertEqual(self.attribution_new.applications[1]['pending'], tutor_application_osis.UPDATE_OPERATION)
body = [{
'global_id': person.global_id,
'tutor_applications': [{
'acronym': 'LAGRO2630',
'year': self.academic_year.year,
'charge_lecturing_asked': '0',
'charge_practical_asked': '0',
'last_changed': "2013-12-08 09:58:57+00:00"
}]
}]
body_encoded = bytearray(json.dumps(body), "utf-8")
tutor_application_osis.process_message(body_encoded)
self.attribution_new.refresh_from_db()
self.assertEqual(self.attribution_new.applications[0]['charge_lecturing_asked'], '12.5')
def test_process_message_with_delete_pending(self):
person = self.tutor.person
_set_all_application_in_pending_delete(self.attribution_new.applications)
self.attribution_new.save()
self.assertEqual(len(self.attribution_new.applications), 3)
body = [{
'global_id': person.global_id,
'tutor_applications': [{
'acronym': 'LAGRO2630',
'year': self.academic_year.year,
'charge_lecturing_asked': '0',
'charge_practical_asked': '0',
'last_changed': "2016-12-08 09:58:57+00:00"
}]
}]
body_encoded = bytearray(json.dumps(body), "utf-8")
tutor_application_osis.process_message(body_encoded)
self.attribution_new.refresh_from_db()
self.assertEqual(len(self.attribution_new.applications), 1)
self.assertEqual(self.attribution_new.applications[0]['charge_lecturing_asked'], '12.5')
def test_process_when_attribution_new_not_exist(self):
body = [{
'global_id': "321654",
'tutor_applications': [{
'acronym': 'LAGRO2630',
'year': self.academic_year.year,
'charge_lecturing_asked': '0',
'charge_practical_asked': '0',
'last_changed': "2016-12-08 09:58:57+00:00"
}]
}]
self.assertEqual(find_by_global_id("321654"), None)
body_encoded = bytearray(json.dumps(body), "utf-8")
tutor_application_osis.process_message(body_encoded)
self.assertEqual(find_by_global_id("321654").global_id, "321654")
def test_process_with_many_change(self):
person = self.tutor.person
self.assertEqual(len(self.attribution_new.applications), 3)
self.attribution_new.applications[0]['pending'] = tutor_application_osis.UPDATE_OPERATION
self.attribution_new.applications[1]['pending'] = tutor_application_osis.DELETE_OPERATION
self.attribution_new.save()
self.attribution_new.refresh_from_db()
body = [{
'global_id': person.global_id,
'tutor_applications': [
{'acronym': 'LAGRO2630',
'year': self.academic_year.year,
'charge_lecturing_asked': '0',
'charge_practical_asked': '0',
'last_changed': "2021-12-08 09:58:57+00:00"
},
{'acronym': 'LBIR1200',
'year': self.academic_year.year,
'charge_lecturing_asked': '0',
'charge_practical_asked': '0',
'last_changed': "2013-12-08 09:58:57+00:00"
},
{'acronym': 'BIO5213',
'year': self.academic_year.year,
'charge_lecturing_asked': '0',
'charge_practical_asked': '0',
'last_changed': "2013-12-08 09:58:57+00:00"}
]
}]
body_encoded = bytearray(json.dumps(body), "utf-8")
tutor_application_osis.process_message(body_encoded)
self.attribution_new.refresh_from_db()
self.assertEqual(len(self.attribution_new.applications), 3)
self.assertEqual(self.attribution_new.applications[0]['charge_lecturing_asked'], '12.5')
self.assertEqual(self.attribution_new.applications[1]['charge_lecturing_asked'], '30.5')
self.assertEqual(self.attribution_new.applications[2]['charge_lecturing_asked'], '0')
class TestOnlineApplication(TestCase):
def setUp(self):
# Create Group tutor
Group.objects.create(name="tutors")
# Create user
user = UserFactory(username="******")
person = PersonFactory(global_id="578945612", user=user)
self.tutor = TutorFactory(person=person)
# Add permission and log into app
add_permission(user, "can_access_attribution_application")
self.client.force_login(user)
# Create current academic year
self.current_academic_year = create_current_academic_year()
# Create application year
# Application is always next year
self.application_academic_year = AcademicYearFactory(
year=self.current_academic_year.year + 1
)
# Create Event to allow teacher to register
start_date = datetime.datetime.today() - datetime.timedelta(days=10)
end_date = datetime.datetime.today() + datetime.timedelta(days=15)
self.academic_calendar = AcademicCalendarFactory(
academic_year=self.current_academic_year,
reference=academic_calendar_type.TEACHING_CHARGE_APPLICATION,
start_date=start_date,
end_date=end_date
)
self.agro_entity = EntityFactory()
self.agro_entity_version = EntityVersionFactory(entity=self.agro_entity, acronym="AGRO",
entity_type='FACULTY',
start_date=self.academic_calendar.start_date,
end_date=self.academic_calendar.end_date)
self.drt_entity = EntityFactory()
self.drt_entity_version = EntityVersionFactory(entity=self.drt_entity, acronym="DRT",
entity_type='FACULTY',
start_date=self.academic_calendar.start_date,
end_date=self.academic_calendar.end_date)
# Creation context with multiple learning container year
self._create_multiple_learning_container_year()
self.attribution = AttributionNewFactory(
global_id=person.global_id,
applications=self._get_default_application_list(),
attributions=self._get_default_attribution_list()
)
def test_redirection_to_outside_encoding_period(self):
# Remove teaching charge application event
self.academic_calendar.delete()
url = reverse('applications_overview')
url_outside = reverse('outside_applications_period')
response = self.client.get(url)
self.assertRedirects(response, "%s?next=%s" % (url_outside, url)) # Redirection
def test_message_outside_encoding_period(self):
# Remove teaching charge application event
self.academic_calendar.delete()
url = reverse('outside_applications_period')
response = self.client.get(url)
messages = list(response.context['messages'])
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0].tags, 'warning')
self.assertEqual(messages[0].message, _('The period of online application is closed'))
def test_applications_overview(self):
url = reverse('applications_overview')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertEqual(context['a_tutor'], self.tutor)
self.assertEqual(context['current_academic_year'], self.current_academic_year)
self.assertEqual(context['application_year'], self.application_academic_year)
self.assertEqual(len(context['attributions']), 1)
self.assertEqual(context['attributions'][0]['acronym'], self.lagro2500_next.acronym)
self.assertEqual(len(context['applications']), 1)
self.assertEqual(context['applications'][0]['acronym'], self.lagro1600_next.acronym)
self.assertEqual(len(context['attributions_about_to_expire']), 1)
self.assertEqual(context['attributions_about_to_expire'][0]['acronym'], self.lbir1300_current.acronym)
def test_applications_overview_post_method_not_allowed(self):
url = reverse('applications_overview')
response = self.client.post(url)
self.assertEqual(response.status_code, 405)
def test_search_vacant_attribution_initial(self):
url = reverse('vacant_attributions_search')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
context = response.context[0]
self.assertEqual(context['a_tutor'], self.tutor)
self.assertTrue(context['search_form'])
self.assertIsNone(context['attributions_vacant'])
def test_search_vacant_attribution_post_not_allowed(self):
url = reverse('vacant_attributions_search')
response = self.client.post(url)
self.assertEqual(response.status_code, 405)
def test_search_vacant_attribution_search_list(self):
url = reverse('vacant_attributions_search')
response = self.client.get(url, data={'learning_container_acronym': 'LAGRO'})
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertEqual(context['a_tutor'], self.tutor)
self.assertTrue(context['search_form'])
self.assertEqual(len(context['attributions_vacant']), 2)
# Check if LAGRO1600 have the boolean already applied
self.assertTrue((next(attrib for attrib in context['attributions_vacant']
if attrib.get('acronym') == self.lagro1600_next.acronym and
attrib.get('already_applied')), False))
def test_search_vacant_attribution_search_list_by_faculty(self):
url = reverse('vacant_attributions_search')
response = self.client.get(
url, data={
'learning_container_acronym': 'LAGRO',
'faculty': self.agro_entity_version.id
}
)
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertEqual(len(context['attributions_vacant']), 2)
def test_search_vacant_attribution_with_declaration_vac_not_allowed(self):
# Create container with type_declaration_vacant not in [RESEVED_FOR_INTERNS, OPEN_FOR_EXTERNS]
self.lagro1234_current = _create_learning_container_with_components("LAGRO1234", self.current_academic_year)
# Creation learning container for next academic year [==> application academic year]
self.lagro1234_next = _create_learning_container_with_components\
("LAGRO1234", self.application_academic_year, 70, 70,
type_declaration_vacant=vacant_declaration_type.DO_NOT_ASSIGN)
url = reverse('vacant_attributions_search')
response = self.client.get(url, data={'learning_container_acronym': 'LAGRO1234'})
self.assertEqual(response.status_code, 200)
context = response.context[0]
self.assertEqual(context['a_tutor'], self.tutor)
self.assertTrue(context['search_form'])
self.assertFalse(context['attributions_vacant'])
def test_renew_applications(self):
url = reverse('renew_applications')
post_data = {'learning_container_year_' + self.lbir1300_next.acronym: 'on'}
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302) # redirection
self.attribution.refresh_from_db()
self.assertEqual(len(self.attribution.applications), 2) # Now we have two applications
def test_renew_applications_with_bad_learning_container(self):
url = reverse('renew_applications')
post_data = {'learning_container_year_' + self.lagro2500_next.acronym: 'on'}
response = self.client.post(url, data=post_data, follow=True)
self.assertEqual(response.status_code, 200)
messages = list(response.context['messages'])
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0].tags, 'error')
self.assertEqual(messages[0].message, _('No attribution renewed'))
def test_renew_applications_method_not_allowed(self):
url = reverse('renew_applications')
response = self.client.get(url)
self.assertEqual(response.status_code, 405)
def test_delete_application(self):
url = reverse('delete_tutor_application', kwargs={'learning_container_year_id': self.lagro1600_next.id})
response = self.client.post(url)
self.assertEqual(response.status_code, 302) # redirection
self.attribution.refresh_from_db()
# pending flag must be set to 'deleted'
self.assertTrue((next(attrib for attrib in self.attribution.applications
if attrib.get('acronym') == self.lagro1600_next.acronym and
attrib.get('pending') == tutor_application_epc.DELETE_OPERATION), False))
def test_delete_application_with_wrong_container(self):
url = reverse('delete_tutor_application', kwargs={'learning_container_year_id': self.lbir1300_next.id})
response = self.client.post(url)
self.assertEqual(response.status_code, 404) # Not found
def test_delete_application_method_not_allowed(self):
url = reverse('delete_tutor_application', kwargs={'learning_container_year_id': self.lagro1600_next.id})
response = self.client.get(url)
self.assertEqual(response.status_code, 405)
def test_get_edit_application_form(self):
url = reverse('create_or_update_tutor_application',
kwargs={'learning_container_year_id': self.lagro1600_next.id})
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
context = response.context[0]
self.assertEqual(context['a_tutor'], self.tutor)
self.assertEqual(context['learning_container_year'], self.lagro1600_next)
self.assertTrue(context['form'])
def test_post_edit_application_form(self):
url = reverse('create_or_update_tutor_application',
kwargs={'learning_container_year_id': self.lagro1600_next.id})
post_data = _get_application_example(self.lagro1600_next, '54', '7')
response = self.client.post(url, data=post_data, follow=True)
self.assertEqual(response.status_code, 200)
self.attribution.refresh_from_db()
self.assertEqual(len(self.attribution.applications), 1)
self.assertEqual(self.attribution.applications[0]['charge_lecturing_asked'], '54.0')
self.assertEqual(self.attribution.applications[0]['charge_practical_asked'], '7.0')
self.assertEqual(self.attribution.applications[0]['pending'], tutor_application_epc.UPDATE_OPERATION)
def test_post_edit_application_form_with_empty_value(self):
url = reverse('create_or_update_tutor_application',
kwargs={'learning_container_year_id': self.lagro1600_next.id})
post_data = _get_application_example(self.lagro1600_next, None, None)
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 200)
context = response.context[0]
self.assertTrue(context.get('form'))
form = context['form']
self.assertTrue(form.errors) # Not valid because not number entered
def test_post_edit_application_form_with_empty_lecturing_value(self):
url = reverse('create_or_update_tutor_application',
kwargs={'learning_container_year_id': self.lagro1600_next.id})
post_data = _get_application_example(self.lagro1600_next, "15", "")
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302)
self.attribution.refresh_from_db()
self.assertEqual(len(self.attribution.applications), 1)
self.assertEqual(self.attribution.applications[0]['charge_lecturing_asked'], '15.0')
self.assertEqual(self.attribution.applications[0]['charge_practical_asked'], '0.0')
self.assertEqual(self.attribution.applications[0]['pending'], tutor_application_epc.UPDATE_OPERATION)
def test_post_edit_application_form_with_value_under_zero(self):
url = reverse('create_or_update_tutor_application',
kwargs={'learning_container_year_id': self.lagro1600_next.id})
post_data = _get_application_example(self.lagro1600_next, '-1', '5')
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 200)
context = response.context[0]
self.assertTrue(context.get('form'))
form = context['form']
self.assertTrue(form.errors) # Not valid because -1 entered
def test_post_overview_with_lecturing_and_practical_component_partim(self):
lbira2101a_next = _create_learning_container_with_components("LBIRA2101A", self.application_academic_year,
volume_lecturing=20, volume_practical_exercices=20,
subtype=learning_unit_year_subtypes.PARTIM)
lbira2101a_current = _create_learning_container_with_components(
"LBIRA2101A", self.current_academic_year,
volume_lecturing=20, volume_practical_exercices=20,
subtype=learning_unit_year_subtypes.PARTIM)
_link_components_and_learning_unit_year_to_container(lbira2101a_current, "LBIRA2101",
subtype=learning_unit_year_subtypes.FULL)
_link_components_and_learning_unit_year_to_container(lbira2101a_next, "LBIRA2101",
subtype=learning_unit_year_subtypes.FULL)
self.attribution.delete()
self.attribution = AttributionNewFactory(
global_id=self.tutor.person.global_id,
applications=[_get_application_example(lbira2101a_next, "10", "10")]
)
url = reverse('applications_overview')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
context = response.context[0]
self.assertEqual(len(context['applications']), 1)
self.assertEqual(context['applications'][0]['acronym'], lbira2101a_next.acronym)
with self.assertRaises(KeyError):
context['applications'][0]['PRACTICAL_EXERCISES']
with self.assertRaises(KeyError):
context['applications'][0]['LECTURING']
def _create_multiple_learning_container_year(self):
# Creation learning container for current academic year
self.lbir1200_current = _create_learning_container_with_components("LBIR1200", self.current_academic_year)
self.lbir1300_current = _create_learning_container_with_components("LBIR1300", self.current_academic_year)
self.ldroi1500_current = _create_learning_container_with_components("LDROI1500", self.current_academic_year)
# Creation learning container for next academic year [==> application academic year]
self.lbir1200_next = _create_learning_container_with_components("LBIR1200", self.application_academic_year,
70, 70)
self.lbir1300_next = _create_learning_container_with_components("LBIR1300", self.application_academic_year,
60, 60)
self.lagro1600_next = _create_learning_container_with_components("LAGRO1600", self.application_academic_year,
54, 7)
self.lagro2500_next = _create_learning_container_with_components("LAGRO2500", self.application_academic_year,
0, 70)
self._create_entity_container_yrs()
def _get_default_application_list(self):
return [
_get_application_example(self.lagro1600_next, '15', '0')
]
def _get_default_attribution_list(self):
return [
# Attribution in current year
_get_attribution_example(self.lbir1200_current, '20.0', '31.5', 2015, 2019),
_get_attribution_example(self.lbir1300_current, '21.5', '40', 2015, self.current_academic_year.year),
# Attribution in next year
_get_attribution_example(self.lagro2500_next, '29', '10', 2015, 2020)
]
def _create_entity_container_yrs(self):
self.lbir1200_current.allocation_entity = self.agro_entity
self.lbir1200_current.save()
self.lbir1300_current.allocation_entity = self.agro_entity
self.lbir1300_current.save()
self.lbir1200_next.allocation_entity = self.agro_entity
self.lbir1200_next.save()
self.lbir1300_next.allocation_entity = self.agro_entity
self.lbir1300_next.save()
self.lagro1600_next.allocation_entity = self.agro_entity
self.lagro1600_next.save()
self.lagro2500_next.allocation_entity = self.agro_entity
self.lagro2500_next.save()
self.ldroi1500_current.allocation_entity = self.drt_entity
self.ldroi1500_current.save()
def test_find_no_attribution(self):
AttributionNewFactory(global_id="123456789", attributions=[])
results = mdl_attribution.attribution_new.find_teachers(
LCHM1111, YEAR_2017)
self.assertEqual(len(results), 0)
