def setUp(self): self.academic_year = create_current_academic_year() self.learning_unit_year = LearningUnitYearFactory( academic_year=self.academic_year, subtype=learning_unit_year_subtypes.FULL) self.language_fr = LanguageFactory(code="FR") self.language_en = LanguageFactory(code="EN") self.user = UserFactory() self.user.user_permissions.add( Permission.objects.get(codename="can_access_learningunit")) self.user.user_permissions.add( Permission.objects.get(codename="can_create_learningunit")) self.person = PersonFactory(user=self.user) self.a_superuser = SuperUserFactory() self.client.force_login(self.a_superuser) self.superperson = PersonFactory(user=self.a_superuser) self.person_entity = PersonEntityFactory(person=self.superperson) EntityContainerYearFactory( learning_container_year=self.learning_unit_year. learning_container_year, entity=self.person_entity.entity, type=entity_container_year_link_type.REQUIREMENT_ENTITY)
def setUp(self): self.language_fr = LanguageFactory(code="FR") self.language_en = LanguageFactory(code="EN") self.user = UserFactory() self.person = PersonFactory(user=self.user) self.person_entity = PersonEntityFactory(person=self.person) self.academic_year = create_current_academic_year() self.learning_unit_year = LearningUnitYearFactory( academic_year=self.academic_year, subtype=learning_unit_year_subtypes.FULL, learning_container_year__requirement_entity=self.person_entity.entity, ) self.client.force_login(self.user) self.achievement_fr = LearningAchievementFactory( language=self.language_fr, learning_unit_year=self.learning_unit_year, order=0 ) self.achievement_en = LearningAchievementFactory( language=self.language_en, learning_unit_year=self.learning_unit_year, order=0, code_name=self.achievement_fr.code_name ) self.reverse_learning_unit_yr = reverse('learning_unit', args=[self.learning_unit_year.id]) flag, created = Flag.objects.get_or_create(name='learning_achievement_update') flag.users.add(self.user) self.request_factory = RequestFactory()
def setUpTestData(cls): cls.language_fr = LanguageFactory(code="FR") cls.language_en = LanguageFactory(code="EN") cls.user = UserFactory() flag, created = Flag.objects.get_or_create(name='learning_achievement_update') flag.users.add(cls.user) cls.person = PersonWithPermissionsFactory("can_access_learningunit", "can_create_learningunit", user=cls.user) cls.person_entity = PersonEntityFactory(person=cls.person) EntityVersionFactory(entity=cls.person_entity.entity) cls.academic_years = AcademicYearFactory.produce_in_future(quantity=5) cls.max_la_number = 2*len(cls.academic_years) cls.learning_unit = LearningUnitFactory(start_year=cls.academic_years[0], end_year=cls.academic_years[-1]) cls.learning_container = LearningContainerFactory() cls.learning_unit_years = [LearningUnitYearFactory( academic_year=academic_year, subtype=learning_unit_year_subtypes.FULL, learning_container_year=LearningContainerYearFactory( academic_year=academic_year, learning_container=cls.learning_container, requirement_entity=cls.person_entity.entity ), learning_unit=cls.learning_unit, acronym="TEST0000" ) for academic_year in cls.academic_years] cls.learning_component_years = [LearningComponentYearFactory( learning_unit_year=luy, ) for luy in cls.learning_unit_years]
def setUp(self): self.academic_year = create_current_academic_year() self.learning_unit_year = LearningUnitYearFactory( academic_year=self.academic_year, subtype=learning_unit_year_subtypes.FULL) self.language_fr = LanguageFactory(code=FR_CODE_LANGUAGE) self.language_en = LanguageFactory(code=EN_CODE_LANGUAGE)
def setUp(self): current_academic_year = create_current_academic_year() generated_container = GenerateContainer(start_year=current_academic_year.year, end_year=current_academic_year.year) generated_container_first_year = generated_container.generated_container_years[0] self.luy = generated_container_first_year.learning_unit_year_full self.language_fr = LanguageFactory(code='FR') self.language_en = LanguageFactory(code='EN')
def setUpTestData(cls): cls.academic_year = create_current_academic_year() cls.learning_unit_year = LearningUnitYearFactory( academic_year=cls.academic_year, subtype=learning_unit_year_subtypes.FULL) cls.language_fr = LanguageFactory(code=FR_CODE_LANGUAGE) cls.language_en = LanguageFactory(code=EN_CODE_LANGUAGE)
def setUpTestData(cls): cls.language_fr = LanguageFactory(code="FR") cls.language_en = LanguageFactory(code="EN") cls.learning_unit_year = LearningUnitYearFactory( academic_year=create_current_academic_year()) cls.learning_achievement = LearningAchievementFactory( learning_unit_year=cls.learning_unit_year, language=cls.language_fr, code_name='TEST', )
def setUpTestData(cls): cls.person = PersonFactory() starting_year = AcademicYearFactory(year=YEAR_LIMIT_LUE_MODIFICATION) end_year = AcademicYearFactory(year=YEAR_LIMIT_LUE_MODIFICATION + 6) academic_years = GenerateAcademicYear(starting_year, end_year).academic_years cls.academic_year = academic_years[1] cls.language = LanguageFactory(code='FR') organization = OrganizationFactory(type=organization_type.MAIN) cls.campus = CampusFactory(organization=organization) cls.language = LanguageFactory(code='FR') cls.container_year = LearningContainerYearFactory( academic_year=cls.academic_year, container_type=EXTERNAL) cls.learning_unit = LearningUnitFactory(start_year=cls.academic_year)
def setUp(self): self.current_academic_year = create_current_academic_year() self.generated_ac_years = GenerateAcademicYear( self.current_academic_year.year + 1, self.current_academic_year.year + 10) self.parent_education_group_year = EducationGroupYearFactory( academic_year=self.current_academic_year) self.test_categories = [ education_group_categories.GROUP, education_group_categories.TRAINING, education_group_categories.MINI_TRAINING, ] self.education_group_types = [ EducationGroupTypeFactory(category=category) for category in self.test_categories ] self.organization = OrganizationFactory(type=organization_type.MAIN) self.entity = EntityFactory(organization=self.organization) self.entity_version = EntityVersionFactory(entity=self.entity, entity_type=FACULTY, start_date=datetime.now()) self.language = LanguageFactory() self.person = PersonFactory() PersonEntityFactory(person=self.person, entity=self.entity) self.client.force_login(self.person.user) self.perm_patcher = mock.patch( "base.business.education_groups.perms._is_eligible_to_add_education_group", return_value=True) self.mocked_perm = self.perm_patcher.start()
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 setUp(self): self.education_group_year = TrainingFactory( academic_year=create_current_academic_year()) self.education_group_type = EducationGroupTypeFactory( category=education_group_categories.TRAINING) EntityVersionFactory( entity=self.education_group_year.administration_entity) EntityVersionFactory( entity=self.education_group_year.management_entity) self.list_acs = GenerateAcademicYear(get_current_year(), get_current_year() + 40).academic_years self.data = { 'title': 'Métamorphose', 'title_english': 'Transfiguration', 'education_group_type': self.education_group_type.pk, 'credits': 42, 'acronym': 'CRSCHOIXDVLD', 'partial_acronym': 'LDVLD101R', 'management_entity': MainEntityVersionFactory().pk, 'administration_entity': MainEntityVersionFactory().pk, 'main_teaching_campus': "", 'academic_year': create_current_academic_year().pk, 'active': ACTIVE, 'schedule_type': DAILY, "internship": internship_presence.NO, "primary_language": LanguageFactory().pk, "start_year": 2010, "constraint_type": "", }
def setUp(self): today = datetime.date.today() self.faculty_user = factory_user.UserFactory() self.faculty_user.groups.add( Group.objects.get(name=FACULTY_MANAGER_GROUP)) self.faculty_person = factory_person.PersonFactory( user=self.faculty_user) self.faculty_user.user_permissions.add( Permission.objects.get(codename='can_propose_learningunit')) self.faculty_user.user_permissions.add( Permission.objects.get(codename='can_create_learningunit')) self.super_user = factory_user.SuperUserFactory() self.person = factory_person.PersonFactory(user=self.super_user) self.academic_year = AcademicYearFactory.build( start_date=today.replace(year=today.year + 1), end_date=today.replace(year=today.year + 2), year=today.year + 1) super(AcademicYear, self.academic_year).save() self.language = LanguageFactory(code='FR') self.organization = organization_factory.OrganizationFactory( type=organization_type.MAIN) self.campus = campus_factory.CampusFactory( organization=self.organization, is_administration=True) self.entity = EntityFactory(organization=self.organization) self.entity_version = EntityVersionFactory( entity=self.entity, entity_type=entity_type.SCHOOL, start_date=today - datetime.timedelta(days=1), end_date=today.replace(year=today.year + 1)) PersonEntityFactory(person=self.faculty_person, entity=self.entity)
def setUp(self): today = datetime.date.today() self.faculty_user = factory_user.UserFactory() self.faculty_user.groups.add( Group.objects.get(name=FACULTY_MANAGER_GROUP)) self.faculty_person = factory_person.PersonFactory( user=self.faculty_user) self.faculty_user.user_permissions.add( Permission.objects.get(codename='can_propose_learningunit')) self.faculty_user.user_permissions.add( Permission.objects.get(codename='can_create_learningunit')) self.super_user = factory_user.SuperUserFactory() self.person = factory_person.PersonFactory(user=self.super_user) self.academic_years = GenerateAcademicYear(get_current_year(), get_current_year() + 7).academic_years self.current_academic_year = self.academic_years[0] self.next_academic_year = self.academic_years[1] self.language = LanguageFactory(code='FR') self.organization = organization_factory.OrganizationFactory( type=organization_type.MAIN) self.campus = campus_factory.CampusFactory( organization=self.organization, is_administration=True) self.entity = EntityFactory(organization=self.organization) self.entity_version = EntityVersionFactory( entity=self.entity, entity_type=entity_type.FACULTY, start_date=today.replace(year=1900), end_date=None) PersonEntityFactory(person=self.faculty_person, entity=self.entity) PersonEntityFactory(person=self.person, entity=self.entity)
def setUpTestData(cls): cls._create_luy() cls._set_entities() cls._create_cms_data() cls.teaching_material = TeachingMaterialFactory( learning_unit_year=cls.l_unit_yr_1, title='Teaching material title') cls.learning_unit_achievement_fr = LearningAchievementFactory( learning_unit_year=cls.l_unit_yr_1, language=LanguageFactory(code='FR')) cls.learning_unit_achievement_en = LearningAchievementFactory( learning_unit_year=cls.l_unit_yr_1, language=LanguageFactory(code='EN')) cls.entity_requirement = EntityVersion.objects.filter(entity=OuterRef( 'learning_container_year__requirement_entity'), ).current( OuterRef('academic_year__start_date')).values('acronym')[:1]
def test_check_postponement_conflict_learning_unit_year_case_language_diff( self): # Copy the same learning unit year + change academic year, language another_learning_unit_year = _build_copy(self.learning_unit_year) another_learning_unit_year.academic_year = self.next_academic_year another_learning_unit_year.language = LanguageFactory(code='FR', name='French') another_learning_unit_year.save() error_list = business_edition._check_postponement_conflict_on_learning_unit_year( self.learning_unit_year, another_learning_unit_year) self.assertIsInstance(error_list, list) self.assertEqual(len(error_list), 1) generic_error = "The value of field '%(field)s' is different between year %(year)s - %(value)s " \ "and year %(next_year)s - %(next_value)s" # Error : Language diff error_language = _(generic_error) % { 'field': _('language'), 'year': self.learning_container_year.academic_year, 'value': getattr(self.learning_unit_year, 'language'), 'next_year': another_learning_unit_year.academic_year, 'next_value': getattr(another_learning_unit_year, 'language') } self.assertIn(error_language, error_list)
def setUp(self): self.academic_year = create_current_academic_year() self.next_academic_year = AcademicYearFactory(year=self.academic_year.year + 1) self.learning_container_year = LearningContainerYearFactory(academic_year=self.academic_year, common_title='common title', language=LanguageFactory(code='EN', name='English'), campus=CampusFactory(name='MIT')) self.learning_unit_year = _create_learning_unit_year_with_components(self.learning_container_year, create_lecturing_component=True, create_pratical_component=True) an_entity = EntityFactory() self.entity_version = EntityVersionFactory(entity=an_entity, parent=None, end_date=None, acronym="DRT") self.allocation_entity = _create_entity_container_with_entity_components( self.learning_unit_year, entity_container_year_link_type.ALLOCATION_ENTITY, an_entity ) self.requirement_entity = _create_entity_container_with_entity_components( self.learning_unit_year, entity_container_year_link_type.REQUIREMENT_ENTITY, an_entity, repartition_lecturing=30, repartition_practical_exercises=10 ) self.add_requirement_entity_1 = _create_entity_container_with_entity_components( self.learning_unit_year, entity_container_year_link_type.ADDITIONAL_REQUIREMENT_ENTITY_1, an_entity, repartition_lecturing=10, repartition_practical_exercises=5 )
def setUp(self): self.person = PersonFactory() starting_year = YEAR_LIMIT_LUE_MODIFICATION self.academic_years = GenerateAcademicYear( starting_year, starting_year + 6).academic_years self.academic_year = self.academic_years[1] self.language = LanguageFactory(code='FR')
def _create_learning_unit_year_with_components(l_container, create_lecturing_component=True, create_pratical_component=True): language = LanguageFactory(code='EN', name='English') a_learning_unit_year = LearningUnitYearFactory( learning_container_year=l_container, acronym=l_container.acronym, academic_year=l_container.academic_year, status=True, language=language, campus=CampusFactory(name='MIT')) if create_lecturing_component: a_component = LearningComponentYearFactory( learning_container_year=l_container, type=learning_component_year_type.LECTURING, planned_classes=1) LearningUnitComponentFactory(learning_unit_year=a_learning_unit_year, learning_component_year=a_component) if create_pratical_component: a_component = LearningComponentYearFactory( learning_container_year=l_container, type=learning_component_year_type.PRACTICAL_EXERCISES, planned_classes=1) LearningUnitComponentFactory(learning_unit_year=a_learning_unit_year, learning_component_year=a_component) return a_learning_unit_year
def setUp(self): self.data = { 'title': 'Métamorphose', 'title_english': 'Transfiguration', 'education_group_type': self.education_group_type.pk, 'credits': 42, 'acronym': 'CRSCHOIXDVLD', 'partial_acronym': 'LDVLD101R', 'management_entity': self.management_entity_version.pk, 'administration_entity': MainEntityVersionFactory().pk, 'main_teaching_campus': "", 'academic_year': create_current_academic_year().pk, 'active': ACTIVE, 'schedule_type': DAILY, "internship": internship_presence.NO, "primary_language": LanguageFactory().pk, "start_year": 2010, "constraint_type": "", "diploma_printing_title": 'Diploma title' } self.administration_entity_version = MainEntityVersionFactory() self.education_group_year = TrainingFactory( academic_year=create_current_academic_year(), education_group_type__name=education_group_types.TrainingType. BACHELOR, management_entity=self.management_entity_version.entity, administration_entity=self.administration_entity_version.entity, ) PersonEntityFactory(person=self.person, entity=self.education_group_year.management_entity)
def setUpTestData(cls): starting_year = AcademicYearFactory(year=YEAR_LIMIT_LUE_MODIFICATION) end_year = AcademicYearFactory(year=YEAR_LIMIT_LUE_MODIFICATION + 6) cls.academic_years = GenerateAcademicYear(starting_year, end_year).academic_years cls.academic_year = cls.academic_years[1] cls.language = LanguageFactory(code='FR')
def test_post_mini_training(self): old_domain = DomainFactory() EducationGroupYearDomainFactory( education_group_year=self.mini_training_education_group_year, domain=old_domain) new_entity_version = MainEntityVersionFactory() PersonEntityFactory(person=self.person, entity=new_entity_version.entity) data = { 'title': 'Cours au choix', 'title_english': 'deaze', 'education_group_type': self.a_mini_training_education_group_type.pk, 'credits': 42, 'acronym': 'CRSCHOIXDVLD', 'partial_acronym': 'LDVLD101R', 'management_entity': new_entity_version.pk, 'main_teaching_campus': "", 'academic_year': self.mini_training_education_group_year.academic_year.pk, 'active': ACTIVE, 'schedule_type': DAILY, "primary_language": LanguageFactory().pk, "start_year": 2010, "constraint_type": "", "diploma_printing_title": "Diploma Title", } response = self.client.post(self.mini_training_url, data=data) self.assertEqual(response.status_code, HttpResponseRedirect.status_code) self.mini_training_education_group_year.refresh_from_db() self.assertEqual(self.mini_training_education_group_year.title, 'Cours au choix') self.assertEqual(self.mini_training_education_group_year.title_english, 'deaze') self.assertEqual(self.mini_training_education_group_year.credits, 42) self.assertEqual(self.mini_training_education_group_year.acronym, 'CRSCHOIXDVLD') self.assertEqual( self.mini_training_education_group_year.partial_acronym, 'LDVLD101R') self.assertEqual( self.mini_training_education_group_year.management_entity, new_entity_version.entity)
def get_valid_external_learning_unit_form_data(academic_year, person, learning_unit_year=None): entities = create_entities_hierarchy() PersonEntityFactory(person=person, entity=entities['root_entity'], with_child=True) requesting_entity = entities['child_one_entity_version'] organization = OrganizationFactory(type=organization_type.MAIN) campus = CampusFactory(organization=organization) language = LanguageFactory(code='FR') if not learning_unit_year: container_year = LearningContainerYearFactory(academic_year=academic_year) learning_unit_year = LearningUnitYearFactory.build( acronym='EOSIS1111', academic_year=academic_year, learning_container_year=container_year, subtype=learning_unit_year_subtypes.FULL, campus=campus, language=language ) return { # Learning unit year data model form 'acronym_0': learning_unit_year.acronym[0], 'acronym_1': learning_unit_year.acronym[1:], 'acronym_2': "A", 'academic_year': learning_unit_year.academic_year.id, 'specific_title': learning_unit_year.specific_title, 'specific_title_english': learning_unit_year.specific_title_english, 'credits': learning_unit_year.credits, 'status': learning_unit_year.status, 'campus': learning_unit_year.campus.id, 'language': learning_unit_year.language.pk, 'periodicity': learning_unit_year.periodicity, # Learning unit data model form 'faculty_remark': learning_unit_year.learning_unit.faculty_remark, # Learning container year data model form 'common_title': learning_unit_year.learning_container_year.common_title, 'common_title_english': learning_unit_year.learning_container_year.common_title_english, 'is_vacant': learning_unit_year.learning_container_year.is_vacant, # External learning unit model form 'requirement_entity': requesting_entity.id, 'allocation_entity': requesting_entity.id, 'external_acronym': 'Gorzyne', 'external_credits': '5', # Learning component year data model form 'component-TOTAL_FORMS': '2', 'component-INITIAL_FORMS': '0', 'component-MAX_NUM_FORMS': '2', 'component-0-hourly_volume_total_annual': 20, 'component-0-hourly_volume_partial_q1': 10, 'component-0-hourly_volume_partial_q2': 10, 'component-0-planned_classes': 1, 'component-1-hourly_volume_total_annual': 20, 'component-1-hourly_volume_partial_q1': 10, 'component-1-hourly_volume_partial_q2': 10, 'component-1-planned_classes': 1, }
def setUp(self): academic_year = AcademicYearFactory() self.education_group_year = EducationGroupYearFactory(academic_year=academic_year) self.language = LanguageFactory() self.education_group_language_1 = EducationGroupLanguageFactory(education_group_year=self.education_group_year, language=self.language) self.education_group_language_2 = EducationGroupLanguageFactory(education_group_year=self.education_group_year, language=self.language)
def setUp(self): self.person = PersonFactory() an_organization = OrganizationFactory(type=organization_type.MAIN) current_academic_year = create_current_academic_year() learning_container_year = LearningContainerYearFactory( academic_year=current_academic_year, container_type=learning_container_year_types.COURSE, campus=CampusFactory(organization=an_organization, is_administration=True)) self.learning_unit_year = LearningUnitYearFakerFactory( credits=5, subtype=learning_unit_year_subtypes.FULL, academic_year=current_academic_year, learning_container_year=learning_container_year) self.entity_container_year = EntityContainerYearFactory( learning_container_year=self.learning_unit_year. learning_container_year, type=entity_container_year_link_type.REQUIREMENT_ENTITY) today = datetime.date.today() an_entity = EntityFactory(organization=an_organization) self.entity_version = EntityVersionFactory( entity=an_entity, entity_type=entity_type.SCHOOL, start_date=today, end_date=today.replace(year=today.year + 1)) self.language = LanguageFactory(code="EN") self.campus = CampusFactory( name="OSIS Campus", organization=OrganizationFactory(type=organization_type.MAIN), is_administration=True) self.form_data = { "academic_year": self.learning_unit_year.academic_year.id, "first_letter": "L", "acronym": "OSIS1245", "common_title": "New common title", "common_title_english": "New common title english", "specific_title": "New title", "specific_title_english": "New title english", "container_type": self.learning_unit_year.learning_container_year.container_type, "internship_subtype": "", "credits": "4", "periodicity": learning_unit_periodicity.BIENNIAL_ODD, "status": False, "language": self.language.pk, "quadrimester": learning_unit_year_quadrimesters.Q1, "campus": self.campus.id, "requirement_entity": self.entity_version.id, "allocation_entity": self.entity_version.id, "entity": self.entity_version.id, "folder_id": "1", "state": proposal_state.ProposalState.CENTRAL.name }
def setUpTestData(cls): cls.current_academic_year = create_current_academic_year() cls.generated_ac_years = GenerateAcademicYear( cls.current_academic_year.year + 1, cls.current_academic_year.year + 10) cls.parent_education_group_year = EducationGroupYearFactory( academic_year=cls.current_academic_year) cls.test_categories = [ education_group_categories.GROUP, education_group_categories.TRAINING, education_group_categories.MINI_TRAINING, ] cls.education_group_types = [ EducationGroupTypeFactory(category=category) for category in cls.test_categories ] cls.urls_without_parent_by_category = { education_group_type.category: reverse("new_education_group", kwargs={ "category": education_group_type.category, "education_group_type_pk": education_group_type.pk, }) for education_group_type in cls.education_group_types } cls.urls_with_parent_by_category = { education_group_type.category: reverse("new_education_group", kwargs={ "category": education_group_type.category, "education_group_type_pk": education_group_type.pk, "root_id": cls.parent_education_group_year.id, "parent_id": cls.parent_education_group_year.id, }) for education_group_type in cls.education_group_types } cls.expected_templates_by_category = { education_group_categories.GROUP: "education_group/create_groups.html", education_group_categories.TRAINING: "education_group/create_trainings.html", education_group_categories.MINI_TRAINING: "education_group/create_mini_trainings.html", } cls.organization = OrganizationFactory(type=organization_type.MAIN) cls.entity = EntityFactory(organization=cls.organization) cls.entity_version = EntityVersionFactory(entity=cls.entity, entity_type=FACULTY, start_date=datetime.now()) cls.language = LanguageFactory() cls.person = PersonFactory() PersonEntityFactory(person=cls.person, entity=cls.entity)
def setUpTestData(cls): cls.initial_language = LanguageFactory(code='FR') cls.initial_campus = CampusFactory(name='Louvain-la-Neuve', organization__type=organization_type.MAIN) cls.current_academic_year = create_current_academic_year() # Creation of a LearningContainerYear and all related models cls.learn_unit_structure = GenerateContainer(cls.current_academic_year, cls.current_academic_year) start_year = AcademicYearFactory(year=cls.current_academic_year.year - 3) end_year = AcademicYearFactory(year=cls.current_academic_year.year + 7) cls.acs = GenerateAcademicYear(start_year=start_year, end_year=end_year).academic_years
def setUp(self): self.person = PersonFactory() self.academic_year = create_current_academic_year() self.language = LanguageFactory(code='FR') organization = OrganizationFactory(type=organization_type.MAIN) campus = CampusFactory(organization=organization) language = LanguageFactory(code='FR') container_year = LearningContainerYearFactory(academic_year=self.academic_year, container_type=EXTERNAL) self.learning_unit = LearningUnitFactory(start_year=self.academic_year.year) self.learning_unit_year = LearningUnitYearFactory( acronym='EOSIS1111', academic_year=self.academic_year, learning_unit=self.learning_unit, learning_container_year=container_year, subtype=learning_unit_year_subtypes.FULL, campus=campus, language=language, internship_subtype=None )
def setUpTestData(cls): academic_year = AcademicYearFactory() cls.education_group_year = EducationGroupYearFactory( academic_year=academic_year) cls.language = LanguageFactory() cls.education_group_language_1 = EducationGroupLanguageFactory( education_group_year=cls.education_group_year, language=cls.language) cls.education_group_language_2 = EducationGroupLanguageFactory( education_group_year=cls.education_group_year, language=cls.language)
def setUp(self): self.user = UserFactory() self.user.user_permissions.add(Permission.objects.get(codename="can_access_learningunit")) self.user.user_permissions.add(Permission.objects.get(codename="can_create_learningunit")) self.user.user_permissions.add(Permission.objects.get(codename="can_propose_learningunit")) self.person = PersonFactory(user=self.user) self.client.force_login(self.user) self.academic_year = create_current_academic_year() self.language = LanguageFactory(code='FR') self.data = get_valid_external_learning_unit_form_data(self.academic_year, self.person) self.url = reverse(get_external_learning_unit_creation_form, args=[self.academic_year.pk])
def setUpTestData(cls): cls.language_fr = LanguageFactory(code="FR") cls.language_en = LanguageFactory(code="EN") cls.user = UserFactory() cls.person = PersonWithPermissionsFactory("can_access_learningunit", "can_create_learningunit", user=cls.user) cls.a_superuser = SuperUserFactory() cls.superperson = PersonFactory(user=cls.a_superuser) cls.person_entity = PersonEntityFactory(person=cls.superperson) cls.academic_year = create_current_academic_year() AcademicYearFactory.produce_in_future(quantity=2) cls.luy = LearningUnitYearFactory( academic_year=cls.academic_year, subtype=learning_unit_year_subtypes.FULL, learning_container_year__requirement_entity=cls.person_entity.entity, ) cls.future_luy = LearningUnitYearFactory( academic_year=cls.academic_year.next(), learning_unit=cls.luy.learning_unit, )