class LearningUnitYearWithContextTestCase(TestCase):
def setUp(self):
self.component_with_repartition = LearningComponentYearFactory(
hourly_volume_total_annual=15.0,
planned_classes=3,
repartition_volume_requirement_entity=20.0,
repartition_volume_additional_entity_1=10.0,
repartition_volume_additional_entity_2=15.0,
)
self.component_without_repartition = LearningComponentYearFactory(
hourly_volume_total_annual=15.0,
planned_classes=3,
repartition_volume_requirement_entity=None,
repartition_volume_additional_entity_1=None,
repartition_volume_additional_entity_2=None,
)
def test_repartition_volumes_property(self):
container_year = self.component_with_repartition.learning_unit_year.learning_container_year
container_year.set_entities({
entity_types.REQUIREMENT_ENTITY:
EntityFactory(),
entity_types.ADDITIONAL_REQUIREMENT_ENTITY_1:
EntityFactory(),
entity_types.ADDITIONAL_REQUIREMENT_ENTITY_2:
EntityFactory(),
})
container_year.save()
expected_result = {
"REQUIREMENT_ENTITY": 20.0,
"ADDITIONAL_REQUIREMENT_ENTITY_1": 10.0,
"ADDITIONAL_REQUIREMENT_ENTITY_2": 15.0,
}
self.assertDictEqual(
self.component_with_repartition.repartition_volumes,
expected_result)
expected_result = {
"REQUIREMENT_ENTITY": None,
"ADDITIONAL_REQUIREMENT_ENTITY_1": None,
"ADDITIONAL_REQUIREMENT_ENTITY_2": None,
}
self.assertDictEqual(
self.component_without_repartition.repartition_volumes,
expected_result)
def test_vol_global(self):
self.assertIsInstance(self.component_with_repartition.vol_global,
float)
self.assertEqual(self.component_with_repartition.vol_global, 45.0)
def test_vol_global_when_repartition_volumes_are_none(self):
self.assertIsInstance(self.component_without_repartition.vol_global,
float)
self.assertEqual(self.component_without_repartition.vol_global, 45.0)
def test_set_repartition_volume(self):
new_repartition_value = 1.0
self.component_without_repartition.set_repartition_volume(
entity_types.REQUIREMENT_ENTITY, new_repartition_value)
self.assertEqual(
self.component_without_repartition.
repartition_volume_requirement_entity, new_repartition_value)
self.component_without_repartition.set_repartition_volume(
entity_types.ADDITIONAL_REQUIREMENT_ENTITY_1,
new_repartition_value)
self.assertEqual(
self.component_without_repartition.
repartition_volume_requirement_entity, new_repartition_value)
self.component_without_repartition.set_repartition_volume(
entity_types.ADDITIONAL_REQUIREMENT_ENTITY_1,
new_repartition_value)
self.assertEqual(
self.component_without_repartition.
repartition_volume_requirement_entity, new_repartition_value)
self.component_without_repartition.refresh_from_db()
def test_set_repartition_volumes(self):
new_repartition_volumes = {
entity_types.REQUIREMENT_ENTITY: 1.0,
entity_types.ADDITIONAL_REQUIREMENT_ENTITY_1: 2.0,
entity_types.ADDITIONAL_REQUIREMENT_ENTITY_2: 3.0,
}
self.component_without_repartition.set_repartition_volumes(
new_repartition_volumes)
self.assertEqual(
self.component_without_repartition.
repartition_volume_requirement_entity, 1.0)
self.assertEqual(
self.component_without_repartition.
repartition_volume_additional_entity_1, 2.0)
self.assertEqual(
self.component_without_repartition.
repartition_volume_additional_entity_2, 3.0)
self.component_without_repartition.refresh_from_db()
class LearningUnitViewTestCase(TestCase):
def setUp(self):
today = datetime.date.today()
self.academic_year_1 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 1),
end_date=today.replace(year=today.year + 2),
year=today.year + 1)
self.academic_year_2 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 2),
end_date=today.replace(year=today.year + 3),
year=today.year + 2)
self.academic_year_3 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 3),
end_date=today.replace(year=today.year + 4),
year=today.year + 3)
self.academic_year_4 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 4),
end_date=today.replace(year=today.year + 5),
year=today.year + 4)
self.academic_year_5 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 5),
end_date=today.replace(year=today.year + 6),
year=today.year + 5)
self.academic_year_6 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 6),
end_date=today.replace(year=today.year + 7),
year=today.year + 6)
self.current_academic_year = AcademicYearFactory(
start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
super(AcademicYear, self.academic_year_1).save()
super(AcademicYear, self.academic_year_2).save()
super(AcademicYear, self.academic_year_3).save()
super(AcademicYear, self.academic_year_4).save()
super(AcademicYear, self.academic_year_5).save()
super(AcademicYear, self.academic_year_6).save()
self.learning_container_yr = LearningContainerYearFactory(
academic_year=self.current_academic_year)
self.learning_component_yr = LearningComponentYearFactory(
learning_container_year=self.learning_container_yr)
self.organization = OrganizationFactory(type=organization_type.MAIN)
self.country = CountryFactory()
self.entity = EntityFactory(country=self.country,
organization=self.organization)
self.entity_2 = EntityFactory(country=self.country,
organization=self.organization)
self.entity_3 = EntityFactory(country=self.country,
organization=self.organization)
self.entity_container_yr = EntityContainerYearFactory(
learning_container_year=self.learning_container_yr,
type=entity_container_year_link_type.REQUIREMENT_ENTITY,
entity=self.entity)
self.entity_container_yr_2 = EntityContainerYearFactory(
learning_container_year=self.learning_container_yr,
type=entity_container_year_link_type.REQUIREMENT_ENTITY,
entity=self.entity_2)
self.entity_container_yr_3 = EntityContainerYearFactory(
learning_container_year=self.learning_container_yr,
type=entity_container_year_link_type.REQUIREMENT_ENTITY,
entity=self.entity_3)
self.entity_version = EntityVersionFactory(
entity=self.entity,
entity_type=entity_type.SCHOOL,
start_date=today,
end_date=today.replace(year=today.year + 1))
self.campus = CampusFactory(organization=self.organization,
is_administration=True,
code="L")
self.language = LanguageFactory(code='FR')
self.a_superuser = SuperUserFactory()
self.person = PersonFactory(user=self.a_superuser)
PersonEntityFactory(person=self.person, entity=self.entity)
PersonEntityFactory(person=self.person, entity=self.entity_2)
PersonEntityFactory(person=self.person, entity=self.entity_3)
self.client.force_login(self.a_superuser)
@mock.patch('base.views.layout.render')
def test_learning_units(self, mock_render):
request_factory = RequestFactory()
request = request_factory.get(reverse('learning_units'))
request.user = self.a_superuser
from base.views.learning_unit import learning_units
learning_units(request)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_units.html')
self.assertEqual(context['current_academic_year'],
self.current_academic_year)
self.assertEqual(len(context['academic_years']), 7)
@mock.patch('base.views.layout.render')
def test_learning_units_search(self, mock_render):
request_factory = RequestFactory()
request = request_factory.get(reverse('learning_units'))
request.user = self.a_superuser
from base.views.learning_unit import learning_units
learning_units(request)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_units.html')
self.assertEqual(context['academic_years'].count(), 7)
self.assertEqual(context['current_academic_year'],
self.current_academic_year)
self.assertEqual(
len(context['types']),
len(learning_unit_year_subtypes.LEARNING_UNIT_YEAR_SUBTYPES))
self.assertEqual(
len(context['container_types']),
len(learning_container_year_types.LEARNING_CONTAINER_YEAR_TYPES))
self.assertTrue(context['experimental_phase'])
self.assertIsNone(context['learning_units'])
@mock.patch('base.views.layout.render')
def test_learning_units_search_with_acronym_filtering(self, mock_render):
self._prepare_context_learning_units_search()
request_factory = RequestFactory()
filter_data = {
'academic_year_id': self.current_academic_year.id,
'status': True,
'acronym': 'LBIR'
}
request = request_factory.get(reverse('learning_units'),
data=filter_data)
request.user = self.a_superuser
from base.views.learning_unit import learning_units
learning_units(request)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_units.html')
self.assertEqual(len(context['learning_units']), 3)
@mock.patch('base.views.layout.render')
def test_learning_units_search_by_acronym_with_valid_regex(
self, mock_render):
self._prepare_context_learning_units_search()
request_factory = RequestFactory()
filter_data = {
'academic_year_id': self.current_academic_year.id,
'status': True,
'acronym': '^DRT.+A'
}
request = request_factory.get(reverse('learning_units'),
data=filter_data)
request.user = self.a_superuser
from base.views.learning_unit import learning_units
learning_units(request)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_units.html')
self.assertEqual(len(context['learning_units']), 1)
@mock.patch('base.views.layout.render')
def test_learning_units_search_by_acronym_with_invalid_regex(
self, mock_render):
self._prepare_context_learning_units_search()
request_factory = RequestFactory()
filter_data = {
'academic_year_id': self.current_academic_year.id,
'status': True,
'acronym': '^LB(+)2+'
}
request = request_factory.get(reverse('learning_units'),
data=filter_data)
request.user = self.a_superuser
from base.views.learning_unit import learning_units
learning_units(request)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_units.html')
self.assertEqual(context['form'].errors['acronym'],
[_('LU_ERRORS_INVALID_REGEX_SYNTAX')])
@mock.patch('base.views.layout.render')
def test_learning_units_search_with_requirement_entity(self, mock_render):
self._prepare_context_learning_units_search()
request_factory = RequestFactory()
filter_data = {
'academic_year_id': self.current_academic_year.id,
'requirement_entity_acronym': 'ENVI'
}
request = request_factory.get(reverse('learning_units'),
data=filter_data)
request.user = self.a_superuser
from base.views.learning_unit import learning_units
learning_units(request)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_units.html')
self.assertEqual(len(context['learning_units']), 1)
@mock.patch('base.views.layout.render')
def test_learning_units_search_with_requirement_entity_and_subord(
self, mock_render):
self._prepare_context_learning_units_search()
request_factory = RequestFactory()
filter_data = {
'academic_year_id': self.current_academic_year.id,
'requirement_entity_acronym': 'AGRO',
'with_entity_subordinated': True
}
request = request_factory.get(reverse('learning_units'),
data=filter_data)
request.user = self.a_superuser
from base.views.learning_unit import learning_units
learning_units(request)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_units.html')
self.assertEqual(len(context['learning_units']), 6)
@mock.patch('base.views.layout.render')
def test_learning_units_search_with_service_course(self, mock_render):
self._prepare_context_learning_units_search()
request_factory = RequestFactory()
filter_data = {
'academic_year_id': self.current_academic_year.id,
'requirement_entity_acronym': 'AGRO',
'with_entity_subordinated': True
}
from base.views.learning_unit import learning_units_service_course
request = request_factory.get(reverse(learning_units_service_course),
data=filter_data)
request.user = self.a_superuser
setattr(request, 'session', 'session')
setattr(request, '_messages', FallbackStorage(request))
learning_units_service_course(request)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_units.html')
self.assertEqual(len(context['learning_units']), 0)
@mock.patch('base.views.layout.render')
@mock.patch('base.models.program_manager.is_program_manager')
def test_learning_unit_read(self, mock_program_manager, mock_render):
mock_program_manager.return_value = True
learning_container_year = LearningContainerYearFactory(
academic_year=self.current_academic_year)
learning_unit_year = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=learning_container_year)
request_factory = RequestFactory()
request = request_factory.get(
reverse('learning_unit', args=[learning_unit_year.id]))
request.user = self.a_superuser
from base.views.learning_unit import learning_unit_identification
learning_unit_identification(request, learning_unit_year.id)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_unit/identification.html')
self.assertEqual(context['learning_unit_year'], learning_unit_year)
def test_get_components_no_learning_container_yr(self):
learning_unit_year = LearningUnitYearFactory(
academic_year=self.current_academic_year)
self.assertEqual(
len(
learning_unit_business.get_same_container_year_components(
learning_unit_year, False)), 0)
def test_get_components_with_classes(self):
l_container = LearningContainerFactory()
l_container_year = LearningContainerYearFactory(
academic_year=self.current_academic_year,
title="LC-98998",
learning_container=l_container)
l_component_year = LearningComponentYearFactory(
learning_container_year=l_container_year)
LearningClassYearFactory(learning_component_year=l_component_year)
LearningClassYearFactory(learning_component_year=l_component_year)
learning_unit_year = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=l_container_year)
components = learning_unit_business.get_same_container_year_components(
learning_unit_year, True)
self.assertEqual(len(components), 1)
self.assertEqual(len(components[0]['learning_component_year'].classes),
2)
@mock.patch('base.views.layout.render')
@mock.patch('base.models.program_manager.is_program_manager')
def test_get_partims_identification_tabs(self, mock_program_manager,
mock_render):
mock_program_manager.return_value = True
learning_unit_container_year = LearningContainerYearFactory(
academic_year=self.current_academic_year)
learning_unit_year = LearningUnitYearFactory(
acronym="LCHIM1210",
learning_container_year=learning_unit_container_year,
subtype=learning_unit_year_subtypes.FULL,
academic_year=self.current_academic_year)
LearningUnitYearFactory(
acronym="LCHIM1210A",
learning_container_year=learning_unit_container_year,
subtype=learning_unit_year_subtypes.PARTIM,
academic_year=self.current_academic_year)
LearningUnitYearFactory(
acronym="LCHIM1210B",
learning_container_year=learning_unit_container_year,
subtype=learning_unit_year_subtypes.PARTIM,
academic_year=self.current_academic_year)
LearningUnitYearFactory(
acronym="LCHIM1210F",
learning_container_year=learning_unit_container_year,
subtype=learning_unit_year_subtypes.PARTIM,
academic_year=self.current_academic_year)
request_factory = RequestFactory()
request = request_factory.get(
reverse('learning_unit', args=[learning_unit_year.id]))
request.user = self.a_superuser
from base.views.learning_unit import learning_unit_identification
learning_unit_identification(request, learning_unit_year.id)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_unit/identification.html')
self.assertEqual(len(context['learning_container_year_partims']), 3)
def test_learning_unit_usage_two_usages(self):
learning_container_yr = LearningContainerYearFactory(
academic_year=self.current_academic_year, acronym='LBIOL')
learning_unit_yr_1 = LearningUnitYearFactory(
academic_year=self.current_academic_year,
acronym='LBIOLA',
quadrimester='Q1',
learning_container_year=learning_container_yr)
learning_unit_yr_2 = LearningUnitYearFactory(
academic_year=self.current_academic_year,
acronym='LBIOLB',
learning_container_year=learning_container_yr)
learning_component_yr = LearningComponentYearFactory(
learning_container_year=learning_container_yr)
LearningUnitComponentFactory(
learning_unit_year=learning_unit_yr_1,
learning_component_year=learning_component_yr)
LearningUnitComponentFactory(
learning_unit_year=learning_unit_yr_2,
learning_component_year=learning_component_yr)
self.assertEqual(
learning_unit_business._learning_unit_usage(learning_component_yr),
'LBIOLA (Q1), LBIOLB (?)')
def test_learning_unit_usage_with_complete_LU(self):
learning_container_yr = LearningContainerYearFactory(
academic_year=self.current_academic_year, acronym='LBIOL')
learning_unit_yr_1 = LearningUnitYearFactory(
academic_year=self.current_academic_year,
acronym='LBIOL',
quadrimester='Q1&2',
learning_container_year=learning_container_yr)
learning_component_yr = LearningComponentYearFactory(
learning_container_year=learning_container_yr)
LearningUnitComponentFactory(
learning_unit_year=learning_unit_yr_1,
learning_component_year=learning_component_yr)
self.assertEqual(
learning_unit_business._learning_unit_usage(learning_component_yr),
'LBIOL (Q1&2)')
def test_learning_unit_usage_by_class_with_complete_LU(self):
academic_year = AcademicYearFactory(year=2016)
learning_container_yr = LearningContainerYearFactory(
academic_year=academic_year, acronym='LBIOL')
learning_unit_yr_1 = LearningUnitYearFactory(
academic_year=academic_year,
acronym='LBIOL',
learning_container_year=learning_container_yr)
learning_component_yr = LearningComponentYearFactory(
learning_container_year=learning_container_yr)
learning_unit_component = LearningUnitComponentFactory(
learning_unit_year=learning_unit_yr_1,
learning_component_year=learning_component_yr)
learning_class_year = LearningClassYearFactory(
learning_component_year=learning_component_yr)
LearningUnitComponentClassFactory(
learning_unit_component=learning_unit_component,
learning_class_year=learning_class_year)
self.assertEqual(
learning_unit_business._learning_unit_usage_by_class(
learning_class_year), 'LBIOL')
def test_component_save(self):
learning_unit_yr = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_yr)
learning_unit_compnt = LearningUnitComponentFactory(
learning_unit_year=learning_unit_yr,
learning_component_year=self.learning_component_yr)
url = reverse('learning_unit_component_edit',
args=[learning_unit_yr.id])
qs = 'learning_component_year_id={}'.format(
self.learning_component_yr.id)
response = self.client.post('{}?{}'.format(url, qs),
data={"used_by": "on"})
self.learning_component_yr.refresh_from_db()
self.assertEqual(response.status_code, 302)
def test_component_save_delete_link(self):
learning_unit_yr = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_yr)
learning_unit_compnt = LearningUnitComponentFactory(
learning_unit_year=learning_unit_yr,
learning_component_year=self.learning_component_yr)
url = reverse('learning_unit_component_edit',
args=[learning_unit_yr.id])
qs = 'learning_component_year_id={}'.format(
self.learning_component_yr.id)
response = self.client.post('{}?{}'.format(url, qs),
data={"planned_classes": "1"})
self.assertRaises(
ObjectDoesNotExist,
learning_unit_component.LearningUnitComponent.objects.filter(
pk=learning_unit_compnt.id).first())
def test_component_save_create_link(self):
learning_unit_yr = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_yr)
url = reverse('learning_unit_component_edit',
args=[learning_unit_yr.id])
qs = 'learning_component_year_id={}'.format(
self.learning_component_yr.id)
response = self.client.post('{}?{}'.format(url, qs),
data={
"planned_classes": "1",
"used_by": "on"
})
self.assertTrue(
learning_unit_component.find_by_learning_component_year(
self.learning_component_yr).exists())
def _prepare_context_learning_units_search(self):
# Create a structure [Entity / Entity version]
ssh_entity = EntityFactory(country=self.country)
ssh_entity_v = EntityVersionFactory(acronym="SSH",
end_date=None,
entity=ssh_entity)
agro_entity = EntityFactory(country=self.country)
envi_entity = EntityFactory(country=self.country)
ages_entity = EntityFactory(country=self.country)
agro_entity_v = EntityVersionFactory(entity=agro_entity,
parent=ssh_entity_v.entity,
acronym="AGRO",
end_date=None)
envi_entity_v = EntityVersionFactory(entity=envi_entity,
parent=agro_entity_v.entity,
acronym="ENVI",
end_date=None)
ages_entity_v = EntityVersionFactory(entity=ages_entity,
parent=agro_entity_v.entity,
acronym="AGES",
end_date=None)
espo_entity = EntityFactory(country=self.country)
drt_entity = EntityFactory(country=self.country)
espo_entity_v = EntityVersionFactory(entity=espo_entity,
parent=ssh_entity_v.entity,
acronym="ESPO",
end_date=None)
drt_entity_v = EntityVersionFactory(entity=drt_entity,
parent=ssh_entity_v.entity,
acronym="DRT",
end_date=None)
# Create UE and put entity charge [AGRO]
l_container_yr = LearningContainerYearFactory(
acronym="LBIR1100",
academic_year=self.current_academic_year,
container_type=learning_container_year_types.COURSE)
EntityContainerYearFactory(
learning_container_year=l_container_yr,
entity=agro_entity_v.entity,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
LearningUnitYearFactory(acronym="LBIR1100",
learning_container_year=l_container_yr,
academic_year=self.current_academic_year,
subtype=learning_unit_year_subtypes.FULL)
LearningUnitYearFactory(acronym="LBIR1100A",
learning_container_year=l_container_yr,
academic_year=self.current_academic_year,
subtype=learning_unit_year_subtypes.PARTIM)
LearningUnitYearFactory(acronym="LBIR1100B",
learning_container_year=l_container_yr,
academic_year=self.current_academic_year,
subtype=learning_unit_year_subtypes.PARTIM)
LearningUnitYearFactory(acronym="LBIR1100C",
learning_container_year=l_container_yr,
academic_year=self.current_academic_year,
subtype=learning_unit_year_subtypes.PARTIM,
status=False)
# Create another UE and put entity charge [ENV]
l_container_yr_2 = LearningContainerYearFactory(
acronym="CHIM1200",
academic_year=self.current_academic_year,
container_type=learning_container_year_types.COURSE)
EntityContainerYearFactory(
learning_container_year=l_container_yr_2,
entity=envi_entity_v.entity,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
LearningUnitYearFactory(acronym="CHIM1200",
learning_container_year=l_container_yr_2,
academic_year=self.current_academic_year,
subtype=learning_unit_year_subtypes.FULL)
# Create another UE and put entity charge [DRT]
l_container_yr_3 = LearningContainerYearFactory(
acronym="DRT1500",
academic_year=self.current_academic_year,
container_type=learning_container_year_types.COURSE)
EntityContainerYearFactory(
learning_container_year=l_container_yr_3,
entity=drt_entity_v.entity,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
LearningUnitYearFactory(acronym="DRT1500",
learning_container_year=l_container_yr_3,
academic_year=self.current_academic_year,
subtype=learning_unit_year_subtypes.FULL)
LearningUnitYearFactory(acronym="DRT1500A",
learning_container_year=l_container_yr_3,
academic_year=self.current_academic_year,
subtype=learning_unit_year_subtypes.PARTIM)
# Create another UE and put entity charge [ESPO]
l_container_yr_4 = LearningContainerYearFactory(
acronym="ESPO1500",
academic_year=self.current_academic_year,
container_type=learning_container_year_types.DISSERTATION)
EntityContainerYearFactory(
learning_container_year=l_container_yr_4,
entity=espo_entity_v.entity,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
LearningUnitYearFactory(acronym="ESPO1500",
learning_container_year=l_container_yr_4,
academic_year=self.current_academic_year,
subtype=learning_unit_year_subtypes.FULL)
# Create another UE and put entity charge [AGES]
l_container_yr_4 = LearningContainerYearFactory(
acronym="AGES1500",
academic_year=self.current_academic_year,
container_type=learning_container_year_types.MASTER_THESIS)
EntityContainerYearFactory(
learning_container_year=l_container_yr_4,
entity=ages_entity_v.entity,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
LearningUnitYearFactory(acronym="AGES1500",
learning_container_year=l_container_yr_4,
academic_year=self.current_academic_year,
subtype=None)
def test_class_save(self):
learning_unit_yr = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_yr)
learning_unit_compnt = LearningUnitComponentFactory(
learning_unit_year=learning_unit_yr,
learning_component_year=self.learning_component_yr)
learning_class_yr = LearningClassYearFactory(
learning_component_year=self.learning_component_yr)
response = self.client.post('{}?{}&{}'.format(
reverse('learning_class_year_edit', args=[learning_unit_yr.id]),
'learning_component_year_id={}'.format(
self.learning_component_yr.id),
'learning_class_year_id={}'.format(learning_class_yr.id)),
data={"used_by": "on"})
self.learning_component_yr.refresh_from_db()
self.assertEqual(response.status_code, 302)
def test_class_save_create_link(self):
learning_unit_yr = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_yr)
learning_unit_compnt = LearningUnitComponentFactory(
learning_unit_year=learning_unit_yr,
learning_component_year=self.learning_component_yr)
learning_class_yr = LearningClassYearFactory(
learning_component_year=self.learning_component_yr)
response = self.client.post('{}?{}&{}'.format(
reverse('learning_class_year_edit', args=[learning_unit_yr.id]),
'learning_component_year_id={}'.format(
self.learning_component_yr.id),
'learning_class_year_id={}'.format(learning_class_yr.id)),
data={"used_by": "on"})
self.assertTrue(
learning_unit_component_class.search(learning_unit_compnt,
learning_class_yr).exists())
def test_class_save_delete_link(self):
learning_unit_yr = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_yr)
learning_unit_compnt = LearningUnitComponentFactory(
learning_unit_year=learning_unit_yr,
learning_component_year=self.learning_component_yr)
learning_class_yr = LearningClassYearFactory(
learning_component_year=self.learning_component_yr)
a_link = LearningUnitComponentClassFactory(
learning_unit_component=learning_unit_compnt,
learning_class_year=learning_class_yr)
response = self.client.post('{}?{}&{}'.format(
reverse('learning_class_year_edit', args=[learning_unit_yr.id]),
'learning_component_year_id={}'.format(
self.learning_component_yr.id),
'learning_class_year_id={}'.format(learning_class_yr.id)),
data={})
self.assertRaises(
ObjectDoesNotExist,
learning_unit_component_class.LearningUnitComponentClass.objects.
filter(pk=a_link.id).first())
def get_base_form_data(self):
return {
"first_letter": "L",
"acronym": "TAU2000",
"container_type": COURSE,
"academic_year": self.current_academic_year.id,
"status": True,
"periodicity": ANNUAL,
"credits": "5",
"campus": self.campus.id,
"internship_subtype": TEACHING_INTERNSHIP,
"title": "LAW",
"title_english": "LAW",
"requirement_entity": self.entity_version.id,
"allocation_entity": self.entity_version.id,
"additional_entity_1": self.entity_version.id,
"additional_entity_2": self.entity_version.id,
"subtype": learning_unit_year_subtypes.FULL,
"language": self.language.id,
"session": SESSION_P23,
"faculty_remark": "faculty remark",
"other_remark": "other remark"
}
def get_valid_data(self):
return self.get_base_form_data()
def get_faulty_acronym(self):
faultydict = dict(self.get_valid_data())
faultydict["acronym"] = "TA200"
return faultydict
def get_empty_acronym(self):
faultyDict = dict(self.get_valid_data())
faultyDict["acronym"] = ""
return faultyDict
def get_faulty_requirement_entity(self):
"""We will create an entity + entity version that user cannot create on it"""
entity = EntityFactory(country=self.country,
organization=self.organization)
entity_version = EntityVersionFactory(entity=entity,
entity_type=entity_type.SCHOOL,
end_date=None,
start_date=datetime.date.today())
faultydict = dict(self.get_valid_data())
faultydict['requirement_entity'] = entity_version.id
return faultydict
def test_learning_unit_year_form(self):
form = CreateLearningUnitYearForm(person=self.person,
data=self.get_valid_data())
self.assertTrue(form.is_valid(), form.errors)
url = reverse('learning_unit_year_add')
response = self.client.post(url, data=self.get_base_form_data())
self.assertEqual(response.status_code, 302)
count_learning_unit_year = LearningUnitYear.objects.all().count()
self.assertEqual(count_learning_unit_year, 6)
def test_create_learning_unit_year_requirement_entity_not_allowed(self):
form = CreateLearningUnitYearForm(
person=self.person, data=self.get_faulty_requirement_entity())
self.assertFalse(form.is_valid())
self.assertEqual(len(form.errors), 1)
self.assertTrue('requirement_entity' in form.errors)
def test_learning_unit_acronym_form(self):
form = CreateLearningUnitYearForm(person=self.person,
data=self.get_valid_data())
self.assertTrue(form.is_valid(), form.errors)
form = CreateLearningUnitYearForm(person=self.person,
data=self.get_empty_acronym())
self.assertFalse(form.is_valid(), form.errors)
self.assertEqual(form.errors['acronym'],
[_('This field is required.')])
form = CreateLearningUnitYearForm(person=self.person,
data=self.get_faulty_acronym())
self.assertFalse(form.is_valid(), form.errors)
self.assertEqual(form.errors['acronym'], [_('invalid_acronym')])
def test_learning_unit_check_acronym(self):
kwargs = {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
url = reverse('check_acronym')
get_data = {
'acronym': 'goodacronym',
'year_id': self.academic_year_1.id
}
response = self.client.get(url, get_data, **kwargs)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(
str(response.content, encoding='utf8'), {
'valid': True,
'existing_acronym': False,
'existed_acronym': False,
'last_using': ""
})
learning_unit_container_year = LearningContainerYearFactory(
academic_year=self.current_academic_year)
learning_unit_year = LearningUnitYearFactory(
acronym="LCHIM1210",
learning_container_year=learning_unit_container_year,
subtype=learning_unit_year_subtypes.FULL,
academic_year=self.current_academic_year)
learning_unit_year.save()
get_data = {
'acronym': 'LCHIM1210',
'year_id': self.current_academic_year.id
}
response = self.client.get(url, get_data, **kwargs)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(
str(response.content, encoding='utf8'), {
'valid': False,
'existing_acronym': True,
'existed_acronym': False,
'last_using': ""
})
learning_unit_year = LearningUnitYearFactory(
acronym="LCHIM1211",
learning_container_year=learning_unit_container_year,
subtype=learning_unit_year_subtypes.FULL,
academic_year=self.current_academic_year)
learning_unit_year.save()
get_data = {'acronym': 'LCHIM1211', 'year_id': self.academic_year_6.id}
response = self.client.get(url, get_data, **kwargs)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(
str(response.content, encoding='utf8'), {
'valid': True,
'existing_acronym': False,
'existed_acronym': True,
'last_using': str(self.current_academic_year)
})
def _get_volumes_data(self, learning_units_year):
if not isinstance(learning_units_year, list):
learning_units_year = [learning_units_year]
data = {}
for learning_unit_year in learning_units_year:
data['VOLUME_TOTAL_REQUIREMENT_ENTITIES_{}_{}'.format(
learning_unit_year.id, self.learning_component_yr.id)] = [60]
data['VOLUME_Q1_{}_{}'.format(
learning_unit_year.id, self.learning_component_yr.id)] = [10]
data['VOLUME_Q2_{}_{}'.format(
learning_unit_year.id, self.learning_component_yr.id)] = [20]
data['VOLUME_TOTAL_{}_{}'.format(
learning_unit_year.id, self.learning_component_yr.id)] = [30]
data['PLANNED_CLASSES_{}_{}'.format(
learning_unit_year.id, self.learning_component_yr.id)] = [2]
return data
@mock.patch('base.views.layout.render')
@mock.patch('base.models.program_manager.is_program_manager')
def test_get_learning_unit_volumes_management(self, mock_program_manager,
mock_render):
mock_program_manager.return_value = True
learning_unit_year = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_yr)
learning_unit_year.save()
request_factory = RequestFactory()
url = reverse("learning_unit_volumes_management",
args=[learning_unit_year.id])
# GET request
request = request_factory.get(url)
request.user = self.a_superuser
from base.views.learning_unit import learning_unit_volumes_management
learning_unit_volumes_management(request, learning_unit_year.id)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_unit/volumes_management.html')
self.assertEqual(context['tab_active'], 'components')
# POST request
request = request_factory.post(
url, self._get_volumes_data([learning_unit_year]))
request.user = mock.Mock()
learning_unit_volumes_management(request, learning_unit_year.id)
self.assertTrue(mock_render.called)
def test_volumes_validation(self):
learning_unit_year = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=self.learning_container_yr)
learning_unit_year.save()
kwargs = {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
url = reverse("volumes_validation", args=[learning_unit_year.id])
data = self._get_volumes_data(learning_unit_year)
# TODO inject wrong data
response = self.client.get(url, data, **kwargs)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(str(response.content, encoding='utf8'), {
'errors': [],
})
@mock.patch("base.models.learning_unit_year.count_search_results")
def test_error_message_case_too_many_results_to_show(self, mock_count):
mock_count.return_value = learning_units.MAX_RECORDS + 1
response = self.client.get(
reverse('learning_units'),
{'academic_year_id': self.academic_year_1.id})
messages = list(response.context['messages'])
self.assertEqual(messages[0].message, _('too_many_results'))