def test_get_title_next_luyr(self):
self.assertIsNone(
attribution_json._get_title_next_luyr(self.learning_unit_yr))
next_academic_year = AcademicYearFactory(year=self.academic_year.year +
1)
self.assertIsNone(
attribution_json._get_title_next_luyr(self.learning_unit_yr))
next_luy = LearningUnitYearFactory(
learning_unit=self.learning_unit_yr.learning_unit,
academic_year=next_academic_year)
self.assertEqual(
attribution_json._get_title_next_luyr(self.learning_unit_yr),
next_luy.complete_title)
def test_with_attributions(self):
today = datetime.datetime.today()
an_academic_year = AcademicYearFactory(
year=today.year,
start_date=today - datetime.timedelta(days=5),
end_date=today + datetime.timedelta(days=5))
a_learning_unit_year = LearningUnitYearFactory(
academic_year=an_academic_year)
AttributionFactory(learning_unit_year=a_learning_unit_year,
tutor=self.tutor)
response = self.client.get(self.url)
self.assertEqual(response.status_code, OK)
self.assertTemplateUsed(response, 'admin/students_list.html')
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
l_container = LearningContainerFactory()
self.l_container_year = LearningContainerYearFactory(
acronym=ACRONYM_LU,
learning_container=l_container,
academic_year=self.academic_yr)
LearningUnitYearFactory(acronym=ACRONYM_LU,
learning_container_year=self.l_container_year,
academic_year=self.academic_yr,
learning_unit=LearningUnitFactory())
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(year=2018)
cls.entity_version = EntityVersionFactory(
entity__organization__type=organization_type.MAIN)
cls.training = TrainingFactory(
acronym='BIR1BA',
partial_acronym='LBIR1000I',
academic_year=cls.academic_year,
management_entity=cls.entity_version.entity,
administration_entity=cls.entity_version.entity,
)
url = reverse('education_group_api_v1:training-detail',
kwargs={'uuid': cls.training.uuid})
cls.serializer = TrainingDetailSerializer(
cls.training, context={'request': RequestFactory().get(url)})
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory()
cls.person = PersonFactory()
cls.education_group_year_1 = EducationGroupYearFactory(
title_english="", academic_year=cls.academic_year)
cls.education_group_year_2 = EducationGroupYearFactory(
title_english="", academic_year=cls.academic_year)
cls.education_group_year_3 = EducationGroupYearFactory(
title_english="", academic_year=cls.academic_year, acronym='ed3')
cls.learning_unit_year_1 = LearningUnitYearFactory(
specific_title_english="")
cls.learning_unit_year_2 = LearningUnitYearFactory(
specific_title_english="", acronym="luy2")
cls.learning_component_year_1 = LearningComponentYearFactory(
learning_unit_year=cls.learning_unit_year_1,
hourly_volume_partial_q1=10,
hourly_volume_partial_q2=10)
cls.learning_component_year_2 = LearningComponentYearFactory(
learning_unit_year=cls.learning_unit_year_1,
hourly_volume_partial_q1=10,
hourly_volume_partial_q2=10)
cls.group_element_year_1 = GroupElementYearFactory(
parent=cls.education_group_year_1,
child_branch=cls.education_group_year_2,
comment="commentaire",
comment_english="english",
block=1)
cls.group_element_year_2 = GroupElementYearFactory(
parent=cls.education_group_year_2,
child_branch=None,
child_leaf=cls.learning_unit_year_1,
comment="commentaire",
comment_english="english",
block=6)
cls.group_element_year_3 = GroupElementYearFactory(
parent=cls.education_group_year_1,
child_branch=cls.education_group_year_3,
comment="commentaire",
comment_english="english",
block=1)
cls.group_element_year_4 = GroupElementYearFactory(
parent=cls.education_group_year_3,
child_branch=None,
child_leaf=cls.learning_unit_year_2,
comment="commentaire",
comment_english="english",
block=123)
cls.a_superuser = SuperUserFactory()
def setUp(self):
group, created = Group.objects.get_or_create(name='entity_managers')
content_type = ContentType.objects.get_for_model(EntityManager)
perm, created = Permission.objects.get_or_create(
codename='is_entity_manager', content_type=content_type)
group.permissions.add(perm)
self.person = PersonFactory()
self.user = self.person.user
self.tutor = TutorFactory(person=self.person)
self.current_academic_year = create_current_academic_year()
self.next_academic_year = AcademicYearFactory(
year=self.current_academic_year.year + 1)
# Old structure model [To remove]
self.structure = structure.StructureFactory()
self.structure_children = structure.StructureFactory(
part_of=self.structure)
# New structure model
entities_hierarchy = create_entities_hierarchy()
self.root_entity = entities_hierarchy.get('root_entity')
self.child_one_entity = entities_hierarchy.get('child_one_entity')
self.child_two_entity = entities_hierarchy.get('child_two_entity')
self.entity_manager = EntityManagerFactory(person=self.person,
structure=self.structure,
entity=self.root_entity)
# Create two learning_unit_year with context (Container + EntityContainerYear)
self.learning_unit_year = create_learning_unit_with_context(
academic_year=self.next_academic_year,
structure=self.structure,
entity=self.child_one_entity,
acronym="LBIR1210")
self.learning_unit_year_children = create_learning_unit_with_context(
academic_year=self.next_academic_year,
structure=self.structure_children,
entity=self.child_two_entity,
acronym="LBIR1211")
self.attribution = test_attribution.create_attribution(
tutor=self.tutor,
learning_unit_year=self.learning_unit_year,
summary_responsible=True)
self.attribution_children = test_attribution.create_attribution(
tutor=self.tutor,
learning_unit_year=self.learning_unit_year_children,
summary_responsible=True)
def test_create_luy_in_past(self, mock_baseform_save):
""" Check if there is no postponement when the learning_unit_year is in the past """
start_insert_year = AcademicYearFactory(
year=self.current_academic_year.year - 10)
self.learning_unit_year_full.academic_year = start_insert_year
self.learning_unit_year_full.save()
form = _instanciate_postponement_form(
self.person,
start_insert_year,
data=self.instance_luy_base_form.data)
self.assertEqual(len(form._forms_to_upsert), 1)
self.assertEqual(len(form._forms_to_delete), 0)
form.save()
self.assertEqual(mock_baseform_save.call_count, 1)
def test_check_education_group_end_date_with_protected_data(self):
edy = EducationGroupYearFactory(
education_group=self.education_group_year.education_group,
management_entity=self.entity,
administration_entity=self.entity,
academic_year=self.ac_year_in_future,
)
# Protected data [Offer enrollment]
OfferEnrollmentFactory(education_group_year=edy)
previous_academic_year = AcademicYearFactory(year=self.ac_year_in_future.year-1)
with self.assertRaises(ValidationError):
check_education_group_end_date(
education_group=self.education_group_year.education_group,
end_year=previous_academic_year
)
def setUpTestData(cls):
cls.manager = PersonWithPermissionsFactory('view_admission',
'change_admission',
groups=[MANAGERS_GROUP])
cls.academic_year = AcademicYearFactory(year=2018)
cls.education_group = EducationGroupFactory()
EducationGroupYearFactory(education_group=cls.education_group,
academic_year=cls.academic_year)
cls.formation = ContinuingEducationTrainingFactory(
education_group=cls.education_group)
cls.admission_accepted = AdmissionFactory(
state=admission_state_choices.ACCEPTED, formation=cls.formation)
cls.admission_rejected = AdmissionFactory(
state=admission_state_choices.REJECTED, formation=cls.formation)
cls.admission_validated = AdmissionFactory(
state=admission_state_choices.VALIDATED, formation=cls.formation)
def setUpTestData(cls):
cls.entity_1 = EntityFactory()
EntityVersionFactory(entity=cls.entity_1)
cls.an_academic_year = AcademicYearFactory(current=True)
cls.learning_container_yr = LearningContainerYearFactory(
academic_year=cls.an_academic_year,
requirement_entity=cls.entity_1,
)
a_learning_unit_year = LearningUnitYearFactory(acronym="LBIO1212",
academic_year=cls.an_academic_year,
learning_container_year=cls.learning_container_yr)
cls.a_proposal_learning_unit = ProposalLearningUnitFactory(learning_unit_year=a_learning_unit_year,
type=proposal_type.ProposalType.CREATION,
state=proposal_state.ProposalState.CENTRAL,
entity=cls.entity_1)
def setUp(self):
self.learning_unit = LearningUnitFactory()
self.current_academic_year = create_current_academic_year()
self.next_academic_yr = AcademicYearFactory(
year=self.current_academic_year.year + 1)
self.lcy = LearningContainerYearFactory(
academic_year=self.current_academic_year,
container_type=learning_container_year_types.COURSE,
requirement_entity=EntityVersionFactory().entity)
self.central_manager = CentralManagerFactory(
'can_edit_learningunit_pedagogy')
self.luy = LearningUnitYearFactory(
learning_unit=self.learning_unit,
learning_container_year=self.lcy,
)
self.central_manager.linked_entities = [self.lcy.requirement_entity.id]
def test_extends_only_components_of_learning_unit_year(self):
# Creating partim with components for the same learningContainerYear
_create_learning_unit_year_with_components(self.learning_container_year,
create_lecturing_component=True,
create_pratical_component=True,
subtype=learning_unit_year_subtypes.PARTIM)
inital_components_count = LearningComponentYear.objects.all().count()
number_of_components = LearningUnitComponent.objects.filter(learning_unit_year=self.learning_unit_year).count()
expected_count = inital_components_count + number_of_components
next_year = self.academic_year.year + 1
business_edition.duplicate_learning_unit_year(self.learning_unit_year, AcademicYearFactory(year=next_year))
# assert components of partims are not duplicated too
self.assertEqual(LearningComponentYear.objects.all().count(), expected_count)
def setUpTestData(cls):
academic_year = AcademicYearFactory(year=2020)
cls.education_group_year = TrainingFactory(academic_year=academic_year)
cls.person = FacultyManagerFactory("delete_educationgroup", "change_educationgroup", "add_educationgroup")
PersonEntityFactory(person=cls.person, entity=cls.education_group_year.management_entity)
# Create an academic calendar in order to check permission [Faculty can modify when period is opened]
cls.academic_calendar = AcademicCalendarFactory(
reference=EDUCATION_GROUP_EDITION,
start_date=timezone.now(),
end_date=timezone.now() + timedelta(weeks=+1),
academic_year=academic_year,
data_year=academic_year,
)
cls.url = reverse('delete_education_group', args=[cls.education_group_year.id, cls.education_group_year.id])
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory()
cls.education_group_year = EducationGroupYearFactory(
academic_year=cls.academic_year)
cls.group_element_year = GroupElementYearFactory(
parent=cls.education_group_year,
child_branch__academic_year=cls.academic_year)
cls.person = CentralManagerFactory()
cls.person.user.user_permissions.add(
Permission.objects.get(codename="can_access_education_group"))
cls.url = reverse("group_element_year_delete",
args=[
cls.education_group_year.id,
cls.education_group_year.id,
cls.group_element_year.id
])
def setUpTestData(cls):
cls.user = UserFactory()
cls.entity_version = EntityVersionFactory(
entity_type=entity_type.FACULTY
)
cls.academic_year = AcademicYearFactory(year=2018)
cls.education_group_yr = EducationGroupYearFactory(
acronym="ACRO",
management_entity=cls.entity_version.entity,
academic_year=cls.academic_year
)
cls.formation = ContinuingEducationTrainingFactory(
education_group=cls.education_group_yr.education_group,
active=True
)
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(current=True)
cls.l_container_1 = LearningContainerYearFactory(in_charge=True)
cls.global_id = '00012345'
cls.tutor_application_1 = TutorApplicationFactory(
tutor__person__global_id=cls.global_id,
learning_container_year=cls.l_container_1
)
cls.tutor_application_2 = TutorApplicationFactory(
tutor__person__global_id='',
learning_container_year=cls.l_container_1
)
cls.tutor_application_3 = TutorApplicationFactory(
tutor__person__global_id=None,
learning_container_year=cls.l_container_1
)
def test_cannot_modify_past_learning_unit(self):
past_year = datetime.date.today().year - 2
past_academic_year = AcademicYearFactory(year=past_year)
past_learning_container_year = LearningContainerYearFactory(
academic_year=past_academic_year,
container_type=learning_container_year_types.COURSE)
past_learning_unit_year = LearningUnitYearFactory(
learning_container_year=past_learning_container_year,
subtype=learning_unit_year_subtypes.FULL)
url = reverse("edit_learning_unit", args=[past_learning_unit_year.id])
response = self.client.get(url)
self.assertTemplateUsed(response, "access_denied.html")
self.assertEqual(response.status_code,
HttpResponseForbidden.status_code)
def test_central_can_copy_into_future(self):
central_manager = CentralManagerFactory()
eg = EducationGroupFactory(end_year=AcademicYearFactory(
year=self.current_academic_year.year + 4))
egy = EducationGroupYearFactory(
education_group=eg,
academic_year__year=self.current_academic_year.year + 2)
GroupElementYearFactory(parent=egy,
child_branch__academic_year=egy.academic_year,
child_branch__education_group__end_year=None)
EducationGroupYearFactory(
education_group=eg,
academic_year__year=self.current_academic_year.year + 3)
self.postponer = PostponeContent(egy, central_manager)
self.assertIsNone(self.postponer.check_instance(central_manager))
def test_offers_search(self):
today = datetime.date.today()
academic_year = AcademicYearFactory(
start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
response = self.client.get(reverse('offers_search'),
data={
'entity_acronym': 'entity',
'code': 'code',
'academic_year': academic_year.id,
})
self.assertTemplateUsed(response, 'offers.html')
self.assertEqual(response.context['offer_years'].count(), 0)
def setUp(self):
self.factory = RequestFactory()
self.settings = SettingsFactory()
today = datetime.date.today()
self.current_academic_year = AcademicYearFactory(
start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
self.assistant_mandate = AssistantMandateFactory(
academic_year=self.current_academic_year)
self.assistant_mandate.state = assistant_mandate_state.TRTS
self.assistant_mandate.save()
LearningUnitYearFactory(academic_year=self.current_academic_year,
acronym="LBIR1210")
LearningUnitYearFactory(academic_year=self.current_academic_year,
acronym="LBIR1211")
def test_faculty_cannot_copy_into_future(self):
eg = EducationGroupFactory(end_year=AcademicYearFactory(
year=self.current_academic_year.year + 4))
egy = EducationGroupYearFactory(
education_group=eg,
academic_year__year=self.current_academic_year.year + 2)
EducationGroupYearFactory(
education_group=eg,
academic_year__year=self.current_academic_year.year + 3)
with self.assertRaises(
NotPostponeError,
msg=
_('You are not allowed to postpone this training in the future.'
)):
self.postponer = PostponeContent(egy, FacultyManagerFactory())
def test_with_existing_education_group_year(self):
academic_year = AcademicYearFactory()
self.assertEqual(EducationGroup.objects.count(), 0)
from base.management.commands.import_reddot import OFFERS
for offer in OFFERS:
EducationGroupType.objects.create(name=offer['name'],
category=offer['category'])
from base.management.commands.import_reddot import create_common_offer_for_academic_year
education_group = EducationGroupFactory(start_year=academic_year.year,
end_year=academic_year.year +
1)
self.assertEqual(EducationGroupYear.objects.count(), 0)
create_common_offer_for_academic_year(academic_year.year)
self.assertEqual(EducationGroupYear.objects.count(), 2)
def generate_exam_enrollments(year, with_different_offer=False):
number_enrollments = 2
academic_year = AcademicYearFactory(year=year)
an_academic_calendar = AcademicCalendarFactory(
academic_year=academic_year,
start_date=datetime.datetime.today() - datetime.timedelta(days=20),
end_date=datetime.datetime.today() + datetime.timedelta(days=20),
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
session_exam_calendar = SessionExamCalendarFactory(
number_session=number_session.ONE,
academic_calendar=an_academic_calendar)
learning_unit_year = LearningUnitYearFakerFactory(
academic_year=academic_year,
learning_container_year__academic_year=academic_year,
acronym=LEARNING_UNIT_ACRONYM)
attribution = AttributionFactory(learning_unit_year=learning_unit_year)
if with_different_offer:
session_exams = [
SessionExamFactory(number_session=number_session.ONE,
learning_unit_year=learning_unit_year,
offer_year__academic_year=academic_year)
for _ in range(0, number_enrollments)
]
else:
session_exams = [
SessionExamFactory(number_session=number_session.ONE,
learning_unit_year=learning_unit_year,
offer_year__academic_year=academic_year)
] * number_enrollments
offer_years = [session_exam.offer_year for session_exam in session_exams]
exam_enrollments = list()
for i in range(0, number_enrollments):
student = StudentFactory()
offer_enrollment = OfferEnrollmentFactory(offer_year=offer_years[i],
student=student)
learning_unit_enrollment = LearningUnitEnrollmentFactory(
learning_unit_year=learning_unit_year,
offer_enrollment=offer_enrollment)
exam_enrollments.append(
ExamEnrollmentFactory(
session_exam=session_exams[i],
learning_unit_enrollment=learning_unit_enrollment))
return locals()
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory()
cls.now = datetime.datetime.now(get_tzinfo())
start_date = cls.now - datetime.timedelta(days=10)
end_date = None
cls._build_current_entity_version_structure(end_date, start_date)
cls.parent = EducationGroupYearFactory(
acronym='LTEST0000',
academic_year=cls.academic_year,
management_entity=cls.SC.entity,
administration_entity=cls.SC.entity)
cls.group_element_year_1 = GroupElementYearFactory(
parent=cls.parent,
child_branch=EducationGroupYearFactory(
acronym='LTEST0010',
academic_year=cls.academic_year,
management_entity=cls.SC.entity,
administration_entity=cls.SC.entity))
cls.group_element_year_1_1 = GroupElementYearFactory(
parent=cls.group_element_year_1.child_branch,
child_branch=EducationGroupYearFactory(
acronym='LTEST0011',
academic_year=cls.academic_year,
management_entity=cls.SC.entity,
administration_entity=cls.SC.entity))
cls.group_element_year_2 = GroupElementYearFactory(
parent=cls.parent,
child_branch=EducationGroupYearFactory(
acronym='LTEST0020',
academic_year=cls.academic_year,
management_entity=cls.MATH.entity,
administration_entity=cls.MATH.entity))
cls.learning_unit_year_1 = LearningUnitYearFactory(
acronym='LTEST0021',
academic_year=cls.academic_year,
learning_container_year__requirement_entity=cls.MATH.entity)
cls.group_element_year_2_1 = GroupElementYearFactory(
parent=cls.group_element_year_2.child_branch,
child_branch=None,
child_leaf=cls.learning_unit_year_1)
cls.parent_ILV = EducationGroupYearFactory(
acronym='TURC LV',
academic_year=cls.academic_year,
management_entity=cls.ILV.entity,
)
def setUpTestData(cls):
cls.next_academic_year = AcademicYearFactory(current=True)
cls.root_egy = EducationGroupYearFactory(academic_year=cls.next_academic_year)
cls.group_element_year = GroupElementYearFactory(parent__academic_year=cls.next_academic_year)
cls.selected_egy = GroupFactory(
academic_year=cls.next_academic_year
)
cls.url = reverse(
"group_element_year_move",
args=[cls.root_egy.id, cls.selected_egy.id, cls.group_element_year.id]
)
cls.person = PersonFactory()
cls.perm_patcher = mock.patch("base.business.education_groups.perms.is_eligible_to_change_education_group",
return_value=True)
def setUp(self):
self.nb_session = number_session.ONE
current_year = datetime.now().year
current_date = datetime(year=current_year, month=9, day=1, hour=12)
academic_year = AcademicYearFactory(year=current_year,
start_date=current_date,
end_date=current_date + timedelta(days=365))
self.off_year = OfferYearFactory()
self.education_group_year = EducationGroupYearFactory()
self._load_initial_data_of_type_deliberation(academic_year)
self._load_initial_data_of_type_scores_exam_submission(academic_year)
self._load_one_student_session_exam_deadline()
def test_education_group_trainings_manager_with_other_types(self):
education_group_not_training = EducationGroupFactory()
EducationGroupYearFactory(
education_group=education_group_not_training,
academic_year=AcademicYearFactory(year=2015),
education_group_type=EducationGroupTypeFactory(category=GROUP)
)
self.assertCountEqual(
list(EducationGroup.objects.having_related_training()),
[self.education_group]
)
self.assertNotEqual(
list(EducationGroup.objects.all()),
list(EducationGroup.objects.having_related_training())
)
def setUp(self):
self.current_academic_year = create_current_academic_year()
self.previous_academic_year = \
GenerateAcademicYear(self.current_academic_year.year-1, self.current_academic_year.year-1).academic_years[0]
self.next_academic_year = AcademicYearFactory(
year=self.current_academic_year.year + 1)
self.organization = OrganizationFactory(type=organization_type.MAIN)
self.country = CountryFactory()
self.url = reverse(learning_units_summary_list)
faculty_managers_group = Group.objects.get(name='faculty_managers')
self.faculty_user = UserFactory()
self.faculty_user.groups.add(faculty_managers_group)
self.faculty_person = PersonFactory(user=self.faculty_user)
self.an_entity = EntityFactory(country=self.country,
organization=self.organization)
PersonEntityFactory(person=self.faculty_person, entity=self.an_entity)
def setUpTestData(cls):
cls.title_acronym_12 = 'Acronym 12'
cls.continuing_education_group_type = EducationGroupTypeFactory(
name=random.choice(CONTINUING_EDUCATION_TRAINING_TYPES))
cls.academic_year = AcademicYearFactory(current=True)
cls.entity_version = create_entity_version("ENTITY_PREV")
similar_entity_version = create_entity_version("abc_ENTITY_PREV_xyz")
entity_version_2 = create_entity_version("FAC2")
cls.iufc_education_group_yr_ACRO_10 = EducationGroupYearFactory(
acronym="ACRO_10",
education_group_type=cls.continuing_education_group_type,
title='Acronym 10',
management_entity=cls.entity_version.entity,
academic_year=cls.academic_year)
cls.iufc_education_group_yr_ACRO_12 = EducationGroupYearFactory(
acronym="ACRO_12",
education_group_type=cls.continuing_education_group_type,
title=cls.title_acronym_12,
management_entity=entity_version_2.entity,
academic_year=cls.academic_year)
education_group_not_organized = EducationGroupFactory()
cls.education_group_yr_not_organized = EducationGroupYearFactory(
acronym="CODE_12",
education_group_type=cls.continuing_education_group_type,
title="Other title",
management_entity=cls.entity_version.entity,
education_group=education_group_not_organized,
academic_year=cls.academic_year)
cls.active_continuing_education_training = ContinuingEducationTrainingFactory(
education_group=cls.iufc_education_group_yr_ACRO_10.
education_group,
active=True,
)
cls.inactive_continuing_education_training = ContinuingEducationTrainingFactory(
education_group=cls.iufc_education_group_yr_ACRO_12.
education_group,
active=False,
)
cls.education_group_yr_not_organized_2 = EducationGroupYearFactory(
education_group_type=cls.continuing_education_group_type,
management_entity=similar_entity_version.entity,
academic_year=cls.academic_year)
def test_find_by_person_exclude_offer_list(self):
a_person = PersonFactory(first_name="Yannick", last_name="Leblanc")
previous_academic_year = AcademicYearFactory(
year=datetime.datetime.now().year - 1)
offer_yr_previous = OfferYearFactory(
academic_year=previous_academic_year)
ProgramManagerFactory(offer_year=offer_yr_previous, person=a_person)
offer_yr1 = OfferYearFactory(academic_year=self.academic_year)
offer_yr2 = OfferYearFactory(academic_year=self.academic_year)
ProgramManagerFactory(offer_year=offer_yr1, person=a_person)
ProgramManagerFactory(offer_year=offer_yr2, person=a_person)
self.assertEquals(
len(
program_manager.find_by_person_exclude_offer_list(
a_person, [offer_yr1], self.academic_year)), 1)
