def test_tree_luy_has_and_is_prerequisite(self):
# self.learning_unit_year_1 is prerequisite
PrerequisiteItemFactory(
learning_unit=self.learning_unit_year_1.learning_unit,
prerequisite=PrerequisiteFactory(education_group_year=self.parent)
)
# self.learning_unit_year_1 has prerequisite
PrerequisiteItemFactory(
prerequisite=PrerequisiteFactory(
learning_unit_year=self.learning_unit_year_1,
education_group_year=self.parent
)
)
node = EducationGroupHierarchy(self.parent)
json = node.to_json()
self.assertEqual(
json['children'][1]['children'][0]['a_attr']['title'],
"{}\n{}".format(
self.learning_unit_year_1.complete_title,
_("The learning unit has prerequisites and is a prerequisite")
)
)
self.assertEqual(
json['children'][1]['children'][0]['icon'],
'fa fa-exchange-alt'
)
def test_get_prerequisite_string_representation_2_groupq_2_items(self):
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_1_1.learning_unit,
group_number=1,
position=1)
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_2_1.learning_unit,
group_number=2,
position=1)
expected_as_href = "{} {} {}".format(
"<a href='/learning_units/{}/'>{}</a>".format(
self.luy_prerequisite_item_1_1.id,
self.luy_prerequisite_item_1_1.acronym), _('AND'),
"<a href='/learning_units/{}/'>{}</a>".format(
self.luy_prerequisite_item_2_1.id,
self.luy_prerequisite_item_2_1.acronym))
self.assertEqual(self.prerequisite.prerequisite_string_as_href,
expected_as_href)
expected_as_href = "%s %s %s" % (
self.luy_prerequisite_item_1_1.acronym, _('AND'),
self.luy_prerequisite_item_2_1.acronym)
self.assertEqual(self.prerequisite.prerequisite_string,
expected_as_href)
def test_when_prerequisites_multiple_learning_units_with_parentheses(self):
learning_unit_year = LearningUnitYearFactory(acronym="LSINF1121")
PrerequisiteItemFactory(
learning_unit=learning_unit_year.learning_unit,
prerequisite=self.prerequisite,
group_number=1,
position=1,
)
learning_unit_year = LearningUnitYearFactory(acronym="LBIR1245A")
PrerequisiteItemFactory(
learning_unit=learning_unit_year.learning_unit,
prerequisite=self.prerequisite,
group_number=1,
position=2,
)
learning_unit_year = LearningUnitYearFactory(acronym="LDROI4578")
PrerequisiteItemFactory(
learning_unit=learning_unit_year.learning_unit,
prerequisite=self.prerequisite,
group_number=2,
position=1,
)
self.prerequisite.main_operator = AND
self.prerequisite.save()
self.assertCountEqual(
extract_learning_units_acronym_from_prerequisite(
self.prerequisite), ["LSINF1121", "LBIR1245A", "LDROI4578"])
self.prerequisite.main_operator = OR
self.prerequisite.save()
self.assertCountEqual(
extract_learning_units_acronym_from_prerequisite(
self.prerequisite), ["LSINF1121", "LBIR1245A", "LDROI4578"])
def test_learning_unit_prerequisite_to_itself_forbidden(self):
with self.assertRaisesMessage(
IntegrityError,
"A learning unit cannot be prerequisite to itself"):
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.learning_unit_year_with_prerequisite.
learning_unit)
def test_when_prerequisite_consits_of_one_learning_unit(self):
learning_unit_year = LearningUnitYearFactory(acronym="LSINF1121")
PrerequisiteItemFactory(learning_unit=learning_unit_year.learning_unit,
prerequisite=self.prerequisite)
self.assertEqual(
extract_learning_units_acronym_from_prerequisite(
self.prerequisite), ["LSINF1121"])
def test_detach_case_learning_unit_having_prerequisite(self):
PrerequisiteItemFactory(
prerequisite__learning_unit_year=self.luy,
prerequisite__education_group_year=self.group_element_year_root.parent
)
response = self.client.post(self.url, follow=True, HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(response.json(), {"error": True})
def test_should_return_false_when_luy_is_prerequisite_in_other_root(self):
PrerequisiteItemFactory(
learning_unit=self.grp_ele_leaf.child_leaf.learning_unit,
group_number=1,
position=1,
)
self.assertFalse(
self.grp_ele_leaf.child_leaf.has_or_is_prerequisite(
self.grp_ele_leaf.parent))
def test_get_prerequisite_string_representation_2_groupq_2_items(self):
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_1_1.learning_unit,
group_number=1,
position=1)
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_2_1.learning_unit,
group_number=2,
position=1)
expected_string = "{} {} {}".format(
self.luy_prerequisite_item_1_1.acronym, _('AND'),
self.luy_prerequisite_item_2_1.acronym)
self.assertEqual(self.prerequisite.prerequisite_string,
expected_string)
def setUpTestData(cls):
cls.learning_unit_is_prerequisite = LearningUnitFactory()
cls.learning_unit_not_prerequisite = LearningUnitFactory()
cls.learning_unit_year_with_prerequisite = LearningUnitYearFactory()
cls.learning_unit_year_without_prerequisite = LearningUnitYearFactory()
cls.prerequisite = PrerequisiteFactory(
learning_unit_year=cls.learning_unit_year_with_prerequisite)
cls.prerequisite_item = PrerequisiteItemFactory(
prerequisite=cls.prerequisite,
learning_unit=cls.learning_unit_is_prerequisite)
def _build_group_of_prerequisite_items(prerequisite, group, positions):
return [
PrerequisiteItemFactory(
prerequisite=prerequisite,
learning_unit=LearningUnitYearFactory(acronym='LDROI11{}{}'.format(group, i)).learning_unit,
group_number=group,
position=i
)
for i in range(1, 1 + positions)
]
def setUp(self):
self.learning_unit_is_prerequisite = LearningUnitFactory()
self.learning_unit_not_prerequisite = LearningUnitFactory()
self.learning_unit_year_with_prerequisite = LearningUnitYearFactory()
self.learning_unit_year_without_prerequisite = LearningUnitYearFactory()
self.prerequisite = PrerequisiteFactory(learning_unit_year=self.learning_unit_year_with_prerequisite)
self.prerequisite_item = PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.learning_unit_is_prerequisite
)
def test_should_return_true_if_luy_has_prerequisite(self):
PrerequisiteItemFactory(
prerequisite__education_group_year=self.grp_ele_root.parent,
prerequisite__learning_unit_year=self.grp_ele_leaf.child_leaf,
group_number=1,
position=1,
)
self.assertTrue(
self.grp_ele_leaf.child_leaf.has_or_is_prerequisite(
self.grp_ele_leaf.parent))
def test_postpone_with_prerequisite(self):
prerequisite = PrerequisiteFactory(
learning_unit_year__academic_year=self.current_academic_year,
education_group_year=self.current_education_group_year
)
item_luy = LearningUnitYearFactory(academic_year=self.current_academic_year)
item_luy_n1 = LearningUnitYearFactory(
academic_year=self.previous_academic_year,
learning_unit=item_luy.learning_unit
)
n1_item_luy = LearningUnitYearFactory(
academic_year=self.next_academic_year,
learning_unit=item_luy.learning_unit,
)
PrerequisiteItemFactory(
prerequisite=prerequisite,
learning_unit=item_luy.learning_unit
)
n1_luy = LearningUnitYearFactory(
learning_unit=prerequisite.learning_unit_year.learning_unit,
academic_year=self.next_academic_year,
)
GroupElementYearFactory(
parent=self.current_education_group_year,
child_branch=None,
child_leaf=item_luy
)
GroupElementYearFactory(
parent=self.current_education_group_year,
child_branch=None,
child_leaf=prerequisite.learning_unit_year
)
self.postponer = PostponeContent(self.current_education_group_year)
new_root = self.postponer.postpone()
new_child_leaf = new_root.groupelementyear_set.last().child_leaf
self.assertEqual(new_child_leaf.acronym, n1_luy.acronym)
# If the luy does not exist in N+1, it should attach N instance
self.assertEqual(new_child_leaf.academic_year, self.next_academic_year)
self.assertFalse(self.postponer.warnings)
self.assertEqual(
new_child_leaf.prerequisite_set.first().prerequisiteitem_set.first().learning_unit,
n1_item_luy.learning_unit
)
def items(obj, create, extracted, groups=None, **kwargs):
"""
Generate PrerequisiteItems for to this Prerequisite based on the argument groups.
:param groups: A tuple of tuples of LearningUnitYear. Ex: ((LSINF1101,), (LOSIS1254, LOSIS2569))
Each tuple contained corresponds to a different group.
"""
if groups is None:
groups = tuple()
for index, group in enumerate(groups):
for group_index, luy in enumerate(group):
PrerequisiteItemFactory(learning_unit=luy.learning_unit,
prerequisite=obj,
group_number=index + 1,
position=group_index + 1)
def setUp(self):
self.mock_authorized_relationship_check_is_valid = mock.patch.object(
CheckAuthorizedRelationshipDetach, "is_valid")
self.mock_authorized_relationship_check_is_valid.return_value = True
self.mocked_perm = self.mock_authorized_relationship_check_is_valid.start(
)
self.addCleanup(self.mock_authorized_relationship_check_is_valid.stop)
self.prerequisite = PrerequisiteFactory(
learning_unit_year=self.lu_children_level_3[0].child_leaf,
education_group_year=self.root,
)
self.prerequisite_item = PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.lu_children_level_2[0].child_leaf.learning_unit)
def test_detach_case_learning_unit_having_prerequisite(self, mock_delete):
PrerequisiteItemFactory(
prerequisite__learning_unit_year=self.luy,
prerequisite__education_group_year=self.group_element_year_root.parent
)
response = self.client.post(self.url, follow=True, HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(response.status_code, HttpResponse.status_code)
messages = [m.message for m in get_messages(response.wsgi_request)]
self.assertEqual(
messages[0],
_("Cannot detach learning unit %(acronym)s as it has a prerequisite or it is a prerequisite.") % {
"acronym": self.luy.acronym}
)
self.assertFalse(mock_delete.called)
def test_get_prerequisite_string_representation_two_groups(self):
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_1_1.learning_unit,
group_number=1,
position=1)
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_1_2.learning_unit,
group_number=1,
position=2)
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_1_3.learning_unit,
group_number=1,
position=3)
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_2_1.learning_unit,
group_number=2,
position=1)
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_2_2.learning_unit,
group_number=2,
position=2)
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_2_3.learning_unit,
group_number=2,
position=3)
expected = \
"(%s %s %s %s " \
"%s) %s (%s %s " \
"%s %s %s)" % (
self.luy_prerequisite_item_1_1.acronym,
_('OR'),
self.luy_prerequisite_item_1_2.acronym,
_('OR'),
self.luy_prerequisite_item_1_3.acronym,
_('AND'),
self.luy_prerequisite_item_2_1.acronym,
_('OR'),
self.luy_prerequisite_item_2_2.acronym,
_('OR'),
self.luy_prerequisite_item_2_3.acronym
)
self.assertEqual(self.prerequisite.prerequisite_string, expected)
def setUpTestData(cls):
cls.prerequisite = PrerequisiteFactory(
learning_unit_year__acronym="LDROI1000")
cls.prerequisite_item = PrerequisiteItemFactory(
prerequisite=cls.prerequisite)
url_kwargs = {
'acronym': cls.prerequisite.learning_unit_year.acronym,
'year': cls.prerequisite.learning_unit_year.academic_year.year
}
url = reverse('learning_unit_api_v1:' +
LearningUnitPrerequisitesList.name,
kwargs=url_kwargs)
cls.serializer = LearningUnitYearPrerequisitesListSerializer(
cls.prerequisite,
context={
'request': RequestFactory().get(url),
'language': settings.LANGUAGE_CODE_EN
},
)
def test_when_prerequisite_learning_unit_does_not_exist_in_n1(self):
prerequisite = PrerequisiteFactory(
learning_unit_year__academic_year=self.current_academic_year,
education_group_year=self.current_education_group_year
)
PrerequisiteItemFactory(
prerequisite=prerequisite,
)
n1_luy = LearningUnitYearFactory(
learning_unit=prerequisite.learning_unit_year.learning_unit,
academic_year=self.next_academic_year,
)
GroupElementYearFactory(
parent=self.current_group_element_year.child_branch,
child_branch=None,
child_leaf=prerequisite.learning_unit_year
)
GroupElementYearFactory(
parent=EducationGroupYearFactory(
education_group=self.current_group_element_year.child_branch.education_group,
academic_year=self.next_academic_year
),
child_branch=None,
child_leaf=LearningUnitYearFactory(academic_year=self.next_academic_year)
)
self.postponer = PostponeContent(self.current_education_group_year)
new_root = self.postponer.postpone()
self.assertIn(
_("%(learning_unit_year)s is not anymore contained in "
"%(education_group_year_root)s "
"=> the prerequisite for %(learning_unit_year)s is not copied.") % {
"education_group_year_root": "{} - {}".format(new_root.partial_acronym, new_root.acronym),
"learning_unit_year": prerequisite.learning_unit_year.acronym,
},
[str(warning) for warning in self.postponer.warnings]
)
def test_get_acronym_as_href(self):
current_academic_yr = create_current_academic_year()
learning_unit_yr = LearningUnitYearFactory(academic_year=current_academic_yr)
learning_unit_yr_prerequisite = LearningUnitYearFactory(academic_year=current_academic_yr)
prerequisite_item = PrerequisiteItemFactory(
prerequisite=PrerequisiteFactory(learning_unit_year=learning_unit_yr),
learning_unit=learning_unit_yr_prerequisite.learning_unit
)
previous_academic_yr = AcademicYearFactory(year=current_academic_yr.year - 1)
self.assertEqual(
base.templatetags.prerequisite._get_acronym_as_href({}, prerequisite_item, previous_academic_yr),
'')
self.assertEqual(
base.templatetags.prerequisite._get_acronym_as_href({}, prerequisite_item, current_academic_yr),
_get_acronym_as_href(learning_unit_yr_prerequisite)
)
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(year=2018)
cls.education_group_year = TrainingFactory(
acronym='DROI1BA',
partial_acronym='LDROI1000',
academic_year=cls.academic_year)
cls.learning_unit_year = LearningUnitYearFactory(
academic_year=cls.academic_year,
learning_container_year__academic_year=cls.academic_year)
cls.prerequisite = PrerequisiteFactory(
learning_unit_year=cls.learning_unit_year,
education_group_year=cls.education_group_year)
PrerequisiteItemFactory(prerequisite=cls.prerequisite)
cls.person = PersonFactory()
url_kwargs = {
'acronym': cls.learning_unit_year.acronym,
'year': cls.learning_unit_year.academic_year.year
}
cls.url = reverse('learning_unit_api_v1:' +
LearningUnitPrerequisitesList.name,
kwargs=url_kwargs)
def test_when_prerequisite_item_does_not_exist_in_formation(self):
prerequisite = PrerequisiteFactory(
learning_unit_year__academic_year=self.current_academic_year,
education_group_year=self.current_education_group_year)
item_luy = LearningUnitYearFactory(
academic_year=self.current_academic_year)
PrerequisiteItemFactory(prerequisite=prerequisite,
learning_unit=item_luy.learning_unit)
LearningUnitYearFactory(
learning_unit=prerequisite.learning_unit_year.learning_unit,
academic_year=self.next_academic_year,
)
GroupElementYearFactory(parent=self.current_education_group_year,
child_branch=None,
child_leaf=prerequisite.learning_unit_year)
self.postponer = PostponeContent(self.current_education_group_year)
new_root = self.postponer.postpone()
self.assertEqual(
_("%(prerequisite_item)s is not anymore contained in "
"%(education_group_year_root)s "
"=> the prerequisite for %(learning_unit_year)s "
"having %(prerequisite_item)s as prerequisite is not copied.") %
{
"education_group_year_root":
"{} - {}".format(new_root.partial_acronym, new_root.acronym),
"learning_unit_year":
prerequisite.learning_unit_year.acronym,
"prerequisite_item":
item_luy.acronym
},
str(self.postponer.warnings[0]),
)
def test_get_prerequisite_string_representation_two_groups(self):
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_1_1.learning_unit,
group_number=1,
position=1)
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_1_2.learning_unit,
group_number=1,
position=2)
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_1_3.learning_unit,
group_number=1,
position=3)
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_2_1.learning_unit,
group_number=2,
position=1)
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_2_2.learning_unit,
group_number=2,
position=2)
PrerequisiteItemFactory(
prerequisite=self.prerequisite,
learning_unit=self.luy_prerequisite_item_2_3.learning_unit,
group_number=2,
position=3)
expected_as_href = \
"(<a href='/learning_units/{}/'>{}</a> {} <a href='/learning_units/{}/'>{}</a> {} " \
"<a href='/learning_units/{}/'>{}</a>) {} (<a href='/learning_units/{}/'>{}</a> {} " \
"<a href='/learning_units/{}/'>{}</a> {} <a href='/learning_units/{}/'>{}</a>)".format(
self.luy_prerequisite_item_1_1.id,
self.luy_prerequisite_item_1_1.acronym,
_('OR'),
self.luy_prerequisite_item_1_2.id,
self.luy_prerequisite_item_1_2.acronym,
_('OR'),
self.luy_prerequisite_item_1_3.id,
self.luy_prerequisite_item_1_3.acronym,
_('AND'),
self.luy_prerequisite_item_2_1.id,
self.luy_prerequisite_item_2_1.acronym,
_('OR'),
self.luy_prerequisite_item_2_2.id,
self.luy_prerequisite_item_2_2.acronym,
_('OR'),
self.luy_prerequisite_item_2_3.id,
self.luy_prerequisite_item_2_3.acronym
)
self.assertEqual(self.prerequisite.prerequisite_string_as_href,
expected_as_href)
expected = \
"(%s %s %s %s " \
"%s) %s (%s %s " \
"%s %s %s)" %(
self.luy_prerequisite_item_1_1.acronym,
_('OR'),
self.luy_prerequisite_item_1_2.acronym,
_('OR'),
self.luy_prerequisite_item_1_3.acronym,
_('AND'),
self.luy_prerequisite_item_2_1.acronym,
_('OR'),
self.luy_prerequisite_item_2_2.acronym,
_('OR'),
self.luy_prerequisite_item_2_3.acronym
)
self.assertEqual(self.prerequisite.prerequisite_string, expected)
