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)