def test_copy_organization_from_cohort(self):
organization = OrganizationFactory(cohort=self.cohort)
speciality = SpecialtyFactory(cohort=self.cohort)
copy_cohort_name = 'Copy of {} {}'.format(self.cohort.name, timezone.now())
form_data = {
'name': copy_cohort_name,
'publication_start_date': self.cohort.publication_start_date.strftime('%Y-%m-%d'),
'subscription_start_date': self.cohort.subscription_start_date.strftime('%Y-%m-%d'),
'subscription_end_date': self.cohort.subscription_end_date.strftime('%Y-%m-%d'),
'description': self.cohort.description,
'originated_from': self.cohort.id,
}
form = CohortForm(data=form_data)
self.assertTrue(form.is_valid())
response = self.client.post(reverse('cohort_new'), data=form_data)
self.assertRedirects(response, reverse('internship'))
copy_cohort = Cohort.objects.filter(name=copy_cohort_name).first()
self.assertEqual(copy_cohort.name, copy_cohort_name)
copy_organization = Organization.objects.filter(cohort=copy_cohort).first()
copy_speciality = InternshipSpeciality.objects.filter(cohort=copy_cohort).first()
self.assertIsNotNone(copy_organization)
self.assertIsNotNone(copy_speciality)
self.assertEqual(organization.name, copy_organization.name)
self.assertEqual(speciality.name, copy_speciality.name)
def setUpTestData(cls):
cls.user = User.objects.create_user('demo', '*****@*****.**',
'passtest')
permission = Permission.objects.get(codename='is_internship_manager')
cls.user.user_permissions.add(permission)
cls.cohort = CohortFactory()
cls.organization = OrganizationFactory(cohort=cls.cohort)
cls.specialty = SpecialtyFactory(mandatory=True, cohort=cls.cohort)
cls.offer = OfferFactory(cohort=cls.cohort,
organization=cls.organization,
speciality=cls.specialty)
students = [StudentFactory() for _ in range(0, 4)]
mandatory_internship = InternshipFactory(cohort=cls.cohort,
speciality=cls.specialty)
non_mandatory_internship = InternshipFactory(cohort=cls.cohort)
for internship in [mandatory_internship, non_mandatory_internship]:
for choice in CHOICES:
create_internship_choice(organization=cls.organization,
student=students[0],
speciality=cls.specialty,
choice=choice,
internship=internship)
for student in students[1:]:
create_internship_choice(organization=cls.organization,
student=student,
speciality=cls.specialty,
choice=random.choice([2, 3, 4]),
internship=mandatory_internship)
cls.url = reverse('internships', kwargs={
'cohort_id': cls.cohort.id,
})
def setUpTestData(cls):
cls.cohort = CohortFactory()
cls.organizations = [
OrganizationFactory(cohort=cls.cohort)
for _ in range(0, N_ORGANIZATIONS)
]
cls.last_switch = []
def test_get_by_id(self):
an_organization = OrganizationFactory()
persisted_organization = organization.get_by_id(an_organization.id)
self.assertEquals(an_organization.id, persisted_organization.id)
nonexistent_organization = organization.get_by_id(0)
self.assertIsNone(nonexistent_organization)
def setUpTestData(cls):
cls.user = User.objects.create_user('demo', '*****@*****.**',
'passtest')
permission = Permission.objects.get(codename='is_internship_manager')
cls.user.user_permissions.add(permission)
cls.cohort = CohortFactory()
cls.organization = OrganizationFactory(cohort=cls.cohort)
def test_masters_index_2(self, mock_render, mock_decorators):
from django.db import connection
from django.db import reset_queries
mock_decorators.login_required = lambda x: x
mock_decorators.permission_required = lambda *args, **kwargs: lambda func: func
fake = faker.Faker()
organization = OrganizationFactory(cohort=self.cohort, reference=fake.random_int(min=10, max=100))
request_factory = RequestFactory()
request = request_factory.get(reverse('internships_masters', kwargs={
'cohort_id': self.cohort.id
}))
request.user = mock.Mock()
from internship.views.master import masters
reset_queries()
self.assertEqual(len(connection.queries), 0)
masters(request, self.cohort.id)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(context['cohort_id'], self.cohort.id)
def test_masters_index_bad_masters(self):
fake = faker.Faker()
master = MasterFactory(organization=OrganizationFactory(reference=fake.random_int(min=10, max=100)))
url = reverse('internships_masters', kwargs={
'cohort_id': self.cohort.id
})
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'internships_masters.html')
masters = response.context['all_masters']
self.assertEqual(masters.count(), 0)
url = reverse('internships_masters', kwargs={
'cohort_id': master.organization.cohort.id,
})
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'internships_masters.html')
masters = response.context['all_masters']
self.assertEqual(masters.count(), 1)
self.assertEqual(masters.first(), master)
def test_valid_allocation_both(self):
request = self.client.post("/masters/save/",
data={
"specialty": [SpecialtyFactory()],
"hospital": [OrganizationFactory()],
"role": [Role.MASTER],
}).wsgi_request
self.assertTrue(_validate_allocations(request))
def test_invalid_allocation_no_role(self):
request = self.client.post("/masters/save/",
data={
"specialty": [SpecialtyFactory()],
"hospital": [OrganizationFactory()],
"role": [''],
}).wsgi_request
self.assertFalse(_validate_allocations(request))
def setUpTestData(cls):
cls.cohort = CohortFactory()
cls.mandatory_internships, cls.mandatory_specialties = _create_mandatory_internships(
cls)
cls.non_mandatory_internships, cls.non_mandatory_specialties = _create_non_mandatory_internships(
cls)
cls.students = _create_internship_students(cls)
cls.hospital_error = OrganizationFactory(name='Hospital Error',
cohort=cls.cohort,
reference=999)
cls.organizations = [
OrganizationFactory(cohort=cls.cohort)
for _ in range(0, N_ORGANIZATIONS)
]
cls.periods = [
PeriodFactory(cohort=cls.cohort) for _ in range(0, N_PERIODS)
]
cls.specialties = cls.mandatory_specialties + cls.non_mandatory_specialties
cls.internships = cls.mandatory_internships + cls.non_mandatory_internships
cls.offers = _create_internship_offers(cls)
cls.places = _declare_offer_places(cls)
_make_student_choices(cls)
cls.prior_student = _block_prior_student_choices(cls)
cls.internship_with_offer_shortage, cls.unlucky_student = _make_shortage_scenario(
cls)
_execute_assignment_algorithm(cls)
cls.affectations = InternshipStudentAffectationStat.objects.all()
cls.prior_student_affectations = cls.affectations.filter(
student=cls.prior_student)
cls.prior_enrollments = InternshipEnrollment.objects.filter(
student=cls.prior_student)
cls.user = User.objects.create_user('demo', '*****@*****.**',
'passtest')
permission = Permission.objects.get(codename='is_internship_manager')
cls.user.user_permissions.add(permission)
def create_organization(name="OSIS",
acronym="OSIS",
reference="01",
cohort=None):
if cohort is None:
cohort = CohortFactory()
return OrganizationFactory(name=name,
acronym=acronym,
reference=reference,
cohort=cohort)
def test_student_choice(self):
organization = OrganizationFactory(cohort=self.cohort)
kwargs = {
'cohort_id': self.cohort.id,
'organization_id': organization.id
}
url = reverse('place_detail_student_choice', kwargs=kwargs)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'place_detail.html')
def test_export_xls_organisation_affectation(self):
organization = OrganizationFactory(cohort=self.cohort)
url = reverse('organisation_affectation_download',
kwargs={
'cohort_id': self.cohort.id,
'organization_id': organization.id,
})
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 200)
def test_home_with_offer(self):
organization = OrganizationFactory(cohort=self.cohort)
speciality = SpecialityFactory(cohort=self.cohort)
offer = OfferFactory(organization=organization, speciality=speciality)
url = reverse('internships', kwargs={
'cohort_id': self.cohort.id,
})
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'internships.html')
def test_edit(self):
organization = OrganizationFactory(cohort=self.cohort)
organization_address = OrganizationAddressFactory(
organization=organization)
kwargs = {
'cohort_id': self.cohort.id,
'organization_id': organization.id
}
url = reverse('place_edit', kwargs=kwargs)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'place_form.html')
def setUpTestData(cls):
cls.cohort = CohortFactory()
cls.past_period_no_scores_submitted = PeriodFactory(cohort=cls.cohort, date_end=date.today()-timedelta(days=1))
cls.past_period_excused = PeriodFactory(cohort=cls.cohort, date_end=date.today()-timedelta(days=1))
cls.past_period_edited = PeriodFactory(cohort=cls.cohort, date_end=date.today()-timedelta(days=1))
cls.user = PersonWithPermissionsFactory('is_internship_manager').user
cls.student = StudentFactory()
cls.student.organizations = {
cls.past_period_no_scores_submitted.name: OrganizationFactory().reference,
cls.past_period_excused.name: OrganizationFactory().reference,
cls.past_period_edited.name: OrganizationFactory().reference,
}
cls.student.periods_scores = {
cls.past_period_no_scores_submitted.name: NO_SUBMISSION_SCORE,
cls.past_period_excused.name: {'edited': EXCUSED_PERIOD_SCORE, 'computed': NO_SUBMISSION_SCORE},
cls.past_period_edited.name: {'edited': EDITED_PERIOD_SCORE, 'computed': COMPUTED_PERIOD_SCORE},
}
cls.periods = [
cls.past_period_no_scores_submitted,
cls.past_period_excused,
cls.past_period_edited,
]
def test_search_master_by_name_unaccent(self):
organization = OrganizationFactory(cohort=self.cohort)
master_with_accent = MasterFactory(person__last_name='Éçàüî')
MasterAllocationFactory(organization=organization,
master=master_with_accent)
url = reverse('internships_masters',
kwargs={
'cohort_id': self.cohort.id,
})
query_string = '?name={}'.format("Éçàüî")
response = self.client.get("{}{}".format(url, query_string))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['allocations'].object_list[0].master,
master_with_accent)
def test_save_duplicated(self):
organization = OrganizationFactory()
specialty = SpecialtyFactory()
MasterAllocationFactory(organization=organization,
specialty=specialty,
master=self.master)
MasterAllocationFactory(organization=organization,
specialty=specialty,
master=self.master)
allocations = master_allocation.find_by_master(specialty.cohort,
self.master)
self.assertEquals(1, allocations.count())
def test_masters_index_2(self, mock_render, mock_decorators):
from django.db import connection
from django.db import reset_queries
mock_decorators.login_required = lambda x: x
mock_decorators.permission_required = lambda *args, **kwargs: lambda func: func
fake = faker.Faker()
organization = OrganizationFactory(cohort=self.cohort, reference=fake.random_int(min=10, max=100))
# speciality = SpecialityFactory(cohort=self.cohort)
master = MasterFactory(organization=organization)
master2 = MasterFactory()
request_factory = RequestFactory()
request = request_factory.get(reverse('internships_masters', kwargs={
'cohort_id': self.cohort.id
}))
request.user = mock.Mock()
from internship.views.master import internships_masters
reset_queries()
self.assertEqual(len(connection.queries), 0)
internships_masters(request, self.cohort.id)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(context['cohort'], self.cohort)
masters_count = context['all_masters'].count()
# print("Queries", len(connection.queries))
# from pprint import pprint as pp
# pp(connection.queries)
from internship.models.internship_master import InternshipMaster
self.assertEqual(masters_count,
InternshipMaster.objects.filter(organization=organization).count())
specs = InternshipMaster.objects.filter(organization=organization)\
.distinct('speciality')\
.values_list('speciality', flat=True)\
.order_by('speciality')
self.assertEqual(len(context['all_spec']), specs.count())
self.assertEqual(set(context['all_spec']), set(list(specs)))
def test_internship_detail_student_choice(self):
offer = OfferFactory(organization=OrganizationFactory(
cohort=self.cohort))
url = reverse('internship_detail_student_choice',
kwargs={
'cohort_id': self.cohort.id,
'offer_id': offer.id,
})
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'internship_detail.html')
self.assertEqual(response.context['internship'], offer)
def test_masters_index_with_master(self):
fake = faker.Faker()
organization = OrganizationFactory(cohort=self.cohort, reference=fake.random_int(min=10, max=100))
master = MasterAllocationFactory(organization=organization)
url = "{}?hospital={}".format(reverse('internships_masters', kwargs={'cohort_id': self.cohort.id}),
organization.id)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'masters.html')
masters = response.context['allocations']
self.assertEqual(masters.count(), 1)
self.assertEqual(masters.first(), master)
def test_save_master_form_with_existing_instance(self):
person = PersonFactory(source=person_source_type.BASE)
hospital = OrganizationFactory(cohort=self.cohort)
specialty = SpecialtyFactory(cohort=self.cohort)
url = reverse('master_save', kwargs={'cohort_id': self.cohort.pk})
response = self.client.post(url,
data={
'existing-person-id': person.pk,
'hospital': hospital.pk,
'specialty': specialty.pk,
'role': Role.MASTER.name,
})
self.assertRedirects(
response, '{}?{}'.format(
reverse('internships_masters',
kwargs={'cohort_id': self.cohort.id}),
'{}{}'.format('hospital=', hospital.pk)))
self.assertEqual(InternshipMaster.objects.first().person, person)
def test_affectation_result_sumup(self):
specialty = SpecialtyFactory(cohort=self.cohort)
organization = OrganizationFactory(cohort=self.cohort)
affectation = StudentAffectationStatFactory(organization=organization, speciality=specialty)
url = reverse('internship_affectation_sumup', kwargs={
'cohort_id': self.cohort.id
})
response = self.client.get("{}?hospital={}&specialty={}".format(url, organization.id, specialty.id))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'internship_affectation_sumup.html')
self.assertEqual(response.context[0]['active_hospital'], affectation.organization)
self.assertEqual(response.context[0]['active_specialty'], affectation.speciality)
self.assertIn(affectation.organization, response.context[0]['hospitals'])
self.assertIn(affectation.speciality.name, response.context[0]['hospital_specialties'])
def test_delete_master_only_delete_allocations(self):
master_test = MasterFactory(
person__source=person_source_type.INTERNSHIP)
# master and person exists before delete
self.assertTrue(
InternshipMaster.objects.filter(pk=master_test.pk).exists())
self.assertTrue(
Person.objects.filter(pk=master_test.person.pk).exists())
fake = faker.Faker()
organization_test = OrganizationFactory(cohort=self.cohort,
reference=fake.random_int(
min=10, max=100))
allocation = MasterAllocationFactory(master=master_test,
organization=organization_test)
url = reverse('master_delete',
kwargs={
'cohort_id': self.cohort.id,
'master_id': master_test.id
})
allocations = master_allocation.find_by_master(self.cohort,
master_test)
self.assertIn(allocation, allocations)
response = self.client.get(url)
self.assertRedirects(
response,
reverse('internships_masters',
kwargs={'cohort_id': self.cohort.id}))
allocations = master_allocation.find_by_master(self.cohort,
master_test)
self.assertNotIn(allocation, allocations)
# master and person have NOT been deleted
self.assertTrue(
InternshipMaster.objects.filter(pk=master_test.pk).exists())
self.assertTrue(
Person.objects.filter(pk=master_test.person.pk).exists())
def setUpTestData(cls):
cls.organization = OrganizationFactory()
cls.student = StudentFactory()
cls.specialty = SpecialtyFactory()
cls.period = PeriodFactory()
def setUp(self):
self.organization = OrganizationFactory()
self.student = StudentFactory()
self.specialty = SpecialtyFactory()
self.period = PeriodFactory()
def test_home_with_organization_filter(self):
organization = OrganizationFactory(cohort=self.cohort)
get_params = '?organization_sort={}'.format(organization.name)
response = self.client.get(self.url + get_params)
self.assertEqual(response.status_code, HttpResponse.status_code)
self.assertTemplateUsed(response, 'internships.html')
def test_find_by_cohort(self):
cohort = CohortFactory()
OrganizationFactory(cohort=cohort)
an_organization = organization.find_by_cohort(cohort)
self.assertEquals(cohort, an_organization[0].cohort)