def setUpTestData(cls):
cls.user = UserFactory()
cls.citizenship = CountryFactory(iso_code='FR')
new_country = CountryFactory(iso_code='NL')
cls.person = ContinuingEducationPersonFactory(
birth_country=cls.citizenship
)
cls.address = AddressFactory()
cls.academic_year = AcademicYearFactory(year=2018)
cls.url = reverse('continuing_education_api_v1:admission-list', kwargs={'uuid': cls.person.uuid})
for state in [SUBMITTED, ACCEPTED, REJECTED, DRAFT]:
education_group = EducationGroupFactory()
EducationGroupYearFactory(
education_group=education_group,
academic_year=cls.academic_year
)
cls.formation = ContinuingEducationTrainingFactory(education_group=education_group)
cls.admission = AdmissionFactory(
citizenship=cls.citizenship,
person_information=cls.person,
address=cls.address,
state=state,
formation=cls.formation
)
def setUpTestData(cls):
cls.country_1 = CountryFactory(name="country_1", iso_code="C1")
cls.country_2 = CountryFactory(name="country_2", iso_code="C2")
cls.country_3 = CountryFactory(name="country_3", iso_code="C3")
cls.academic_year_1 = AcademicYearFactory(year=2040)
cls.academic_year_2 = AcademicYearFactory(current=True)
cls.academic_year_3 = AcademicYearFactory(year=2041)
cls.financing_1 = FinancingFactory(
type__name="financing_1",
academic_year=cls.academic_year_1,
)
cls.financing_2 = FinancingFactory(
type__name="financing_2",
academic_year=cls.academic_year_1,
)
cls.financing_3 = FinancingFactory(
type__name="financing_3",
academic_year=cls.academic_year_3,
)
cls.financing_1.countries.set([cls.country_1, cls.country_2])
cls.financing_2.countries.set([cls.country_3])
cls.user = UserFactory()
cls.user_adri = UserFactory()
entity_version = EntityVersionFactory(acronym='ADRI')
PartnershipEntityManagerFactory(entity=entity_version.entity,
person__user=cls.user_adri)
cls.url = reverse('partnerships:financings:export',
kwargs={'year': cls.academic_year_1.year})
cls.url_empty = reverse('partnerships:financings:export')
def test_get_financing(self):
self.client.force_login(self.user)
academic_year = AcademicYearFactory()
financing = FinancingFactory(academic_year=academic_year)
country = CountryFactory(iso_code="BA")
financing.countries.add(country)
year = PartnershipYearFactory(
partnership__partner__contact_address=None,
academic_year=academic_year,
)
# No financing because no address
self.assertEqual(year.get_financing(), None)
year = PartnershipYearFactory(
partnership__partner__contact_address__country__iso_code="FO",
academic_year=academic_year,
)
# No financing for this country
self.assertEqual(year.get_financing(), None)
financing = FinancingFactory(academic_year=academic_year)
country = CountryFactory(iso_code="FO")
financing.countries.add(country)
# Correct financing
self.assertEqual(year.get_financing(), financing)
def setUpTestData(cls):
cls.user = UserFactory()
cls.url = reverse('reference_api_v1:country-list')
CountryFactory(iso_code='BE')
CountryFactory(iso_code='FR')
CountryFactory(iso_code='UK')
def setUpTestData(cls):
cls.birth_country = CountryFactory()
fr = CountryFactory(iso_code='FR')
cls.user = UserFactory()
p = PersonFactory(user=cls.user)
cls.person = ContinuingEducationPersonFactory(
person=p, birth_country=cls.birth_country)
cls.url = reverse('continuing_education_api_v1:person-detail')
def setUpTestData(cls):
cls.user = UserFactory()
cls.url = reverse('continuing_education_api_v1:person-list-create')
cls.birth_country = CountryFactory()
cls.country = CountryFactory(iso_code='FR')
cls.person = PersonFactory()
for x in range(3):
ContinuingEducationPersonFactory(birth_country=cls.birth_country)
def setUpTestData(cls):
cls.filename_1 = tempfile.mkstemp(suffix='.csv')[1]
cls.filename_2 = tempfile.mkstemp(suffix='.csv')[1]
cls.filename_3 = tempfile.mkstemp(suffix='.badext')[1]
cls.country_1 = CountryFactory(name='country_1', iso_code='C1')
cls.country_2 = CountryFactory(name='country_2', iso_code='C2')
cls.country_3 = CountryFactory(name='country_3', iso_code='C3')
cls.country_4 = CountryFactory(name='country_4', iso_code='C4')
FundingSourceFactory(name='Source1')
FundingSourceFactory(name='Source2')
FundingProgramFactory(name='ProgramA')
FundingProgramFactory(name='ProgramB')
FundingProgramFactory(name='ProgramC')
with open(cls.filename_1, 'w') as f:
f.write('country_name;country;name;url;program;source\n')
f.write(
'{0.name};{0.iso_code};foo;http://foo.com;ProgramB;Source2\n'.
format(cls.country_1))
f.write(
'{0.name};{0.iso_code};bar;http://bar.com;ProgramC;Source2\n'.
format(cls.country_2))
f.write(
'{0.name};{0.iso_code};foo;http://foo.com;ProgramA;Source1\n'.
format(cls.country_3))
# bad country
f.write('FOO;ZZ;baz;http://baz.com;ProgramD;Source1\n')
# bad program
f.write(
'{0.name};{0.iso_code};foo;http://foo.com;bad program;Source1\n'
.format(cls.country_3))
# bad url
f.write(
'{0.name};{0.iso_code};foo;badurl;ProgramA;Source1\n'.format(
cls.country_3))
# no name
f.write('{0.name};{0.iso_code};;badurl;ProgramA;Source1\n'.format(
cls.country_2))
with open(cls.filename_2, 'w') as f:
f.write('country_name;country;name;url;program;source\n')
f.write(
'{0.name};{0.iso_code};foo;http://foobis.com;ProgramA;Source1\n'
.format(cls.country_4))
with open(cls.filename_3, 'w') as f:
f.writelines(['foo', 'bar'])
cls.user = UserFactory()
cls.user_adri = UserFactory()
entity_version = EntityVersionFactory(acronym='ADRI')
PartnershipEntityManagerFactory(entity=entity_version.entity,
person__user=cls.user_adri)
cls.academic_year = AcademicYearFactory()
cls.url = reverse('partnerships:financings:import')
def setUpTestData(cls):
cls.country = CountryFactory()
cls.new_country = CountryFactory(iso_code='FR', name="France")
cls.address = AddressFactory(country=cls.country,
location="Rue Bauloy")
cls.user = UserFactory()
cls.url = reverse('continuing_education_api_v1:address-detail-update',
kwargs={'uuid': cls.address.uuid})
cls.invalid_url = reverse(
'continuing_education_api_v1:address-detail-update',
kwargs={'uuid': uuid.uuid4()})
def setUp(self):
GroupFactory(name='continuing_education_managers')
self.citizenship = CountryFactory()
self.user = UserFactory()
self.academic_year = AcademicYearFactory(year=2018)
education_group = EducationGroupFactory()
EducationGroupYearFactory(
education_group=education_group,
academic_year=self.academic_year
)
self.admission = AdmissionFactory(
citizenship=self.citizenship,
person_information=ContinuingEducationPersonFactory(person=PersonFactory(user=self.user)),
formation=ContinuingEducationTrainingFactory(education_group=education_group),
state=DRAFT
)
self.url = reverse('continuing_education_api_v1:admission-detail-update', kwargs={'uuid': self.admission.uuid})
self.invalid_url = reverse(
'continuing_education_api_v1:admission-detail-update',
kwargs={'uuid': uuid.uuid4()}
)
self.client.force_authenticate(user=self.user)
def setUpTestData(cls):
cls.country = CountryFactory()
cls.address = AddressFactory(country=cls.country)
url = reverse('continuing_education_api_v1:address-list-create')
cls.serializer = AddressPostSerializer(
cls.address, context={'request': RequestFactory().get(url)})
def create_new_entity(self):
country = CountryFactory()
# Root entity
self.root_entity = EntityFactory(country=country)
self.root_entity_version = EntityVersionFactory(
entity=self.root_entity,
acronym="ROOT_V",
parent=None,
end_date=None)
# Child 1 entity to root
self.child_one_entity = EntityFactory(country=country)
self.child_one_entity_version = EntityVersionFactory(
acronym="CHILD_1_V",
parent=self.root_entity,
end_date=None,
entity=self.child_one_entity)
# Child 2 entity to root
self.child_two_entity = EntityFactory(country=country)
self.child_two_entity_version = EntityVersionFactory(
acronym="CHILD_2_V",
parent=self.root_entity,
end_date=None,
entity=self.child_two_entity)
def setUpTestData(cls):
cls.country = CountryFactory()
cls.organization = OrganizationFactory(type=organization_type.MAIN)
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)
def setUpTestData(cls):
cls.education_group = EducationGroupFactory()
EducationGroupYearFactory(
education_group=cls.education_group,
academic_year=create_current_academic_year()
)
cls.formation = ContinuingEducationTrainingFactory(
education_group=cls.education_group
)
algeria = CountryFactory(name=COUNTRY_NAME)
cls.address = AddressFactory(city=CITY_NAME,
country=algeria,
location='Street',
postal_code='5500')
cls.registration = AdmissionFactory(
formation=cls.formation,
state=ACCEPTED,
ucl_registration_complete=True,
payment_complete=False,
citizenship=algeria,
person_information=ContinuingEducationPersonFactory(birth_location=CITY_NAME,
birth_country=algeria,
birth_date=datetime.datetime(1977, 4, 22)),
address=cls.address,
billing_address=cls.address,
residence_address=cls.address
)
def setUpTestData(cls):
cls.start_date = timezone.make_aware(datetime.datetime(2015, 1, 1))
cls.end_date = timezone.make_aware(datetime.datetime(2015, 12, 31))
cls.date_in_2015 = factory.fuzzy.FuzzyDate(
timezone.make_aware(datetime.datetime(2015, 1, 1)),
timezone.make_aware(datetime.datetime(2015, 12, 30))).fuzz()
cls.date_in_2017 = factory.fuzzy.FuzzyDate(
timezone.make_aware(datetime.datetime(2017, 1, 1)),
timezone.make_aware(datetime.datetime(2017, 12, 30))).fuzz()
cls.country = CountryFactory()
cls.parent = EntityFactory(country=cls.country)
EntityVersionFactory(entity=cls.parent,
parent=None,
acronym="ROOT_ENTITY",
start_date=cls.start_date,
end_date=cls.end_date)
cls.children = [EntityFactory(country=cls.country) for x in range(4)]
cls.types_dict = dict(entity_type.ENTITY_TYPES)
types = [
cls.types_dict['SECTOR'], cls.types_dict['FACULTY'],
cls.types_dict['SCHOOL'], cls.types_dict['FACULTY']
]
for x in range(4):
EntityVersionFactory(entity=cls.children[x],
parent=cls.parent,
acronym="ENTITY_V_" + str(x),
start_date=cls.start_date,
end_date=cls.end_date,
entity_type=types[x])
cls.an_entity = EntityFactory(external_id="1234567")
def setUp(self):
self.country = CountryFactory()
self.organization = OrganizationFactory(type=organization_type.MAIN)
self.entities = [
EntityFactory(country=self.country, organization=self.organization)
for x in range(3)
]
self.parent = EntityFactory(country=self.country,
organization=self.organization)
self.start_date = datetime.date(2015, 1, 1)
self.end_date = datetime.date(2015, 12, 31)
self.date_in_2015 = factory.fuzzy.FuzzyDate(
datetime.date(2015, 1, 1), datetime.date(2015, 12, 30)).fuzz()
self.date_in_2017 = factory.fuzzy.FuzzyDate(
datetime.date(2017, 1, 1), datetime.date(2017, 12, 30)).fuzz()
self.entity_versions = [
EntityVersionFactory(entity=self.entities[x],
acronym="ENTITY_V_" + str(x),
title="This is the entity version " + str(x),
entity_type="FACULTY",
parent=self.parent,
start_date=self.start_date,
end_date=self.end_date) for x in range(3)
]
self.parent_entity_version = EntityVersionFactory(
entity=self.parent,
acronym="ENTITY_PARENT",
title="This is the entity parent version",
entity_type="SECTOR",
start_date=self.start_date,
end_date=self.end_date)
def setUpTestData(cls):
cls.user = UserFactory()
cls.person = CentralManagerFactory(user=cls.user)
cls.academic_year = create_current_academic_year()
cls.education_group_yr = EducationGroupYearFactory(
acronym='ARKE2A',
academic_year=cls.academic_year,
education_group_type=EducationGroupTypeFactory(
category=education_group_categories.TRAINING),
management_entity=EntityFactory())
cls.root_id = cls.education_group_yr.id
cls.country_be = CountryFactory()
cls.organization_address = OrganizationAddressFactory(
country=cls.country_be)
cls.organization = cls.organization_address.organization
cls.education_group_organization = EducationGroupOrganizationFactory(
organization=cls.organization,
education_group_year=cls.education_group_yr,
diploma=diploma_coorganization.UNIQUE,
all_students=True,
)
cls.organization_bis = OrganizationFactory()
cls.address = OrganizationAddressFactory(
organization=cls.organization_bis, is_main=True)
def setUpTestData(cls):
cls.user = UserFactory()
CountryFactory(iso_code='NL')
cls.person = ContinuingEducationPersonFactory()
cls.address = AddressFactory()
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 = AdmissionFactory(
person_information=cls.person,
address=cls.address,
state=DRAFT,
formation=cls.formation
)
cls.url = reverse('continuing_education_api_v1:registration-list', kwargs={'uuid': cls.person.uuid})
for state in [VALIDATED, ACCEPTED, REGISTRATION_SUBMITTED]:
cls.education_group = EducationGroupFactory()
EducationGroupYearFactory(education_group=cls.education_group)
AdmissionFactory(
person_information=cls.person,
state=state,
formation=ContinuingEducationTrainingFactory(
education_group=cls.education_group
)
)
def setUp(self):
today = datetime.date.today()
self.current_academic_year = AcademicYearFactory(
start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
self.learning_container_yr = LearningContainerYearFactory(
academic_year=self.current_academic_year)
self.organization = OrganizationFactory(type=organization_type.MAIN)
self.country = CountryFactory()
self.entity = EntityFactory(country=self.country,
organization=self.organization)
self.entity_container_yr = EntityContainerYearFactory(
learning_container_year=self.learning_container_yr,
type=entity_container_year_link_type.REQUIREMENT_ENTITY,
entity=self.entity)
self.learning_component_yr = LearningComponentYearFactory(
learning_container_year=self.learning_container_yr,
hourly_volume_partial=-1,
planned_classes=1)
self.entity_component_yr = EntityComponentYearFactory(
learning_component_year=self.learning_component_yr,
entity_container_year=self.entity_container_yr,
hourly_volume_total=None)
self.entity_components_yr = [
self.entity_component_yr,
]
def test_load_countries_and_continent(self):
CountryFactory(iso_code='BE', name='Belgium')
args = []
opts = {}
call_command('load_countries_continent', *args, **opts)
self.assertTrue(Country.objects.filter(iso_code='BE').get().continent)
self.assertEqual(Country.objects.all().count(), 1) # assert doesn't create any Country
def create_entities_hierarchy(organization_type=MAIN):
country = CountryFactory()
start_date = date.today().replace(year=1900)
organization = OrganizationFactory(type=organization_type)
root_entity = EntityFactory(country=country, organization=organization)
root_entity_version = EntityVersionFactory(entity=root_entity,
acronym="ROOT_V",
entity_type=SECTOR,
parent=None,
end_date=None,
start_date=start_date)
child_one_entity = EntityFactory(country=country,
organization=organization)
child_one_entity_version = EntityVersionFactory(acronym="CHILD_1_V",
parent=root_entity,
entity_type=FACULTY,
end_date=None,
entity=child_one_entity,
start_date=start_date)
child_two_entity = EntityFactory(country=country,
organization=organization)
child_two_entity_version = EntityVersionFactory(acronym="CHILD_2_V",
parent=root_entity,
entity_type=FACULTY,
end_date=None,
entity=child_two_entity,
start_date=start_date)
return locals()
def setUp(self):
self.start_date = timezone.make_aware(datetime.datetime(2015, 1, 1))
self.end_date = timezone.make_aware(datetime.datetime(2015, 12, 31))
self.date_in_2015 = factory.fuzzy.FuzzyDate(
timezone.make_aware(datetime.datetime(2015, 1, 1)),
timezone.make_aware(datetime.datetime(2015, 12, 30))).fuzz()
self.date_in_2017 = factory.fuzzy.FuzzyDate(
timezone.make_aware(datetime.datetime(2017, 1, 1)),
timezone.make_aware(datetime.datetime(2017, 12, 30))).fuzz()
self.country = CountryFactory()
self.parent = EntityFactory(country=self.country)
EntityVersionFactory(entity=self.parent,
parent=None,
acronym="ROOT_ENTITY",
start_date=self.start_date,
end_date=self.end_date)
self.children = [EntityFactory(country=self.country) for x in range(4)]
self.types_dict = dict(entity_type.ENTITY_TYPES)
types = [
self.types_dict['SECTOR'], self.types_dict['FACULTY'],
self.types_dict['SCHOOL'], self.types_dict['FACULTY']
]
for x in range(4):
EntityVersionFactory(entity=self.children[x],
parent=self.parent,
acronym="ENTITY_V_" + str(x),
start_date=self.start_date,
end_date=self.end_date,
entity_type=types[x])
def setUp(self):
self.country = CountryFactory()
self.organization = OrganizationFactory(type=organization_type.MAIN)
self.now = datetime.datetime.now(get_tzinfo())
start_date = self.now - datetime.timedelta(days=10)
end_date = None
self._build_current_entity_version_structure(end_date, start_date)
def setUp(self):
self.user = PersonFactory().user
today = datetime.date.today()
self.current_academic_year = AcademicYearFactory(start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
self.academic_calendar = AcademicCalendarFactory(academic_year=self.current_academic_year,
reference=academic_calendar_type.SUMMARY_COURSE_SUBMISSION)
self.entity = EntityFactory(country=CountryFactory())
self.parent = EntityFactory()
self.start_date = datetime.date(2015, 1, 1)
self.end_date = datetime.date(2015, 12, 31)
self.entity_version = EntityVersionFactory(
entity=self.entity,
acronym="ENTITY_CHILDREN",
title="This is the entity version ",
entity_type="FACULTY",
parent=self.parent,
start_date=self.start_date,
end_date=self.end_date
)
self.parent_entity_version = EntityVersionFactory(
entity=self.parent,
acronym="ENTITY_PARENT",
title="This is the entity parent version",
entity_type="SECTOR",
start_date=self.start_date,
end_date=self.end_date
)
def setUpTestData(cls):
# User creation
cls.user = UserFactory()
cls.user_adri = UserFactory()
entity_version = EntityVersionFactory(acronym='ADRI')
PartnershipEntityManagerFactory(entity=entity_version.entity,
person__user=cls.user_adri)
cls.user_gf = UserFactory()
entity_manager = PartnershipEntityManagerFactory(
person__user=cls.user_gf)
cls.user_other_gf = UserFactory()
PartnershipEntityManagerFactory(person__user=cls.user_other_gf,
entity=entity_manager.entity)
# Partner creation
cls.partner = PartnerFactory()
cls.partner_gf = PartnerFactory(author=cls.user_gf.person)
# Misc
cls.contact_type = ContactType.objects.create(value='foobar')
cls.country = CountryFactory()
cls.media = MediaFactory()
cls.partner.medias.add(cls.media)
cls.url = reverse('partnerships:partners:medias:update',
kwargs={
'partner_pk': cls.partner.pk,
'pk': cls.media.pk
})
def setUpTestData(cls):
cls.user = UserFactory()
cls.url = reverse('continuing_education_api_v1:address-list-create')
cls.country = CountryFactory()
cls.address = AddressFactory(country=cls.country)
for x in range(2):
AddressFactory(country=cls.country)
def setUpTestData(cls):
cls.academic_year = create_current_academic_year()
cls.education_group = EducationGroupFactory()
EducationGroupYearFactory(education_group=cls.education_group,
academic_year=cls.academic_year)
cls.formation = ContinuingEducationTrainingFactory(
education_group=cls.education_group,
additional_information_label='additional_information',
registration_required=True)
cls.education_group_no_registration_required = EducationGroupFactory()
EducationGroupYearFactory(
education_group=cls.education_group_no_registration_required,
academic_year=cls.academic_year)
cls.formation_no_registration_required = ContinuingEducationTrainingFactory(
education_group=cls.education_group_no_registration_required,
registration_required=False)
group = GroupFactory(name=MANAGERS_GROUP)
cls.manager = PersonWithPermissionsFactory('view_admission',
'change_admission')
cls.manager.user.groups.add(group)
group = GroupFactory(name=TRAINING_MANAGERS_GROUP)
cls.training_manager = PersonWithPermissionsFactory(
'view_admission', 'change_admission')
cls.training_manager.user.groups.add(group)
EntityVersionFactory(entity=cls.formation.management_entity)
cls.admission = AdmissionFactory(
formation=cls.formation,
state=SUBMITTED,
person_information__person__gender='M',
academic_year=cls.academic_year,
)
a_person_information = ContinuingEducationPersonFactory(
person__gender='M')
cls.admission_no_admission_required = AdmissionFactory(
formation=cls.formation_no_registration_required,
state=ACCEPTED_NO_REGISTRATION_REQUIRED,
person_information=a_person_information,
academic_year=cls.academic_year,
)
cls.file = SimpleUploadedFile(name='upload_test.pdf',
content=str.encode(FILE_CONTENT),
content_type="application/pdf")
cls.country = CountryFactory()
cls.person_data = {
'last_name': cls.admission.person_information.person.last_name,
'first_name': cls.admission.person_information.person.first_name,
'gender': cls.admission.person_information.person.gender,
'email': cls.admission.person_information.person.email,
}
cls.continuing_education_person_data = {
'birth_date':
cls.admission.person_information.birth_date.strftime('%Y-%m-%d'),
'birth_location':
cls.admission.person_information.birth_location,
'birth_country':
cls.admission.person_information.birth_country.id,
}
def test_valid_form(self):
data = {
"location": "test",
"city": "test",
"postal_code": "1000",
"country": CountryFactory().pk,
}
person_address_form = InternshipPersonAddressForm(data)
self.assertTrue(person_address_form.is_valid())
def setUpTestData(cls):
cls.birth_country = CountryFactory()
cls.continuing_education_person = ContinuingEducationPersonFactory(
birth_country=cls.birth_country)
url = reverse('continuing_education_api_v1:person-list-create')
cls.serializer = ContinuingEducationPersonPostSerializer(
cls.continuing_education_person,
context={'request': RequestFactory().get(url)})
def test_when_filter_with_country_data_forwarded_no_result_found(self):
country = CountryFactory(iso_code='FR')
self.client.force_login(user=self.super_user)
response = self.client.get(
self.url, data={'forward': '{"country": "%s"}' % country.pk})
self.assertEqual(response.status_code, 200)
results = _get_results_from_autocomplete_response(response)
self.assertListEqual(results, [])
def setUp(self):
self.country = CountryFactory()
self.organization = OrganizationFactory(
name="Université catholique de Louvain",
acronym="UCL",
type=organization_type.MAIN)
self.now = datetime.datetime.now(get_tzinfo())
start_date = self.now - datetime.timedelta(days=10)
end_date = None
self._build_current_entity_version_structure(end_date, start_date)
