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 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)