class TestAssistantMandateFactory(TestCase):
def setUp(self):
self.mandate = AssistantMandateFactory(
academic_year=factory.SubFactory(AcademicYearFactory, year=datetime.date.today().year - 1))
self.mandate2 = AssistantMandateFactory(
academic_year=factory.SubFactory(AcademicYearFactory, year=datetime.date.today().year))
self.researched_academic_year = self.mandate.academic_year
self.mandate3 = AssistantMandateFactory(
academic_year=factory.SubFactory(AcademicYearFactory, year=datetime.date.today().year),
state=assistant_mandate_state.DECLINED
)
def test_find_mandate_by_id(self):
self.assertEqual(self.mandate, assistant_mandate.find_mandate_by_id(self.mandate.id))
self.mandate.delete()
self.assertEqual(None, assistant_mandate.find_mandate_by_id(self.mandate.id))
def test_find_by_academic_year(self):
for current_mandate in assistant_mandate.find_by_academic_year(self.researched_academic_year):
self.assertEqual(self.researched_academic_year, current_mandate.academic_year)
def test_find_by_academic_year_by_excluding_declined(self):
self.assertEqual(
list(find_by_academic_year_by_excluding_declined(self.researched_academic_year)),
[self.mandate]
)
def test_find_declined_by_academic_year(self):
self.assertEqual(
list(find_declined_by_academic_year(self.mandate3.academic_year)),
[self.mandate3]
)
def setUpTestData(cls):
cls.settings = SettingsFactory()
cls.previous_academic_year, cls.current_academic_year, _ = AcademicYearFactory.produce(
)
cls.phd_supervisor = PersonFactory()
cls.assistant = AcademicAssistantFactory(supervisor=cls.phd_supervisor)
cls.assistant_mandate = AssistantMandateFactory(
academic_year=cls.current_academic_year,
assistant=cls.assistant,
state=assistant_mandate_state.PHD_SUPERVISOR)
cls.assistant2 = AcademicAssistantFactory(supervisor=None)
cls.assistant_mandate2 = AssistantMandateFactory(
academic_year=cls.current_academic_year,
assistant=cls.assistant2,
state=assistant_mandate_state.RESEARCH,
)
cls.review = ReviewFactory(reviewer=None,
mandate=cls.assistant_mandate,
status=review_status.IN_PROGRESS)
cls.entity_version = EntityVersionFactory(
entity_type=entity_type.INSTITUTE, end_date=None)
cls.mandate_entity = MandateEntityFactory(
assistant_mandate=cls.assistant_mandate,
entity=cls.entity_version.entity)
cls.mandate_entity2 = MandateEntityFactory(
assistant_mandate=cls.assistant_mandate2,
entity=cls.entity_version.entity)
cls.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=cls.entity_version.entity,
person=cls.phd_supervisor)
class TestAssistantMandateFactory(TestCase):
def setUp(self):
self.mandate = AssistantMandateFactory(
academic_year=factory.SubFactory(
AcademicYearFactory, year=datetime.date.today().year - 1))
self.mandate2 = AssistantMandateFactory(
academic_year=factory.SubFactory(AcademicYearFactory,
year=datetime.date.today().year))
self.researched_academic_year = self.mandate.academic_year
self.mandate3 = AssistantMandateFactory(
academic_year=factory.SubFactory(AcademicYearFactory,
year=datetime.date.today().year),
state=assistant_mandate_state.DECLINED)
def test_find_mandate_by_id(self):
self.assertEqual(self.mandate,
assistant_mandate.find_mandate_by_id(self.mandate.id))
self.mandate.delete()
self.assertEqual(None,
assistant_mandate.find_mandate_by_id(self.mandate.id))
def test_find_by_academic_year(self):
for current_mandate in assistant_mandate.find_by_academic_year(
self.researched_academic_year):
self.assertEqual(self.researched_academic_year,
current_mandate.academic_year)
def test_find_by_academic_year_by_excluding_declined(self):
self.assertEqual(
list(
find_by_academic_year_by_excluding_declined(
self.researched_academic_year)), [self.mandate])
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
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.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(
supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(
academic_year=self.current_academic_year, assistant=self.assistant)
self.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
self.assistant_mandate.save()
self.review = ReviewFactory(reviewer=None,
mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
self.entity_version = EntityVersionFactory(
entity_type=entity_type.INSTITUTE)
self.mandate_entity = MandateEntityFactory(
assistant_mandate=self.assistant_mandate,
entity=self.entity_version.entity)
class PhdSupervisorReviewViewTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
today = datetime.date.today()
self.current_academic_year = AcademicYearFactory(
start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
self.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(
supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(
academic_year=self.current_academic_year, assistant=self.assistant)
self.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
self.assistant_mandate.save()
self.review = ReviewFactory(reviewer=None,
mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
def test_generate_phd_supervisor_menu_tabs(self):
self.client.force_login(self.phd_supervisor)
# Review has not been completed -> supervisor can edit
self.assertEqual(
generate_phd_supervisor_menu_tabs(self.assistant_mandate, None),
[{
'item': assistant_mandate_state.PHD_SUPERVISOR,
'class': '',
'action': 'edit'
}])
self.assertEqual(
generate_phd_supervisor_menu_tabs(
self.assistant_mandate,
assistant_mandate_state.PHD_SUPERVISOR),
[{
'item': assistant_mandate_state.PHD_SUPERVISOR,
'class': 'active',
'action': 'edit'
}])
# Review has been completed -> supervisor can only view his review
self.review.status = review_status.DONE
self.review.save()
self.assistant_mandate.state = assistant_mandate_state.RESEARCH
self.assistant_mandate.save()
self.assertEqual(
generate_phd_supervisor_menu_tabs(self.assistant_mandate, None),
[{
'item': assistant_mandate_state.PHD_SUPERVISOR,
'class': '',
'action': 'view'
}])
self.assertEqual(
generate_phd_supervisor_menu_tabs(
self.assistant_mandate,
assistant_mandate_state.PHD_SUPERVISOR),
[{
'item': assistant_mandate_state.PHD_SUPERVISOR,
'class': 'active',
'action': 'view'
}])
def setUp(self):
self.mandate = AssistantMandateFactory(
academic_year=factory.SubFactory(
AcademicYearFactory, year=datetime.date.today().year - 1))
self.mandate2 = AssistantMandateFactory(
academic_year=factory.SubFactory(AcademicYearFactory,
year=datetime.date.today().year))
self.researched_academic_year = self.mandate.academic_year
class AssistantsListViewTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
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.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(
supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(
academic_year=self.current_academic_year, assistant=self.assistant)
self.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
self.assistant_mandate.save()
self.review = ReviewFactory(reviewer=None,
mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
self.entity_version = EntityVersionFactory(
entity_type=entity_type.INSTITUTE)
self.mandate_entity = MandateEntityFactory(
assistant_mandate=self.assistant_mandate,
entity=self.entity_version.entity)
def test_with_unlogged_user(self):
response = self.client.get('/assistants/phd_supervisor/assistants/')
self.assertEqual(response.status_code, HTTP_FOUND)
def test_context_data_phd_supervisor_is_not_reviewer(self):
self.client.force_login(self.phd_supervisor.user)
response = self.client.get('/assistants/phd_supervisor/assistants/')
self.assertEqual(response.status_code, HTTP_OK)
self.assertEqual(response.context['current_reviewer'],
find_by_person(self.phd_supervisor))
self.assertFalse(response.context['can_delegate'])
entities_id = self.assistant_mandate.mandateentity_set.all().order_by(
'id').values_list('entity', flat=True)
self.assistant_mandate.entities = find_versions_from_entites(
entities_id, None)
self.assistant_mandate.save()
self.assertQuerysetEqual(response.context['object_list'],
find_for_supervisor_for_academic_year(
self.phd_supervisor,
self.current_academic_year),
transform=lambda x: x)
def test_context_data_phd_supervisor_is_reviewer(self):
self.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=self.entity_version.entity,
person=self.phd_supervisor)
self.client.force_login(self.phd_supervisor.user)
response = self.client.get('/assistants/phd_supervisor/assistants/')
self.assertEqual(response.context['current_reviewer'],
find_by_person(self.phd_supervisor))
self.assertTrue(response.context['can_delegate'])
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
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.current_academic_year.save()
self.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(
supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(
academic_year=self.current_academic_year,
assistant=self.assistant,
state=assistant_mandate_state.RESEARCH)
self.assistant_mandate2 = AssistantMandateFactory(
academic_year=self.current_academic_year,
assistant=self.assistant,
state=assistant_mandate_state.RESEARCH)
self.phd_supervisor_review = ReviewFactory(
reviewer=None,
mandate=self.assistant_mandate,
status=review_status.DONE)
self.entity_version = EntityVersionFactory(
entity_type=entity_type.INSTITUTE)
self.entity_mandate = MandateEntityFactory(
assistant_mandate=self.assistant_mandate,
entity=self.entity_version.entity)
self.entity_mandate2 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate2,
entity=self.entity_version.entity)
self.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=self.entity_version.entity)
self.review = ReviewFactory(reviewer=self.reviewer,
mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
self.entity_version2 = EntityVersionFactory(
entity_type=entity_type.FACULTY)
self.entity_mandate2 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate,
entity=self.entity_version2.entity)
self.reviewer2 = ReviewerFactory(role=reviewer_role.SUPERVISION,
entity=self.entity_version2.entity)
self.entity_version3 = EntityVersionFactory(
entity_type=entity_type.SECTOR)
self.entity_mandate3 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate,
entity=self.entity_version3.entity)
self.reviewer3 = ReviewerFactory(role=reviewer_role.VICE_RECTOR,
entity=self.entity_version3.entity)
def setUpTestData(cls):
cls.past_acy, cls.current_acy, cls.next_acy = AcademicYearFactory.produce(
)
cls.mandates = AssistantMandateFactory.create_batch(
5, academic_year=cls.current_acy)
cls.past_mandates = AssistantMandateFactory.create_batch(
3, academic_year=cls.past_acy)
cls.manager = ManagerFactory()
cls.url = reverse("mandates_list")
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 setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.manager = ManagerFactory()
self.settings = SettingsFactory()
self.client.force_login(self.manager.person.user)
self.assistant = AcademicAssistantFactory()
self.assistant_mandate = AssistantMandateFactory(
state=assistant_mandate_state.TRTS,
assistant=self.assistant,
assistant_type=assistant_type.ASSISTANT)
self.assistant2 = AcademicAssistantFactory()
self.assistant_mandate2 = AssistantMandateFactory(
state=assistant_mandate_state.SUPERVISION,
assistant=self.assistant2,
assistant_type=assistant_type.TEACHING_ASSISTANT)
self.entity1 = EntityFactory()
self.entity_version1 = EntityVersionFactory(
entity=self.entity1, entity_type=entity_type.SECTOR)
self.entity2 = EntityFactory()
self.entity_version2 = EntityVersionFactory(
entity=self.entity2, entity_type=entity_type.FACULTY)
self.entity3 = EntityFactory()
self.entity_version3 = EntityVersionFactory(
entity=self.entity3, entity_type=entity_type.INSTITUTE)
self.entity4 = EntityFactory()
self.entity_version4 = EntityVersionFactory(
entity=self.entity4,
parent=self.entity2,
entity_type=entity_type.SCHOOL)
self.mandate_entity1 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate, entity=self.entity1)
self.mandate_entity2 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate, entity=self.entity2)
self.mandate_entity3 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate, entity=self.entity3)
self.mandate_entity4 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate2, entity=self.entity1)
self.mandate_entity5 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate2, entity=self.entity2)
self.reviewer1 = ReviewerFactory(entity=self.entity3,
role=reviewer_role.RESEARCH)
self.reviewer2 = ReviewerFactory(entity=self.entity2,
role=reviewer_role.SUPERVISION)
self.reviewer3 = ReviewerFactory(entity=self.entity1,
role=reviewer_role.VICE_RECTOR)
self.reviewer4 = ReviewerFactory(entity=None,
role=reviewer_role.PHD_SUPERVISOR)
class AssistantsListViewTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
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.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(academic_year=self.current_academic_year,
assistant=self.assistant)
self.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
self.assistant_mandate.save()
self.review = ReviewFactory(reviewer=None, mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
self.entity_version = EntityVersionFactory(entity_type=entity_type.INSTITUTE)
self.mandate_entity = MandateEntityFactory(assistant_mandate=self.assistant_mandate,
entity=self.entity_version.entity)
def test_with_unlogged_user(self):
response = self.client.get('/assistants/phd_supervisor/assistants/')
self.assertEqual(response.status_code, HTTP_FOUND)
def test_context_data_phd_supervisor_is_not_reviewer(self):
self.client.force_login(self.phd_supervisor.user)
response = self.client.get('/assistants/phd_supervisor/assistants/')
self.assertEqual(response.status_code, HTTP_OK)
self.assertEqual(response.context['current_reviewer'], find_by_person(self.phd_supervisor))
self.assertFalse(response.context['can_delegate'])
entities_id = self.assistant_mandate.mandateentity_set.all().order_by('id').values_list('entity', flat=True)
self.assistant_mandate.entities = find_versions_from_entites(entities_id, None)
self.assistant_mandate.save()
self.assertQuerysetEqual(response.context['object_list'],
find_for_supervisor_for_academic_year(self.phd_supervisor, self.current_academic_year),
transform = lambda x: x
)
def test_context_data_phd_supervisor_is_reviewer(self):
self.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=self.entity_version.entity,
person=self.phd_supervisor)
self.client.force_login(self.phd_supervisor.user)
response = self.client.get('/assistants/phd_supervisor/assistants/')
self.assertEqual(response.context['current_reviewer'], find_by_person(self.phd_supervisor))
self.assertTrue(response.context['can_delegate'])
def setUpTestData(cls):
cls.manager = ManagerFactory()
cls.settings = SettingsFactory()
cls.assistant = AcademicAssistantFactory()
cls.assistant_mandate = AssistantMandateFactory(
state=assistant_mandate_state.TRTS,
assistant=cls.assistant,
assistant_type=assistant_type.ASSISTANT)
cls.assistant2 = AcademicAssistantFactory()
cls.assistant_mandate2 = AssistantMandateFactory(
state=assistant_mandate_state.SUPERVISION,
assistant=cls.assistant2,
assistant_type=assistant_type.TEACHING_ASSISTANT)
cls.entity1 = EntityFactory()
cls.entity_version1 = EntityVersionFactory(
entity=cls.entity1, entity_type=entity_type.SECTOR)
cls.entity2 = EntityFactory()
cls.entity_version2 = EntityVersionFactory(
entity=cls.entity2, entity_type=entity_type.FACULTY)
cls.entity3 = EntityFactory()
cls.entity_version3 = EntityVersionFactory(
entity=cls.entity3, entity_type=entity_type.INSTITUTE)
cls.entity4 = EntityFactory()
cls.entity_version4 = EntityVersionFactory(
entity=cls.entity4,
parent=cls.entity2,
entity_type=entity_type.SCHOOL)
cls.mandate_entity1 = MandateEntityFactory(
assistant_mandate=cls.assistant_mandate, entity=cls.entity1)
cls.mandate_entity2 = MandateEntityFactory(
assistant_mandate=cls.assistant_mandate, entity=cls.entity2)
cls.mandate_entity3 = MandateEntityFactory(
assistant_mandate=cls.assistant_mandate, entity=cls.entity3)
cls.mandate_entity4 = MandateEntityFactory(
assistant_mandate=cls.assistant_mandate2, entity=cls.entity1)
cls.mandate_entity5 = MandateEntityFactory(
assistant_mandate=cls.assistant_mandate2, entity=cls.entity2)
cls.reviewer1 = ReviewerFactory(entity=cls.entity3,
role=reviewer_role.RESEARCH)
cls.reviewer2 = ReviewerFactory(entity=cls.entity2,
role=reviewer_role.SUPERVISION)
cls.reviewer3 = ReviewerFactory(entity=cls.entity1,
role=reviewer_role.VICE_RECTOR)
cls.reviewer4 = ReviewerFactory(entity=None,
role=reviewer_role.PHD_SUPERVISOR)
def setUpTestData(cls):
cls.settings = SettingsFactory()
today = datetime.date.today()
cls.current_academic_year = AcademicYearFactory(start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
cls.current_academic_year.save()
cls.phd_supervisor = PersonFactory()
cls.assistant = AcademicAssistantFactory(supervisor=cls.phd_supervisor)
cls.assistant_mandate2 = AssistantMandateFactory(
academic_year=cls.current_academic_year,
assistant=cls.assistant,
state=assistant_mandate_state.RESEARCH
)
cls.entity_version = EntityVersionFactory(entity_type=entity_type.INSTITUTE)
cls.entity_version2 = EntityVersionFactory(entity_type=entity_type.FACULTY)
cls.entity_version3 = EntityVersionFactory(entity_type=entity_type.SECTOR)
cls.reviewer = ReviewerFactory(
role=reviewer_role.RESEARCH,
entity=cls.entity_version.entity
)
cls.reviewer2 = ReviewerFactory(
role=reviewer_role.SUPERVISION,
entity=cls.entity_version2.entity
)
cls.reviewer3 = ReviewerFactory(
role=reviewer_role.VICE_RECTOR,
entity=cls.entity_version3.entity
)
MandateEntityFactory(
assistant_mandate=cls.assistant_mandate2,
entity=cls.entity_version.entity
)
def setUp(self):
self.mandate = AssistantMandateFactory(
state=assistant_mandate_state.DONE)
self.entity_version1 = EntityVersionFactory(
entity_type=entity_type.INSTITUTE, end_date=None)
self.mandate_entity1 = MandateEntityFactory(
assistant_mandate=self.mandate, entity=self.entity_version1.entity)
self.entity_version2 = EntityVersionFactory(
entity_type=entity_type.FACULTY, end_date=None)
self.mandate_entity2 = MandateEntityFactory(
assistant_mandate=self.mandate, entity=self.entity_version2.entity)
self.entity_version3 = EntityVersionFactory(
entity_type=entity_type.SECTOR, end_date=None)
self.mandate_entity3 = MandateEntityFactory(
assistant_mandate=self.mandate, entity=self.entity_version3.entity)
self.reviewer1 = reviewer.ReviewerFactory(
role=reviewer_role.RESEARCH, entity=self.entity_version1.entity)
self.review1 = review.ReviewFactory(reviewer=self.reviewer1,
status=review_status.DONE,
mandate=self.mandate)
self.reviewer2 = reviewer.ReviewerFactory(
role=reviewer_role.SUPERVISION, entity=self.entity_version2.entity)
self.review2 = review.ReviewFactory(reviewer=self.reviewer2,
status=review_status.DONE,
mandate=self.mandate)
self.reviewer3 = reviewer.ReviewerFactory(
role=reviewer_role.VICE_RECTOR_ASSISTANT,
entity=self.entity_version3.entity)
self.review2 = review.ReviewFactory(reviewer=self.reviewer3,
status=review_status.DONE,
mandate=self.mandate)
self.client = Client()
self.client.force_login(self.reviewer1.person.user)
def setUpTestData(cls):
cls.settings = SettingsFactory()
cls.current_academic_year = AcademicYearFactory(current=True)
cls.assistant_mandate = AssistantMandateFactory(
academic_year=cls.current_academic_year,
state=assistant_mandate_state.PHD_SUPERVISOR)
cls.review = ReviewFactory(reviewer=None,
mandate=cls.assistant_mandate,
status=review_status.IN_PROGRESS)
cls.institute = EntityVersionFactory(entity_type=entity_type.INSTITUTE,
end_date=None)
cls.institute_child = EntityVersionFactory(parent=cls.institute.entity,
end_date=None)
cls.school = EntityVersionFactory(entity_type=entity_type.SCHOOL,
end_date=None)
cls.sector = EntityVersionFactory(entity_type=entity_type.SECTOR)
cls.faculty = EntityVersionFactory(entity_type=entity_type.FACULTY)
cls.mandate_entity = MandateEntityFactory(
assistant_mandate=cls.assistant_mandate,
entity=cls.institute.entity)
cls.research_reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=cls.institute.entity)
cls.research_assistant_reviewer = ReviewerFactory(
role=reviewer_role.RESEARCH_ASSISTANT,
entity=cls.institute_child.entity)
cls.vice_sector_reviewer = ReviewerFactory(
role=reviewer_role.VICE_RECTOR, entity=cls.school.entity)
cls.supervision_reviewer = ReviewerFactory(
role=reviewer_role.SUPERVISION, entity=cls.faculty.entity)
cls.delegate = PersonFactory()
cls.delegate2 = PersonFactory()
def setUp(self):
self.maxDiff = None
self.assistant_mandate = AssistantMandateFactory()
self.entity1 = EntityFactory()
self.entity_version1 = EntityVersionFactory(
entity=self.entity1, entity_type=entity_type.SECTOR)
self.entity2 = EntityFactory()
self.entity_version2 = EntityVersionFactory(
entity=self.entity2, entity_type=entity_type.FACULTY)
self.entity3 = EntityFactory()
self.entity_version3 = EntityVersionFactory(
entity=self.entity3, entity_type=entity_type.INSTITUTE)
self.entity4 = EntityFactory()
self.entity_version4 = EntityVersionFactory(
entity=self.entity4,
parent=self.entity3,
entity_type=entity_type.SCHOOL)
self.mandate_entity1 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate, entity=self.entity1)
self.mandate_entity2 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate, entity=self.entity2)
self.mandate_entity3 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate, entity=self.entity3)
def setUp(self):
self.maxDiff = None
self.factory = RequestFactory()
self.assistant = AcademicAssistantFactory(
phd_inscription_date=datetime.date(2015, 10, 2),
thesis_title='Data fitting on manifolds',
confirmation_test_date=datetime.date(2017, 9, 25),
remark=
"Deux co-promoteurs (l'application ne m'autorise à n'en renseigner qu'un)"
)
self.mandate = AssistantMandateFactory(
assistant=self.assistant,
assistant_type=assistant_type.ASSISTANT,
sap_id='1120019',
entry_date=datetime.date(2012, 9, 15),
end_date=datetime.date(2018, 9, 14),
contract_duration='6 ans',
contract_duration_fte='6 ans',
fulltime_equivalent=1,
other_status=None,
renewal_type=assistant_mandate_renewal.NORMAL,
justification=None,
external_contract='',
external_functions='',
)
self.entity_version = EntityVersionFactory()
self.mandate_entity = MandateEntityFactory(
assistant_mandate=self.mandate, entity=self.entity_version.entity)
self.reviewer = ReviewerFactory(entity=self.mandate_entity.entity)
self.styles = getSampleStyleSheet()
self.review1 = ReviewFactory(mandate=self.mandate,
reviewer=self.reviewer)
def setUpTestData(cls):
cls.person2 = PersonFactory()
cls.manager = ManagerFactory()
cls.person = cls.manager.person
cls.entity_factory = EntityFactory()
cls.entity_factory2 = EntityFactory()
cls.entity_version = EntityVersionFactory(entity_type=entity_type.INSTITUTE,
end_date=None,
entity=cls.entity_factory)
cls.entity_version2 = EntityVersionFactory(entity_type=entity_type.INSTITUTE,
end_date=None,
entity=cls.entity_factory2)
cls.phd_supervisor = PersonFactory()
cls.assistant = AcademicAssistantFactory(supervisor=cls.phd_supervisor)
today = datetime.date.today()
cls.current_academic_year = AcademicYearFactory(start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
cls.assistant_mandate = AssistantMandateFactory(academic_year=cls.current_academic_year,
assistant=cls.assistant)
cls.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH_ASSISTANT,
entity=cls.entity_version.entity)
cls.reviewer2 = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=cls.entity_version.entity)
cls.reviewer3 = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=cls.entity_version.entity)
cls.review = ReviewFactory(reviewer=cls.reviewer2)
cls.formset = formset_factory(ReviewersFormset)
cls.current_academic_year = AcademicYearFactory(start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
def test_check_delete_learning_unit_year_with_assistants(self):
learning_unit_year = LearningUnitYearFactory()
assistant_mandate = AssistantMandateFactory()
tutoring = TutoringLearningUnitYear.objects.create(mandate=assistant_mandate,
learning_unit_year=learning_unit_year)
msg = deletion.check_learning_unit_year_deletion(learning_unit_year)
self.assertIn(tutoring, msg.keys())
def setUp(self):
self.factory = RequestFactory()
today = datetime.date.today()
self.current_academic_year = AcademicYearFactory(
start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
self.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(
supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(
academic_year=self.current_academic_year, assistant=self.assistant)
self.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
self.assistant_mandate.save()
self.review = ReviewFactory(reviewer=None,
mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
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.current_academic_year.save()
self.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(
academic_year=self.current_academic_year,
assistant=self.assistant,
state=assistant_mandate_state.RESEARCH
)
self.assistant_mandate2 = AssistantMandateFactory(
academic_year=self.current_academic_year,
assistant=self.assistant,
state=assistant_mandate_state.RESEARCH
)
self.phd_supervisor_review = ReviewFactory(
reviewer=None,
mandate=self.assistant_mandate,
status=review_status.DONE
)
self.entity_version = EntityVersionFactory(entity_type=entity_type.INSTITUTE)
self.entity_mandate = MandateEntityFactory(assistant_mandate=self.assistant_mandate,
entity=self.entity_version.entity)
self.entity_mandate2 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate2,
entity=self.entity_version.entity
)
self.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=self.entity_version.entity)
self.review = ReviewFactory(reviewer=self.reviewer, mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
self.entity_version2 = EntityVersionFactory(entity_type=entity_type.FACULTY)
self.entity_mandate2 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate,
entity=self.entity_version2.entity
)
self.reviewer2 = ReviewerFactory(
role=reviewer_role.SUPERVISION,
entity=self.entity_version2.entity
)
self.entity_version3 = EntityVersionFactory(entity_type=entity_type.SECTOR)
self.entity_mandate3 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate,
entity=self.entity_version3.entity
)
self.reviewer3 = ReviewerFactory(
role=reviewer_role.VICE_RECTOR,
entity=self.entity_version3.entity
)
class TestUsersAccess(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
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.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(academic_year=self.current_academic_year,
assistant=self.assistant)
self.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
self.assistant_mandate.save()
self.review = ReviewFactory(reviewer=None, mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
self.entity = EntityFactory()
self.entity_version = EntityVersionFactory(entity=self.entity, entity_type=entity_type.INSTITUTE)
self.mandate_entity = MandateEntityFactory(assistant_mandate=self.assistant_mandate, entity=self.entity)
self.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=self.entity_version.entity)
def test_user_is_reviewer_and_procedure_is_open(self):
auth.signals.user_logged_in.disconnect(auth.models.update_last_login)
self.client.force_login(self.reviewer)
self.assertTrue(user_is_reviewer_and_procedure_is_open(self.reviewer.person.user))
def test_user_is_not_reviewer_and_procedure_is_open(self):
auth.signals.user_logged_in.disconnect(auth.models.update_last_login)
self.client.force_login(self.assistant)
self.assertFalse(user_is_reviewer_and_procedure_is_open(self.assistant.person.user))
def test_user_is_phd_supervisor_and_procedure_is_open(self):
auth.signals.user_logged_in.disconnect(auth.models.update_last_login)
self.client.force_login(self.phd_supervisor)
self.assertTrue(user_is_phd_supervisor_and_procedure_is_open(self.phd_supervisor.user))
def test_user_is_not_phd_supervisor_and_procedure_is_open(self):
auth.signals.user_logged_in.disconnect(auth.models.update_last_login)
self.client.force_login(self.assistant)
self.assertFalse(user_is_phd_supervisor_and_procedure_is_open(self.assistant.person.user))
class TestUsersAccess(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
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.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(academic_year=self.current_academic_year,
assistant=self.assistant)
self.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
self.assistant_mandate.save()
self.review = ReviewFactory(reviewer=None, mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
self.entity = EntityFactory()
self.entity_version = EntityVersionFactory(entity=self.entity, entity_type=entity_type.INSTITUTE)
self.mandate_entity = MandateEntityFactory(assistant_mandate=self.assistant_mandate, entity=self.entity)
self.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=self.entity_version.entity)
def test_user_is_reviewer_and_procedure_is_open(self):
auth.signals.user_logged_in.disconnect(auth.models.update_last_login)
self.client.force_login(self.reviewer)
self.assertTrue(user_is_reviewer_and_procedure_is_open(self.reviewer.person.user))
def test_user_is_not_reviewer_and_procedure_is_open(self):
auth.signals.user_logged_in.disconnect(auth.models.update_last_login)
self.client.force_login(self.assistant)
self.assertFalse(user_is_reviewer_and_procedure_is_open(self.assistant.person.user))
def test_user_is_phd_supervisor_and_procedure_is_open(self):
auth.signals.user_logged_in.disconnect(auth.models.update_last_login)
self.client.force_login(self.phd_supervisor)
self.assertTrue(user_is_phd_supervisor_and_procedure_is_open(self.phd_supervisor.user))
def test_user_is_not_phd_supervisor_and_procedure_is_open(self):
auth.signals.user_logged_in.disconnect(auth.models.update_last_login)
self.client.force_login(self.assistant)
self.assertFalse(user_is_phd_supervisor_and_procedure_is_open(self.assistant.person.user))
def setUp(self):
self.mandate = AssistantMandateFactory(
assistant=self.assistant,
assistant_type=assistant_type.ASSISTANT,
sap_id='1120019',
entry_date=datetime.date(self.current_academic_year.year - 6, 9,
15),
end_date=datetime.date(self.current_academic_year.year, 9, 24),
contract_duration='6 ans',
contract_duration_fte='6 ans',
fulltime_equivalent=1,
other_status=None,
renewal_type=assistant_mandate_renewal.NORMAL,
justification=None,
external_contract='',
external_functions='',
state=assistant_mandate_state.TO_DO)
self.mandate2 = AssistantMandateFactory(
state=assistant_mandate_state.DECLINED,
academic_year=self.current_academic_year)
self.mandate3 = AssistantMandateFactory(
state=assistant_mandate_state.DECLINED,
academic_year=self.current_academic_year)
self.tutoring_learning_unit_year = TutoringLearningUnitYearFactory(
mandate=self.mandate)
self.review3 = ReviewFactory(mandate=self.mandate, reviewer=None)
self.entity_version = EntityVersionFactory()
self.mandate_entity = MandateEntityFactory(
assistant_mandate=self.mandate, entity=self.entity_version.entity)
self.entity_version2 = EntityVersionFactory(
entity_type=entity_type.FACULTY, end_date=None)
self.mandate_entity2 = MandateEntityFactory(
assistant_mandate=self.mandate, entity=self.entity_version2.entity)
self.reviewer = ReviewerFactory(role=reviewer_role.SUPERVISION,
entity=self.mandate_entity.entity)
self.reviewer2 = ReviewerFactory(entity=self.mandate_entity2.entity)
self.review1 = ReviewFactory(mandate=self.mandate,
reviewer=self.reviewer)
self.review2 = ReviewFactory(mandate=self.mandate,
reviewer=self.reviewer2,
status=review_status.IN_PROGRESS)
self.review3 = ReviewFactory(mandate=self.mandate, reviewer=None)
def test_should_only_show_past_completed_or_refused_mandates(self):
AssistantMandateFactory(assistant=self.academic_assistant,
academic_year=self.previous_acy,
state=assistant_mandate_state.PHD_SUPERVISOR)
response = self.client.get(self.url)
self.assertQuerysetEqual(response.context["assistant_mandates_list"],
[self.assistant_mandate],
transform=lambda obj: obj)
def setUpTestData(cls):
cls.open_settings = SettingsFactory()
cls.previous_acy, cls.current_acy, cls.next_acy = AcademicYearFactory.produce(
)
cls.academic_assistant = AcademicAssistantFactory()
cls.assistant_mandate = AssistantMandateFactory(
assistant=cls.academic_assistant, academic_year=cls.current_acy)
cls.url = urls.reverse('assistant_mandates')
def test_retrieve_learning_units_year_from_previous_mandate(self):
self.assistant_mandate3 = AssistantMandateFactory(assistant=self.assistant2)
self.assistant_mandate2 = AssistantMandateFactory(
assistant=self.assistant1,
academic_year=self.previous_academic_year
)
self.tutoring_learning_unit_year1 = TutoringLearningUnitYearFactory(mandate=self.assistant_mandate2)
self.tutoring_learning_unit_year2 = TutoringLearningUnitYearFactory(mandate=self.assistant_mandate2)
self.assistant_mandate5 = AssistantMandateFactory(
assistant=self.assistant2
)
retrieve_learning_units_year_from_previous_mandate(self.assistant1, self.assistant_mandate1)
self.assertEqual(len(find_by_mandate(self.assistant_mandate1)), 2)
retrieve_learning_units_year_from_previous_mandate(self.assistant2, self.assistant_mandate5)
self.assertEqual(len(find_by_mandate(self.assistant_mandate5)), 0)
retrieve_learning_units_year_from_previous_mandate(self.assistant2, self.assistant_mandate3)
self.assertEqual(len(find_by_mandate(self.assistant_mandate3)), 0)
class AssistantFormViewTestCase(TestCase):
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_assistant_form_part4_edit_view_basic(self):
self.client.force_login(self.assistant_mandate.assistant.person.user)
request = self.factory.get(reverse('form_part4_edit'))
request.user = self.assistant_mandate.assistant.person.user
with self.assertTemplateUsed('assistant_form_part4.html'):
response = form_part4_edit(request)
self.assertEqual(response.status_code, 200)
def test_get_learning_units_year(self):
self.client.force_login(self.assistant_mandate.assistant.person.user)
response = self.client.generic(
method='get',
path=
'/assistants/assistant/form/part2/get_learning_units_year/?term=LBIR1211',
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
data = json.loads(response.content.decode('utf-8'))
self.assertEqual(data[0]['value'], 'LBIR1211')
self.assertEqual(len(data), 1)
response = self.client.generic(
method='get',
path=
'/assistants/assistant/form/part2/get_learning_units_year/?term=LBIR12',
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
data = json.loads(response.content.decode('utf-8'))
self.assertEqual(len(data), 2)
def setUp(self):
self.mandate = AssistantMandateFactory(
academic_year=factory.SubFactory(AcademicYearFactory, year=datetime.date.today().year - 1))
self.mandate2 = AssistantMandateFactory(
academic_year=factory.SubFactory(AcademicYearFactory, year=datetime.date.today().year))
self.researched_academic_year = self.mandate.academic_year
self.mandate3 = AssistantMandateFactory(
academic_year=factory.SubFactory(AcademicYearFactory, year=datetime.date.today().year),
state=assistant_mandate_state.DECLINED
)
def test_should_show_past_refused_mandates(self):
past_refused_mandate = AssistantMandateFactory(
assistant=self.academic_assistant,
academic_year=self.previous_acy,
state=assistant_mandate_state.DECLINED)
response = self.client.get(self.url)
self.assertQuerysetEqual(
response.context["assistant_mandates_list"],
[past_refused_mandate, self.assistant_mandate],
transform=lambda obj: obj)
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.settings = SettingsFactory()
today = datetime.date.today()
self.manager = ManagerFactory()
self.assistant = AcademicAssistantFactory()
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,
state=assistant_mandate_state.RESEARCH)
def setUpTestData(cls):
cls.settings = SettingsFactory()
today = datetime.date.today()
cls.manager = ManagerFactory()
cls.assistant = AcademicAssistantFactory()
cls.current_academic_year = AcademicYearFactory(
start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
cls.assistant_mandate = AssistantMandateFactory(
academic_year=cls.current_academic_year,
state=assistant_mandate_state.RESEARCH)
def setUpTestData(cls):
cls.settings = SettingsFactory()
cls.current_academic_year = AcademicYearFactory(current=True)
cls.assistant_mandate = AssistantMandateFactory(
academic_year=cls.current_academic_year,
state=assistant_mandate_state.TRTS)
LearningUnitYearFactory(academic_year=cls.current_academic_year,
acronym="LBIR1210")
LearningUnitYearFactory(academic_year=cls.current_academic_year,
acronym="LBIR1211")
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.manager = ManagerFactory()
self.settings = SettingsFactory()
self.client.force_login(self.manager.person.user)
self.assistant = AcademicAssistantFactory()
self.assistant_mandate = AssistantMandateFactory(
state=assistant_mandate_state.TRTS,
assistant=self.assistant,
assistant_type=assistant_type.ASSISTANT
)
self.assistant2 = AcademicAssistantFactory()
self.assistant_mandate2 = AssistantMandateFactory(
state=assistant_mandate_state.SUPERVISION,
assistant=self.assistant2,
assistant_type=assistant_type.TEACHING_ASSISTANT
)
self.entity1 = EntityFactory()
self.entity_version1 = EntityVersionFactory(entity=self.entity1, entity_type=entity_type.SECTOR)
self.entity2 = EntityFactory()
self.entity_version2 = EntityVersionFactory(entity=self.entity2, entity_type=entity_type.FACULTY)
self.entity3 = EntityFactory()
self.entity_version3 = EntityVersionFactory(entity=self.entity3, entity_type=entity_type.INSTITUTE)
self.entity4 = EntityFactory()
self.entity_version4 = EntityVersionFactory(
entity=self.entity4, parent=self.entity2, entity_type=entity_type.SCHOOL)
self.mandate_entity1 = MandateEntityFactory(assistant_mandate=self.assistant_mandate, entity=self.entity1)
self.mandate_entity2 = MandateEntityFactory(assistant_mandate=self.assistant_mandate, entity=self.entity2)
self.mandate_entity3 = MandateEntityFactory(assistant_mandate=self.assistant_mandate, entity=self.entity3)
self.mandate_entity4 = MandateEntityFactory(assistant_mandate=self.assistant_mandate2, entity=self.entity1)
self.mandate_entity5 = MandateEntityFactory(assistant_mandate=self.assistant_mandate2, entity=self.entity2)
self.reviewer1 = ReviewerFactory(entity=self.entity3, role=reviewer_role.RESEARCH)
self.reviewer2 = ReviewerFactory(entity=self.entity2, role=reviewer_role.SUPERVISION)
self.reviewer3 = ReviewerFactory(entity=self.entity1, role=reviewer_role.VICE_RECTOR)
self.reviewer4 = ReviewerFactory(entity=None, role=reviewer_role.PHD_SUPERVISOR)
def setUpTestData(cls):
cls.mandate = AssistantMandateFactory()
cls.entity_factory = EntityFactory()
cls.entity_version = EntityVersionFactory(entity_type=entity_type.INSTITUTE,
end_date=None,
entity=cls.entity_factory)
cls.entity_factory2 = EntityFactory()
cls.entity_version2 = EntityVersionFactory(entity_type=entity_type.SECTOR,
end_date=None,
entity=cls.entity_factory2)
cls.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=cls.entity_version.entity)
cls.delegate = PersonFactory()
class AssistantFormViewTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.settings = SettingsFactory()
today = datetime.date.today()
self.current_academic_year = AcademicYearFactory(
start_date=today.replace(year=today.year-1),
end_date=today.replace(year=today.year+1),
year=today.year-1,
)
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_assistant_form_part4_edit_view_basic(self):
self.client.force_login(self.assistant_mandate.assistant.person.user)
response = self.client.get('/assistants/assistant/form/part4/edit/')
self.assertEqual(response.status_code, HTTP_OK)
def test_get_learning_units_year(self):
self.client.force_login(self.assistant_mandate.assistant.person.user)
response = self.client.generic(method='get',
path='/assistants/assistant/form/part2/get_learning_units_year/?term=LBIR1211',
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
data = json.loads(response.content.decode('utf-8'))
self.assertEqual(data[0]['value'], 'LBIR1211')
self.assertEqual(len(data), 1)
response = self.client.generic(method='get',
path='/assistants/assistant/form/part2/get_learning_units_year/?term=LBIR12',
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
data = json.loads(response.content.decode('utf-8'))
self.assertEqual(len(data), 2)
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.settings = SettingsFactory()
today = datetime.date.today()
self.current_academic_year = AcademicYearFactory(
start_date=today.replace(year=today.year-1),
end_date=today.replace(year=today.year+1),
year=today.year-1,
)
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 setUp(self):
self.factory = RequestFactory()
self.client = Client()
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.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(academic_year=self.current_academic_year,
assistant=self.assistant)
self.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
self.assistant_mandate.save()
self.review = ReviewFactory(reviewer=None, mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
self.entity1 = EntityFactory()
self.entity_version1 = EntityVersionFactory(entity=self.entity1, entity_type=entity_type.INSTITUTE)
self.mandate_entity = MandateEntityFactory(assistant_mandate=self.assistant_mandate, entity=self.entity1)
class PhdSupervisorReviewViewTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
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.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(academic_year=self.current_academic_year,
assistant=self.assistant)
self.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
self.assistant_mandate.save()
self.review = ReviewFactory(reviewer=None, mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
self.entity1 = EntityFactory()
self.entity_version1 = EntityVersionFactory(entity=self.entity1, entity_type=entity_type.INSTITUTE)
self.mandate_entity = MandateEntityFactory(assistant_mandate=self.assistant_mandate, entity=self.entity1)
def test_generate_phd_supervisor_menu_tabs(self):
self.client.force_login(self.phd_supervisor)
# Review has not been completed -> supervisor can edit
self.assertEqual(generate_phd_supervisor_menu_tabs(self.assistant_mandate, None),
[{'item': assistant_mandate_state.PHD_SUPERVISOR, 'class': '',
'action': 'edit'}])
self.assertEqual(generate_phd_supervisor_menu_tabs(self.assistant_mandate,
assistant_mandate_state.PHD_SUPERVISOR),
[{'item': assistant_mandate_state.PHD_SUPERVISOR, 'class': 'active',
'action': 'edit'}])
# Review has been completed -> supervisor can only view his review
self.review.status = review_status.DONE
self.review.save()
self.assistant_mandate.state = assistant_mandate_state.RESEARCH
self.assistant_mandate.save()
self.assertEqual(generate_phd_supervisor_menu_tabs(self.assistant_mandate, None),
[{'item': assistant_mandate_state.PHD_SUPERVISOR, 'class': '',
'action': 'view'}])
self.assertEqual(generate_phd_supervisor_menu_tabs(self.assistant_mandate,
assistant_mandate_state.PHD_SUPERVISOR),
[{'item': assistant_mandate_state.PHD_SUPERVISOR, 'class': 'active',
'action': 'view'}])
def test_pst_form_view(self):
self.client.force_login(self.phd_supervisor.user)
response = self.client.post('/assistants/phd_supervisor/pst_form/', {'mandate_id': self.assistant_mandate.id})
self.assertEqual(response.status_code, HTTP_OK)
def test_review_view(self):
self.client.force_login(self.phd_supervisor.user)
response = self.client.post('/assistants/phd_supervisor/review/view/', {'mandate_id': self.assistant_mandate.id})
self.assertEqual(response.status_code, HTTP_OK)
def test_review_edit(self):
self.client.force_login(self.phd_supervisor.user)
response = self.client.post('/assistants/phd_supervisor/review/edit/', {'mandate_id': self.assistant_mandate.id})
self.assertEqual(response.status_code, HTTP_OK)
self.review.status = review_status.DONE
self.review.save()
response = self.client.post('/assistants/phd_supervisor/review/edit/',{'mandate_id': self.assistant_mandate.id})
self.assertEqual(response.status_code, HTTP_FOUND)
def test_review_save(self):
self.client.force_login(self.phd_supervisor.user)
response = self.client.post('/assistants/phd_supervisor/review/save/', {'mandate_id': self.assistant_mandate.id,
'review_id': self.review.id
})
self.assertEqual(response.status_code, HTTP_OK)
def test_validate_review_and_update_mandate(self):
validate_review_and_update_mandate(self.review, self.assistant_mandate)
self.assertEqual(self.review.status, review_status.DONE)
self.assertEqual(self.assistant_mandate.state, assistant_mandate_state.RESEARCH)
self.entity_version1.entity_type = entity_type.POLE
self.entity_version1.save()
validate_review_and_update_mandate(self.review, self.assistant_mandate)
self.assertEqual(self.assistant_mandate.state, assistant_mandate_state.RESEARCH)
self.entity_version1.entity_type = entity_type.FACULTY
self.entity_version1.save()
validate_review_and_update_mandate(self.review, self.assistant_mandate)
self.assertEqual(self.assistant_mandate.state, assistant_mandate_state.SUPERVISION)
class StructuresListView(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
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.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(academic_year=self.current_academic_year,
assistant=self.assistant)
self.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
self.assistant_mandate.save()
self.review = ReviewFactory(reviewer=None, mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
self.entity_factory = EntityFactory()
self.entity_version = EntityVersionFactory(
entity_type=entity_type.INSTITUTE,
end_date=None,
entity=self.entity_factory
)
self.entity_factory2 = EntityFactory()
self.entity_version2 = EntityVersionFactory(
entity_type=entity_type.SCHOOL,
end_date=None,
entity=self.entity_factory2
)
self.entity_version2 = EntityVersionFactory(entity_type=entity_type.SECTOR)
self.mandate_entity = MandateEntityFactory(assistant_mandate=self.assistant_mandate,
entity=self.entity_version.entity)
self.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=self.entity_version.entity)
self.reviewer2 = ReviewerFactory(role=reviewer_role.VICE_RECTOR,
entity=self.entity_version2.entity)
self.entity_version3 = EntityVersionFactory(entity_type=entity_type.FACULTY)
self.reviewer3 = ReviewerFactory(role=reviewer_role.SUPERVISION,
entity=self.entity_version3.entity)
self.delegate = PersonFactory()
self.delegate2 = PersonFactory()
def test_with_unlogged_user(self):
response = self.client.get('/assistants/reviewer/delegation/')
self.assertEqual(response.status_code, HTTP_FOUND)
def test_context_data(self):
self.client.force_login(self.reviewer.person.user)
response = self.client.get('/assistants/reviewer/delegation/')
entities_version = entity_version.get_last_version(self.reviewer.entity).children
entities = [this_entity_version.entity for this_entity_version in entities_version]
entities.insert(0, entity_version.get_last_version(self.reviewer.entity).entity)
queryset = [{
'id': entity.id,
'title': entity_version.get_last_version(entity, None).title,
'acronym': entity.most_recent_acronym,
'has_already_delegate': get_delegate_for_entity(self.reviewer, entity)
} for entity in entities]
self.assertQuerysetEqual(response.context['object_list'],
queryset,
transform=lambda x: x
)
self.assertEqual(response.context['entity'], entity_version.get_last_version(self.reviewer.entity))
self.assertEqual(response.context['year'], self.current_academic_year.year)
self.assertEqual(response.status_code, HTTP_OK)
self.assertEqual(response.context['current_reviewer'], find_by_person(self.reviewer.person))
self.assertEqual(response.context['is_supervisor'], is_supervisor(self.reviewer.person))
def test_add_reviewer_for_structure_with_invalid_data(self):
self.client.force_login(self.reviewer.person.user)
this_entity = find_versions_from_entites([self.entity_factory.id], date=None)[0]
response = self.client.post('/assistants/reviewer/delegate/add/',
{
#'person_id': self.delegate.id,
'entity': this_entity.id,
'role': self.reviewer.role
}
)
self.assertEqual(response.status_code, HTTP_OK)
def test_add_reviewer_for_structure_with_person_already_reviewer(self):
self.client.force_login(self.reviewer.person.user)
this_entity = find_versions_from_entites([self.entity_factory.id], date=None)[0]
response = self.client.post('/assistants/reviewer/delegate/add/',
{
'person_id': self.reviewer2.person.id,
'entity': this_entity.id,
'role': self.reviewer.role
}
)
self.assertEqual(response.status_code, HTTP_OK)
def test_add_reviewer_for_structure_with_valid_data(self):
self.client.force_login(self.reviewer.person.user)
this_entity = find_versions_from_entites([self.entity_factory.id], date=None)[0]
response = self.client.post('/assistants/reviewer/delegate/add/',
{
'person_id': self.delegate.id,
'entity': this_entity.id,
'role': self.reviewer.role
}
)
self.assertEqual(response.status_code, HTTP_FOUND)
self.assertTrue(find_by_person(self.delegate))
def test_add_reviewer_for_structure_if_logged_reviewer_cannot_delegate(self):
self.client.force_login(self.reviewer2.person.user)
response = self.client.post('/assistants/reviewer/delegate/add/', {'entity': self.reviewer.entity.id})
self.assertEqual(response.status_code, HTTP_FOUND)
class TestMandateEntity(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.manager = ManagerFactory()
self.settings = SettingsFactory()
self.client.force_login(self.manager.person.user)
self.assistant = AcademicAssistantFactory()
self.assistant_mandate = AssistantMandateFactory(
state=assistant_mandate_state.TRTS,
assistant=self.assistant,
assistant_type=assistant_type.ASSISTANT
)
self.assistant2 = AcademicAssistantFactory()
self.assistant_mandate2 = AssistantMandateFactory(
state=assistant_mandate_state.SUPERVISION,
assistant=self.assistant2,
assistant_type=assistant_type.TEACHING_ASSISTANT
)
self.entity1 = EntityFactory()
self.entity_version1 = EntityVersionFactory(entity=self.entity1, entity_type=entity_type.SECTOR)
self.entity2 = EntityFactory()
self.entity_version2 = EntityVersionFactory(entity=self.entity2, entity_type=entity_type.FACULTY)
self.entity3 = EntityFactory()
self.entity_version3 = EntityVersionFactory(entity=self.entity3, entity_type=entity_type.INSTITUTE)
self.entity4 = EntityFactory()
self.entity_version4 = EntityVersionFactory(
entity=self.entity4, parent=self.entity2, entity_type=entity_type.SCHOOL)
self.mandate_entity1 = MandateEntityFactory(assistant_mandate=self.assistant_mandate, entity=self.entity1)
self.mandate_entity2 = MandateEntityFactory(assistant_mandate=self.assistant_mandate, entity=self.entity2)
self.mandate_entity3 = MandateEntityFactory(assistant_mandate=self.assistant_mandate, entity=self.entity3)
self.mandate_entity4 = MandateEntityFactory(assistant_mandate=self.assistant_mandate2, entity=self.entity1)
self.mandate_entity5 = MandateEntityFactory(assistant_mandate=self.assistant_mandate2, entity=self.entity2)
self.reviewer1 = ReviewerFactory(entity=self.entity3, role=reviewer_role.RESEARCH)
self.reviewer2 = ReviewerFactory(entity=self.entity2, role=reviewer_role.SUPERVISION)
self.reviewer3 = ReviewerFactory(entity=self.entity1, role=reviewer_role.VICE_RECTOR)
self.reviewer4 = ReviewerFactory(entity=None, role=reviewer_role.PHD_SUPERVISOR)
def test_mandate_can_go_backward(self):
self.assertTrue(mandate_can_go_backward(self.assistant_mandate))
self.assistant_mandate.state = assistant_mandate_state.RESEARCH
self.assistant_mandate.save()
self.review1 = ReviewFactory(
reviewer=self.reviewer1,
mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS
)
self.assertFalse(mandate_can_go_backward(self.assistant_mandate))
self.review1.delete()
self.assistant_mandate.state = assistant_mandate_state.TO_DO
self.assistant_mandate.save()
self.assertFalse(mandate_can_go_backward(self.assistant_mandate))
def test_assistant_mandate_step_back_from_assistant_to_beginning(self):
self.assistant_mandate.state = assistant_mandate_state.TRTS
self.assistant_mandate.save()
self.client.post(reverse('assistant_mandate_step_back'), {'mandate_id': self.assistant_mandate.id})
self.assistant_mandate.refresh_from_db()
self.assertEqual(self.assistant_mandate.state, assistant_mandate_state.TO_DO)
def test_assistant_mandate_step_back_from_phd_supervisor_to_assistant(self):
self.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
self.assistant_mandate.save()
self.client.post(reverse('assistant_mandate_step_back'), {'mandate_id': self.assistant_mandate.id})
self.assistant_mandate.refresh_from_db()
self.assertEqual(self.assistant_mandate.state, assistant_mandate_state.TRTS)
def test_assistant_mandate_step_back_from_institute_president_to_php_supervisor(self):
self.assistant.supervisor = PersonFactory()
self.assistant.save()
self.review1 = ReviewFactory(
reviewer=self.reviewer1,
mandate=self.assistant_mandate,
status=review_status.DONE
)
self.review2 = ReviewFactory(
reviewer=None,
mandate=self.assistant_mandate,
status=review_status.DONE
)
self.assistant_mandate.state = assistant_mandate_state.RESEARCH
self.assistant_mandate.save()
self.client.post(reverse('assistant_mandate_step_back'), {'mandate_id': self.assistant_mandate.id})
self.assistant_mandate.refresh_from_db()
self.assertEqual(self.assistant_mandate.state, assistant_mandate_state.PHD_SUPERVISOR)
def test_assistant_mandate_step_back_from_institute_president_to_assistant(self):
# Test if assistant does not have a phd supervisor
self.assistant_mandate.state = assistant_mandate_state.RESEARCH
self.assistant_mandate.save()
self.assistant.supervisor = None
self.assistant.save()
self.client.post(reverse('assistant_mandate_step_back'), {'mandate_id': self.assistant_mandate.id})
self.assistant_mandate.refresh_from_db()
self.assertEqual(self.assistant_mandate.state, assistant_mandate_state.TRTS)
def test_assistant_mandate_step_back_from_dean_of_faculty_to_institute_president(self):
self.research_review = ReviewFactory(mandate=self.assistant_mandate, reviewer=self.reviewer1)
self.assistant_mandate.state = assistant_mandate_state.SUPERVISION
self.assistant_mandate.save()
self.client.post(reverse('assistant_mandate_step_back'), {'mandate_id': self.assistant_mandate.id})
self.assistant_mandate.refresh_from_db()
self.assertEqual(self.assistant_mandate.state, assistant_mandate_state.RESEARCH)
def test_assistant_mandate_step_back_from_vice_rector_to_dean_of_faculty(self):
self.supervision_review = ReviewFactory(mandate=self.assistant_mandate, reviewer=self.reviewer2)
self.assistant_mandate.state = assistant_mandate_state.VICE_RECTOR
self.assistant_mandate.save()
self.client.post(reverse('assistant_mandate_step_back'), {'mandate_id': self.assistant_mandate.id})
self.assistant_mandate.refresh_from_db()
self.assertEqual(self.assistant_mandate.state, assistant_mandate_state.SUPERVISION)
def test_assistant_mandate_step_back_from_dean_of_faculty_to_assistant(self):
# Test if assistant is teaching assistant
self.research_review = ReviewFactory(mandate=self.assistant_mandate, reviewer=self.reviewer1)
self.assistant_mandate.state = assistant_mandate_state.SUPERVISION
self.assistant_mandate.save()
self.client.post(reverse('assistant_mandate_step_back'), {'mandate_id': self.assistant_mandate2.id})
self.assistant_mandate2.refresh_from_db()
self.assertEqual(self.assistant_mandate2.state, assistant_mandate_state.TRTS)
def test_assistant_mandate_step_back_from_done_to_vice_rector(self):
self.review4 = ReviewFactory(
reviewer=self.reviewer3,
mandate=self.assistant_mandate2,
status=review_status.DONE
)
self.review5 = ReviewFactory(
reviewer=self.reviewer2,
mandate=self.assistant_mandate2,
status=review_status.DONE
)
self.assistant_mandate2.state = assistant_mandate_state.DONE
self.assistant_mandate2.save()
self.client.post(reverse('assistant_mandate_step_back'), {'mandate_id': self.assistant_mandate2.id})
self.assistant_mandate2.refresh_from_db()
self.assertEqual(self.assistant_mandate2.state, assistant_mandate_state.VICE_RECTOR)
def test_add_actions_to_mandates_list(self):
self.client.force_login(self.reviewer1.person.user)
response = self.client.get('/assistants/reviewer/')
context = add_actions_to_mandates_list(response.context, self.reviewer1)
for mandate in context['object_list']:
if mandate.id == self.assistant_mandate.id:
self.assertFalse(mandate.view)
self.assertFalse(mandate.edit)
self.client.force_login(self.reviewer2.person.user)
response = self.client.get('/assistants/reviewer/')
context = add_actions_to_mandates_list(response.context, self.reviewer2)
for mandate in context['object_list']:
if mandate.id == self.assistant_mandate2.id:
self.assertTrue(mandate.view)
self.assertTrue(mandate.edit)
class ReviewerReviewViewTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
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.current_academic_year.save()
self.phd_supervisor = PersonFactory()
self.assistant = AcademicAssistantFactory(supervisor=self.phd_supervisor)
self.assistant_mandate = AssistantMandateFactory(
academic_year=self.current_academic_year,
assistant=self.assistant,
state=assistant_mandate_state.RESEARCH
)
self.assistant_mandate2 = AssistantMandateFactory(
academic_year=self.current_academic_year,
assistant=self.assistant,
state=assistant_mandate_state.RESEARCH
)
self.phd_supervisor_review = ReviewFactory(
reviewer=None,
mandate=self.assistant_mandate,
status=review_status.DONE
)
self.entity_version = EntityVersionFactory(entity_type=entity_type.INSTITUTE)
self.entity_mandate = MandateEntityFactory(assistant_mandate=self.assistant_mandate,
entity=self.entity_version.entity)
self.entity_mandate2 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate2,
entity=self.entity_version.entity
)
self.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
entity=self.entity_version.entity)
self.review = ReviewFactory(reviewer=self.reviewer, mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
self.entity_version2 = EntityVersionFactory(entity_type=entity_type.FACULTY)
self.entity_mandate2 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate,
entity=self.entity_version2.entity
)
self.reviewer2 = ReviewerFactory(
role=reviewer_role.SUPERVISION,
entity=self.entity_version2.entity
)
self.entity_version3 = EntityVersionFactory(entity_type=entity_type.SECTOR)
self.entity_mandate3 = MandateEntityFactory(
assistant_mandate=self.assistant_mandate,
entity=self.entity_version3.entity
)
self.reviewer3 = ReviewerFactory(
role=reviewer_role.VICE_RECTOR,
entity=self.entity_version3.entity
)
def test_pst_form_view(self):
self.client.force_login(self.reviewer.person.user)
response = self.client.post('/assistants/reviewer/pst_form/', {'mandate_id': self.assistant_mandate.id})
self.assertEqual(response.status_code, HTTP_OK)
def test_review_edit(self):
self.client.force_login(self.reviewer.person.user)
response = self.client.post('/assistants/reviewer/review/edit/', {'mandate_id': self.assistant_mandate2.id})
self.assertEqual(response.status_code, HTTP_OK)
def test_review_save(self):
self.client.force_login(self.reviewer.person.user)
response = self.client.post('/assistants/reviewer/review/save/', {'mandate_id': self.assistant_mandate.id,
'review_id': self.review.id
})
self.assertEqual(response.status_code, HTTP_OK)
def test_validate_review_and_update_mandate(self):
validate_review_and_update_mandate(self.review, self.assistant_mandate)
self.assertEqual(self.review.status, review_status.DONE)
self.assertEqual(self.assistant_mandate.state, assistant_mandate_state.SUPERVISION)
self.review2 = ReviewFactory(
reviewer=self.reviewer2, mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS
)
validate_review_and_update_mandate(self.review2, self.assistant_mandate)
self.assertEqual(self.review2.status, review_status.DONE)
self.assertEqual(self.assistant_mandate.state, assistant_mandate_state.VICE_RECTOR)
self.review3 = ReviewFactory(reviewer=self.reviewer3, mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS)
validate_review_and_update_mandate(self.review3, self.assistant_mandate)
self.assertEqual(self.review3.status, review_status.DONE)
self.assertEqual(self.assistant_mandate.state, assistant_mandate_state.DONE)
def test_review_view(self):
self.client.force_login(self.reviewer.person.user)
response = self.client.post('/assistants/reviewer/review/view/', {'mandate_id': self.assistant_mandate.id,
'role': reviewer_role.PHD_SUPERVISOR})
self.assertEqual(response.status_code, HTTP_OK)
response = self.client.post('/assistants/reviewer/review/view/', {'mandate_id': self.assistant_mandate.id,
'role': reviewer_role.RESEARCH})
self.assertEqual(response.status_code, HTTP_OK)
def test_generate_reviewer_menu_tabs(self):
self.client.force_login(self.reviewer.person.user)
self.assertEqual([{'action': 'view', 'class': '', 'item': 'PHD_SUPERVISOR'},
{'item': 'RESEARCH', 'class': '', 'action': 'edit'}],
generate_reviewer_menu_tabs(reviewer_role.RESEARCH, self.assistant_mandate, None))
self.review.status = review_status.DONE
self.review.save()
self.assistant_mandate.state = assistant_mandate_state.SUPERVISION
self.assistant_mandate.save()
self.review2 = ReviewFactory(
reviewer=self.reviewer2,
mandate=self.assistant_mandate,
status=review_status.IN_PROGRESS
)
self.assertEqual([{'action': 'view', 'class': '', 'item': 'PHD_SUPERVISOR'},
{'item': 'RESEARCH', 'class': 'active', 'action': 'view'}],
generate_reviewer_menu_tabs(reviewer_role.RESEARCH, self.assistant_mandate,
assistant_mandate_state.RESEARCH))
self.assertEqual([{'action': 'view', 'class': '', 'item': 'PHD_SUPERVISOR'},
{'item': 'RESEARCH', 'class': '', 'action': 'view'},
{'item': 'SUPERVISION', 'class': '', 'action': 'edit'}],
generate_reviewer_menu_tabs(reviewer_role.SUPERVISION, self.assistant_mandate, None))
