def test_faculty_manager_is_not_eligible_to_add_training(self): result = _is_eligible_to_add_education_group_with_category( FacultyManagerFactory(), random.choice([EducationGroupYearFactory(), None]), Categories.TRAINING, raise_exception=False) self.assertFalse(result)
def test_is_faculty_manager_eligible(self): faculty_manager = FacultyManagerFactory() for education_group_year in [self.training, self.common_bachelor]: perm = GeneralInformationPerms(faculty_manager.user, education_group_year) self.assertTrue(perm._is_faculty_manager_eligible())
def setUpTestData(cls): today = datetime.date.today() FacultyManagerGroupFactory() cls.faculty_user = factory_user.UserFactory() cls.faculty_person = FacultyManagerFactory('can_propose_learningunit', 'can_create_learningunit', user=cls.faculty_user) cls.super_user = factory_user.SuperUserFactory() cls.person = factory_person.CentralManagerFactory(user=cls.super_user) start_year = AcademicYearFactory(year=get_current_year()) end_year = AcademicYearFactory(year=get_current_year() + 7) cls.academic_years = GenerateAcademicYear(start_year, end_year).academic_years cls.current_academic_year = cls.academic_years[0] cls.next_academic_year = cls.academic_years[1] generate_creation_or_end_date_proposal_calendars(cls.academic_years) cls.language = LanguageFactory(code='FR') cls.organization = organization_factory.OrganizationFactory( type=organization_type.MAIN) cls.campus = campus_factory.CampusFactory( organization=cls.organization, is_administration=True) cls.entity = EntityFactory(organization=cls.organization) cls.entity_version = EntityVersionFactory( entity=cls.entity, entity_type=entity_type.FACULTY, start_date=today.replace(year=1900), end_date=None) PersonEntityFactory(person=cls.faculty_person, entity=cls.entity) PersonEntityFactory(person=cls.person, entity=cls.entity)
def test_li_edit_lu_year_non_editable_for_faculty_manager(self): faculty_manager = FacultyManagerFactory() self.context["learning_unit_year"] = self.previous_learning_unit_year self.context["user"] = faculty_manager.user result = li_edit_lu(self.context, self.url_edit, "") self.assertEqual( result, { 'load_modal': False, 'id_li': ID_LINK_EDIT_LU, 'url': "#", 'title': "{}. {}".format( "You can't modify learning unit under year : %(year)d" % {"year": settings.YEAR_LIMIT_LUE_MODIFICATION}, "Modifications should be made in EPC for year %(year)d" % { "year": self.previous_learning_unit_year.academic_year.year }), 'class_li': DISABLED, 'text': "", 'data_target': "" })
def test_learning_unit_with_faculty_manager_when_cannot_edit_end_date( self): learning_container_year = LearningContainerYearFactory( academic_year=self.current_academic_year, container_type=learning_container_year_types.COURSE, requirement_entity=EntityFactory(), ) learning_unit_year = LearningUnitYearFactory( academic_year=self.current_academic_year, learning_container_year=learning_container_year, subtype=learning_unit_year_subtypes.FULL) EntityVersionFactory(entity=learning_container_year.requirement_entity) learning_unit_year.learning_unit.end_year = None learning_unit_year.learning_unit.save() managers = [ FacultyManagerFactory('can_access_learningunit'), ] for manager in managers: PersonEntityFactory( entity=learning_container_year.requirement_entity, person=manager) url = reverse("learning_unit", args=[learning_unit_year.id]) self.client.force_login(manager.user) response = self.client.get(url) self.assertEqual(response.context["can_edit_date"], False)
def setUpTestData(cls): cls.person_fac = FacultyManagerFactory() cls.academic_yr = create_current_academic_year() cls.academic_yr_1 = AcademicYearFactory.build( year=cls.academic_yr.year + 1) super(AcademicYear, cls.academic_yr_1).save() cls.academic_yr_2 = AcademicYearFactory.build( year=cls.academic_yr.year + 2) super(AcademicYear, cls.academic_yr_2).save() cls.academic_yr_6 = AcademicYearFactory.build( year=cls.academic_yr.year + 6) super(AcademicYear, cls.academic_yr_6).save() previous_academic_yr = AcademicYearFactory.build( year=cls.academic_yr.year - 1) super(AcademicYear, previous_academic_yr).save() cls.lunit_container_yr = LearningContainerYearFactory( academic_year=cls.academic_yr) cls.luy = LearningUnitYearFactory( academic_year=cls.academic_yr, learning_container_year=cls.lunit_container_yr, subtype=FULL, learning_unit=LearningUnitFactory( start_year=create_past_academic_year(), end_year=cls.academic_yr)) academic_years = [ cls.academic_yr, cls.academic_yr_1, cls.academic_yr_2 ] generate_learning_unit_edition_calendars(academic_years)
def setUpTestData(cls): now = datetime.datetime.now() cls.academic_year = create_current_academic_year() cls.previous_academic_year = GenerateAcademicYear( cls.academic_year.year - 1, cls.academic_year.year - 1).academic_years[0] AcademicCalendarFactory( academic_year=cls.previous_academic_year, start_date=now - datetime.timedelta(days=5), end_date=now + datetime.timedelta(days=15), reference=academic_calendar_type.SUMMARY_COURSE_SUBMISSION) cls.requirement_entity_version = EntityVersionFactory( entity__organization__type=organization_type.MAIN, start_date=now, end_date=datetime.datetime(now.year + 1, 9, 15), entity_type=entity_type.INSTITUTE) cls.learning_unit_year = LearningUnitYearFactory( acronym="LBIR1100", academic_year=cls.academic_year, learning_container_year__academic_year=cls.academic_year, learning_container_year__acronym="LBIR1100", learning_container_year__requirement_entity=cls. requirement_entity_version.entity) cls.url = reverse('learning_units_summary') cls.faculty_person = FacultyManagerFactory( 'can_access_learningunit', 'can_edit_learningunit_pedagogy') PersonEntityFactory(person=cls.faculty_person, entity=cls.requirement_entity_version.entity)
def test_raise_permission_denied_if_person_is_faculty_manager_and_period_closed(self): CloseAcademicCalendarFactory(reference=EDUCATION_GROUP_EDITION, academic_year=self.previous_acy) person_entity = PersonEntityFactory(entity=self.group_element_year.parent.management_entity, person=FacultyManagerFactory()) with self.assertRaises(PermissionDenied): can_update_group_element_year(person_entity.person.user, self.group_element_year)
def setUp(self): current_ac = create_current_academic_year() self.education_group_year = TrainingFactory(academic_year=current_ac) self.person = FacultyManagerFactory("delete_educationgroup", "change_educationgroup", "add_educationgroup") PersonEntityFactory(person=self.person, entity=self.education_group_year.management_entity) # Create an academic calendar in order to check permission [Faculty can modify when period is opened] self.academic_calendar = AcademicCalendarFactory( reference=EDUCATION_GROUP_EDITION, start_date=timezone.now(), end_date=timezone.now() + timedelta(weeks=+1), academic_year=current_ac, ) self.client.force_login(user=self.person.user) self.url = reverse( 'delete_education_group', args=[self.education_group_year.id, self.education_group_year.id]) self.context = { "person": self.person, "root": self.education_group_year, "education_group_year": self.education_group_year, "request": RequestFactory().get("") }
def setUpTestData(cls): now = datetime.datetime.now() cls.academic_year = create_current_academic_year() cls.previous_academic_year = GenerateAcademicYear( cls.academic_year.year - 1, cls.academic_year.year - 1).academic_years[0] AcademicCalendarFactory( academic_year=cls.previous_academic_year, start_date=now - datetime.timedelta(days=5), end_date=now + datetime.timedelta(days=15), reference=academic_calendar_type.SUMMARY_COURSE_SUBMISSION) cls.requirement_entity_version = EntityVersionFactory( entity__organization__type=organization_type.MAIN, start_date=now, end_date=datetime.datetime(now.year + 1, 9, 15), entity_type=entity_type.INSTITUTE) cls.url = reverse('learning_units_summary') cls.faculty_person = FacultyManagerFactory( 'can_access_learningunit', 'can_edit_learningunit_pedagogy') PersonEntityFactory(person=cls.faculty_person, entity=cls.requirement_entity_version.entity) # Generate data for XLS export cls.learning_unit_year_with_mandatory_teaching_materials = LearningUnitYearFactory( acronym="LBIR1100", academic_year=cls.academic_year, learning_container_year__academic_year=cls.academic_year, learning_container_year__acronym="LBIR1100", learning_container_year__requirement_entity=cls. requirement_entity_version.entity) TeachingMaterialFactory( learning_unit_year=cls. learning_unit_year_with_mandatory_teaching_materials, title="Magic wand", mandatory=True, ) TeachingMaterialFactory( learning_unit_year=cls. learning_unit_year_with_mandatory_teaching_materials, title="Broomsticks", mandatory=False, ) cls.learning_unit_year_without_mandatory_teaching_materials = LearningUnitYearFactory( acronym="LDROI1600", academic_year=cls.academic_year, learning_container_year__academic_year=cls.academic_year, learning_container_year__acronym="LDROI1600", learning_container_year__requirement_entity=cls. requirement_entity_version.entity) TeachingMaterialFactory( learning_unit_year=cls. learning_unit_year_without_mandatory_teaching_materials, title="cauldron", mandatory=False, )
def test_faculty_manager_is_eligible_to_add_groups_in_tree_of_offer_of_its_entity( self): result = _is_eligible_to_add_education_group_with_category( FacultyManagerFactory(), EducationGroupYearFactory(), Categories.GROUP, raise_exception=False) self.assertTrue(result)
def test_faculty_manager_is_not_eligible_to_add_groups_in_search_page( self): result = _is_eligible_to_add_education_group_with_category( FacultyManagerFactory(), None, Categories.GROUP, raise_exception=False) self.assertFalse(result)
def test_is_eligible_case_user_is_faculty_manager(self, mock_is_faculty_eligible, mock_user_have_perm, mock_super_is_eligible): faculty_manager = FacultyManagerFactory() perm = AdmissionConditionPerms(faculty_manager.user, self.common_bachelor) perm._is_eligible() self.assertTrue(mock_super_is_eligible.called) self.assertTrue(mock_is_faculty_eligible.called)
def test_is_eligible_to_modify_by_proposal(self, mock_perm): learning_unit_yr = LearningUnitYearFactory( academic_year=self.next_academic_yr, subtype=learning_unit_year_subtypes.FULL, learning_container_year=self.lcy) person_faculty_manager = FacultyManagerFactory() self.assertTrue( is_eligible_to_modify_by_proposal(learning_unit_yr, person_faculty_manager, True))
def test_li_edit_date_person_test_is_eligible_to_modify_end_date_based_on_container_type( self): lu = LearningUnitFactory(existing_proposal_in_epc=False) learning_unit_year_without_proposal = LearningUnitYearFactory( academic_year=self.academic_year, subtype=learning_unit_year_subtypes.FULL, learning_unit=lu, learning_container_year=self.lcy) person_faculty_manager = FacultyManagerFactory() PersonEntityFactory(person=person_faculty_manager, entity=self.entity_container_yr.entity) self.context['user'] = person_faculty_manager.user self.context[ 'learning_unit_year'] = learning_unit_year_without_proposal result = li_edit_date_lu(self.context, self.url_edit, "") self.assertEqual( result, self._get_result_data_expected(ID_LINK_EDIT_DATE_LU, MSG_NO_ELIGIBLE_TO_MODIFY_END_DATE)) # allowed if _is_person_central_manager or # _is_learning_unit_year_a_partim or # negation(_is_container_type_course_dissertation_or_internship), # test 1st condition true self.context['user'] = self.central_manager_person.user result = li_edit_date_lu(self.context, self.url_edit, "") self.assertEqual( result, self._get_result_data_expected(ID_LINK_EDIT_DATE_LU, url=self.url_edit)) # test 2nd condition true self.context['user'] = person_faculty_manager.user learning_unit_year_without_proposal.subtype = learning_unit_year_subtypes.PARTIM learning_unit_year_without_proposal.save() self.context[ 'learning_unit_year'] = learning_unit_year_without_proposal self.assertEqual( li_edit_date_lu(self.context, self.url_edit, ""), self._get_result_data_expected(ID_LINK_EDIT_DATE_LU, url=self.url_edit)) # test 3rd condition true learning_unit_year_without_proposal.learning_container_year.container_type = learning_container_year_types.OTHER_COLLECTIVE learning_unit_year_without_proposal.learning_container_year.save() learning_unit_year_without_proposal.subtype = learning_unit_year_subtypes.FULL learning_unit_year_without_proposal.save() self.context[ 'learning_unit_year'] = learning_unit_year_without_proposal self.assertEqual( li_edit_date_lu(self.context, self.url_edit, ""), self._get_result_data_expected(ID_LINK_EDIT_DATE_LU, url=self.url_edit))
def setUpTestData(cls): cls.current_academic_year = create_current_academic_year() cls.faculty_person = FacultyManagerFactory() cls.learning_unit_year = LearningUnitYearFactory( academic_year=cls.current_academic_year, learning_container_year__academic_year=cls.current_academic_year, subtype=FULL ) cls.url = reverse('learning_unit_pedagogy_toggle_summary_locked', kwargs={'learning_unit_year_id': cls.learning_unit_year.pk})
def test_is_faculty_manager_case_cannot_modify_data_in_past(self): previous_year = self.current_academic_year.year - 1 training_in_past = TrainingFactory(academic_year__year=previous_year) common_in_past = EducationGroupYearCommonBachelorFactory(academic_year__year=previous_year) faculty_manager = FacultyManagerFactory() for education_group_year in [training_in_past, common_in_past]: perm = AdmissionConditionPerms(faculty_manager.user, education_group_year) with self.assertRaises(PermissionDenied): perm._is_faculty_manager_eligible()
def test_faculty_mgr_can_not_modify_end_year_by_proposal_n_year(self): faculty_person = FacultyManagerFactory() lcy = LearningContainerYearFactory( academic_year=self.current_academic_year, container_type=learning_container_year_types.COURSE) learning_unit_yr = LearningUnitYearFactory( academic_year=self.current_academic_year, subtype=learning_unit_year_subtypes.FULL, learning_unit=LearningUnitFactory(), learning_container_year=lcy) self._assert_no_permission_end_year(faculty_person, learning_unit_yr)
def step_impl(context: Context): context.user = FacultyManagerFactory( user__username="******", user__first_name="Keyser", user__last_name="Söze", user__password="******").user page = LoginPage(driver=context.browser, base_url=context.get_url('/login/')).open() page.login("usual_suspect", 'Roger_Verbal_Kint') context.test.assertEqual(context.browser.current_url, context.get_url('/'))
def test_not_is_eligible_to_modify_by_proposal(self, mock_perm): learning_unit_yr = LearningUnitYearFactory( academic_year=self.current_academic_year, subtype=learning_unit_year_subtypes.FULL, learning_container_year=self.lcy) person_faculty_manager = FacultyManagerFactory() with self.assertRaises(PermissionDenied) as perm_ex: is_eligible_to_modify_by_proposal(learning_unit_yr, person_faculty_manager, True) self.assertEqual('{}'.format(perm_ex.exception), MSG_NOT_ELIGIBLE_TO_PUT_IN_PROPOSAL_ON_THIS_YEAR)
def setUpTestData(cls): cls.current_acy, cls.previous_acy = AcademicYearFactory.produce_in_past( from_year=2019, quantity=2) cls.group_element_year = GroupElementYearFactory( parent=TrainingFactory(academic_year=cls.current_acy), child_branch=MiniTrainingFactory(academic_year=cls.current_acy), ) cls.faculty_manager = FacultyManagerFactory() cls.faculty_manager.user.user_permissions.add( Permission.objects.get(codename="change_educationgroup")) PersonEntityFactory( entity=cls.group_element_year.parent.management_entity, person=cls.faculty_manager)
def test_is_eligible_to_modify_end_year_by_proposal(self, mock_perm): lu = LearningUnitFactory(existing_proposal_in_epc=False) learning_unit_yr = LearningUnitYearFactory( academic_year=self.next_academic_yr, subtype=learning_unit_year_subtypes.FULL, learning_unit=lu, learning_container_year=self.lcy) ProposalLearningUnitFactory(learning_unit_year=learning_unit_yr) person_faculty_manager = FacultyManagerFactory() self.assertTrue( is_eligible_to_modify_end_year_by_proposal(learning_unit_yr, person_faculty_manager, True))
def test_li_edit_proposal_as_faculty_manager(self): person_faculty_manager = FacultyManagerFactory() self.context['user'] = person_faculty_manager.user self.context['proposal'] = self.proposal self.context['learning_unit_year'] = self.proposal.learning_unit_year result = li_edit_proposal(self.context, self.url_edit, "") self.assertEqual( result, self._get_result_data_expected_for_proposal( 'link_proposal_edit', MSG_CAN_EDIT_PROPOSAL_NO_LINK_TO_ENTITY, DISABLED)) faculty_manager_person = FacultyManagerFactory() PersonEntityFactory(person=faculty_manager_person, entity=self.requirement_entity) self.context['user'] = faculty_manager_person.user self.context['person'] = faculty_manager_person self.proposal.state = ProposalState.CENTRAL.name self.proposal.save() self.context['proposal'] = self.proposal result = li_edit_proposal(self.context, self.url_edit, "") self.assertEqual( result, self._get_result_data_expected_for_proposal( 'link_proposal_edit', MSG_NOT_PROPOSAL_STATE_FACULTY, DISABLED)) self.proposal.state = ProposalState.FACULTY.name self.proposal.save() self.context['proposal'] = self.proposal result = li_edit_proposal(self.context, self.url_edit, "") self.assertEqual( result, self._get_result_data_expected_for_proposal( 'link_proposal_edit', MSG_NOT_ELIGIBLE_TO_EDIT_PROPOSAL, DISABLED))
def setUpTestData(cls): cls.current_acy, cls.previous_acy = AcademicYearFactory.produce_in_past( from_year=2019, quantity=2) cls.group_element_year = GroupElementYearFactory( parent=TrainingFactory(academic_year=cls.current_acy), child_branch=MiniTrainingFactory( academic_year=cls.current_acy, education_group_type__name=MiniTrainingType.DEEPENING.name), ) cls.faculty_manager = FacultyManagerFactory( 'change_educationgroup', 'change_educationgroupcontent') PersonEntityFactory( entity=cls.group_element_year.parent.management_entity, person=cls.faculty_manager)
def setUpTestData(cls): cls.current_acy = create_current_academic_year() cls.academic_years = GenerateAcademicYear( cls.current_acy.year - LEARNING_UNIT_CREATION_SPAN_YEARS, cls.current_acy.year + LEARNING_UNIT_CREATION_SPAN_YEARS).academic_years cls.academic_years[LEARNING_UNIT_CREATION_SPAN_YEARS] = cls.current_acy cls.learning_unit_years = [ LearningUnitYearFactory(academic_year=acy) for acy in cls.academic_years ] cls.faculty_manager = FacultyManagerFactory() cls.central_manager = CentralManagerFactory()
def test_can_modify_by_proposal_n_year(self): faculty_person = FacultyManagerFactory() lcy = LearningContainerYearFactory( academic_year=self.current_academic_year, container_type=learning_container_year_types.COURSE) learning_unit_yr = LearningUnitYearFactory( academic_year=self.current_academic_year, subtype=learning_unit_year_subtypes.FULL, learning_unit=LearningUnitFactory(), learning_container_year=lcy) self._modify_permission_assert(faculty_person, learning_unit_yr) central_person = CentralManagerFactory() self.assertTrue( can_modify_by_proposal(learning_unit_yr, central_person, True))
def test_raise_permission_denied_when_minor_or_major_list_choice_and_person_is_faculty_manager(self): OpenAcademicCalendarFactory(reference=EDUCATION_GROUP_EDITION, academic_year=self.previous_acy) egys = [ GroupFactory(education_group_type__name=GroupType.MINOR_LIST_CHOICE.name, academic_year=self.current_acy), GroupFactory(education_group_type__name=GroupType.MAJOR_LIST_CHOICE.name, academic_year=self.current_acy) ] person_entity = PersonEntityFactory(entity=self.group_element_year.parent.management_entity, person=FacultyManagerFactory()) for egy in egys: with self.subTest(type=egy.education_group_type): with self.assertRaises(PermissionDenied): group_element_year = GroupElementYearFactory(parent=self.group_element_year.parent, child_branch=egy) can_update_group_element_year(person_entity.person.user, group_element_year)
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_academic_year_range_creation_proposal_faculty_manager(self): LanguageFactory(code="FR") faculty_manager = FacultyManagerFactory() form = learning_unit_create_2.FullForm( faculty_manager, self.learning_unit_year.academic_year, start_year=self.learning_unit_year.academic_year, proposal_type=ProposalType.CREATION.name ) self.assertCountEqual( list(form.fields['academic_year'].queryset), list(academic_year_mdl.find_academic_years( start_year=self.current_academic_year.year + 1, end_year=self.current_academic_year.year + 6 )) )
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])