def get_valid_data():
start_date = faker.future_datetime(
tzinfo=timezone.get_current_timezone())
end_date = start_date + datetime.timedelta(
days=faker.random_int(1, 10))
return {
'applicant':
UserFactory().id,
'section':
SectionFactory().id,
"application_start_date":
start_date.strftime("%Y-%m-%d %H:%M"),
"application_end_date":
end_date.strftime("%Y-%m-%d %H:%M"),
'current_position_title':
faker.catch_phrase(),
'trip_subcategory':
models.TripSubcategory.objects.all()[faker.random_int(
0,
models.TripSubcategory.objects.count() - 1)].id,
'location':
faker.catch_phrase(),
'is_virtual':
faker.pybool(),
'is_adm_approval_required':
faker.pybool(),
}
def get_valid_data():
valid_data = {
'trip': TripFactory().id,
"section": SectionFactory().id,
"created_by": UserFactory().id,
"late_justification": faker.text()
}
return valid_data
def get_valid_data():
valid_data = {
'trip': TripFactory().id,
"section": SectionFactory().id,
"created_by": UserFactory().id,
"late_justification": faker.text(),
'needs_gov_vehicle': faker.pybool(),
}
return valid_data
def get_valid_data():
return {
'section_id':
SectionFactory().id,
'sex':
models.Observation.sex_choices[faker.random_int(
0,
len(models.Observation.sex_choices) - 1)][0],
'certainty_rating':
faker.pyint(0, 1),
'carapace_length_mm':
faker.pyfloat(positive=True),
}
def get_valid_data():
return {
'section':
SectionFactory().id,
'functional_group':
FunctionalGroupFactory().id,
'default_funding_source':
FundingSourceFactory().id,
'title':
faker.catch_phrase(),
'activity_type':
models.ActivityType.objects.all()[faker.random_int(
0,
models.ActivityType.objects.count() - 1)].id,
}
def create_test_data(self):
self.reg = RegionFactory()
self.bra = BranchFactory(region=self.reg)
self.div_1 = DivisionFactory(name="Div 1", branch=self.bra)
self.div_2 = DivisionFactory(name="Div 2", branch=self.bra)
self.sec_1 = SectionFactory(division=self.div_1)
self.sec_2 = SectionFactory(division=self.div_2)
self.fy_current = shared_models.FiscalYear.objects.get(pk=2020)
self.fy_previous = shared_models.FiscalYear.objects.get(pk=2018)
self.prj_1 = FactoryFloor.ProjectFactory(project_title="Test Project",
year=self.fy_current,
section=self.sec_1)
self.prj_2 = FactoryFloor.ProjectFactory(
project_title="Test Project 2",
year=self.fy_previous,
section=self.sec_2)
self.om_1 = FactoryFloor.OMCostTravelFactory(project=self.prj_1)
self.om_2 = FactoryFloor.OMCostEquipmentFactory(project=self.prj_2)
# create two DFO and one non-DFO staff for columns 5 and 6
FactoryFloor.IndeterminateStaffFactory(project=self.prj_1, lead=True)
FactoryFloor.IndeterminateStaffFactory(project=self.prj_1)
FactoryFloor.StudentStaffFactory(project=self.prj_1)
def get_valid_data():
start_date = faker.future_datetime(tzinfo=timezone.get_current_timezone())
end_date = start_date + datetime.timedelta(days=faker.random_int(1, 10))
trip = TripFactory(
start_date=start_date,
end_date=end_date,
)
valid_data = {
'trip': trip.id,
"section": SectionFactory().id,
"user": UserFactory().id,
"is_group_request": False,
"is_public_servant": True,
"is_research_scientist": True,
"start_date": trip.start_date.strftime("%Y-%m-%d %H:%M"),
"end_date": trip.end_date.strftime("%Y-%m-%d %H:%M"),
}
return valid_data
def test_submit(self):
data = FactoryFloor.DefaultReviewerFactory.get_valid_data()
self.assert_success_url(self.test_url, data=data, user=self.admin_user)
# check if a section reviewer is added correctly to a trip request
my_section = SectionFactory()
my_reviewer = FactoryFloor.DefaultReviewerFactory()
my_reviewer.sections.add(my_section)
my_tr = FactoryFloor.IndividualTripRequestFactory(section=my_section)
utils.get_tr_reviewers(my_tr)
self.assertIn(my_reviewer.user,
[r.user for r in my_tr.reviewers.all()])
# check if a branch reviewer is added correctly to a trip request
my_branch = my_section.division.branch
my_reviewer = FactoryFloor.DefaultReviewerFactory()
my_reviewer.branches.add(my_branch)
my_tr = FactoryFloor.IndividualTripRequestFactory(section=my_section)
utils.get_tr_reviewers(my_tr)
self.assertIn(my_reviewer.user,
[r.user for r in my_tr.reviewers.all()])
def get_valid_data():
start_date = faker.future_datetime(
tzinfo=timezone.get_current_timezone())
return {
"section":
SectionFactory().id,
"title_eng":
faker.catch_phrase(),
"descr_eng":
faker.text(),
"purpose_eng":
faker.text(),
"resource_type":
models.ResourceType.objects.all()[faker.random_int(
0,
models.ResourceType.objects.count() - 1)].id,
"time_start_day":
start_date.day,
"time_start_month":
start_date.month,
"time_start_year":
start_date.year,
}
def test_is_manager_or_assistant_or_admin(self):
section = SectionFactory(head=UserFactory(), admin=UserFactory())
division = section.division
division.head = UserFactory()
division.admin = UserFactory()
division.save()
branch = division.branch
branch.admin = UserFactory()
branch.head = UserFactory()
branch.save()
region = branch.region
region.head = UserFactory()
region.admin = UserFactory()
region.save()
rando = UserFactory()
self.assertFalse(utils.is_manager_or_assistant_or_admin(rando))
self.assertTrue(utils.is_manager_or_assistant_or_admin(section.head))
self.assertTrue(utils.is_manager_or_assistant_or_admin(division.head))
self.assertTrue(utils.is_manager_or_assistant_or_admin(branch.head))
self.assertTrue(utils.is_manager_or_assistant_or_admin(region.head))
self.assertTrue(utils.is_manager_or_assistant_or_admin(section.admin))
self.assertTrue(utils.is_manager_or_assistant_or_admin(division.admin))
self.assertTrue(utils.is_manager_or_assistant_or_admin(branch.admin))
self.assertTrue(utils.is_manager_or_assistant_or_admin(region.admin))
def test_m2m_sections(self):
# a `default_reviewer` that is attached to a given `sections` should be accessible by the m2m field name `sections`
section = SectionFactory()
self.instance.sections.add(section)
self.assertEqual(self.instance.sections.count(), 1)
self.assertIn(section, self.instance.sections.all())
def test_auth_utils(self):
section = SectionFactory()
rando = self.get_and_login_user()
admin = self.get_and_login_user(in_group="projects_admin")
section_head = section.head
division_head = section.division.head
branch_head = section.division.branch.head
project = FactoryFloor.ProjectFactory()
date1 = datetime(year=2019,
month=4,
day=1,
tzinfo=timezone.get_current_timezone())
date2 = datetime(year=2020,
month=4,
day=1,
tzinfo=timezone.get_current_timezone())
project_year1 = FactoryFloor.ProjectYearFactory(project=project,
start_date=date1)
project_year2 = FactoryFloor.ProjectYearFactory(project=project,
start_date=date2)
staff1a = FactoryFloor.LeadStaffFactory(project_year=project_year1)
staff1b = FactoryFloor.StaffFactory(project_year=project_year1,
is_lead=False)
staff2a = FactoryFloor.LeadStaffFactory(project_year=project_year2)
staff2b = FactoryFloor.StaffFactory(project_year=project_year2,
is_lead=False)
# is in projects admin group
self.assertFalse(utils.in_projects_admin_group(rando))
self.assertFalse(utils.in_projects_admin_group(section_head))
self.assertTrue(utils.in_projects_admin_group(admin))
# is manager
self.assertFalse(utils.is_management(rando))
self.assertFalse(utils.is_management(admin))
self.assertTrue(utils.is_management(section_head))
self.assertTrue(utils.is_management(division_head))
self.assertTrue(utils.is_management(branch_head))
# is manager or admin
self.assertFalse(utils.is_admin_or_project_manager(rando, project))
self.assertFalse(
utils.is_admin_or_project_manager(section_head, project))
self.assertTrue(utils.is_admin_or_project_manager(admin, project))
self.assertTrue(
utils.is_admin_or_project_manager(project.section.head, project))
self.assertTrue(
utils.is_admin_or_project_manager(project.section.division.head,
project))
self.assertTrue(
utils.is_admin_or_project_manager(
project.section.division.branch.head, project))
# is section head
self.assertFalse(utils.is_section_head(section_head, project))
self.assertFalse(
utils.is_section_head(project.section.division.head, project))
self.assertFalse(
utils.is_section_head(project.section.division.branch.head,
project))
self.assertTrue(utils.is_section_head(project.section.head, project))
# is_division_manager
self.assertFalse(utils.is_division_manager(division_head, project))
self.assertFalse(
utils.is_division_manager(project.section.head, project))
self.assertFalse(
utils.is_division_manager(project.section.division.branch.head,
project))
self.assertTrue(
utils.is_division_manager(project.section.division.head, project))
# is_rds
self.assertFalse(utils.is_rds(branch_head, project))
self.assertFalse(utils.is_rds(project.section.head, project))
self.assertFalse(utils.is_rds(project.section.division.head, project))
self.assertTrue(
utils.is_rds(project.section.division.branch.head, project))
self.assertTrue(utils.is_rds(branch_head))
# is_project_lead
# first with project id
self.assertFalse(
utils.is_project_lead(section_head, project_id=project.id))
self.assertFalse(utils.is_project_lead(admin, project_id=project.id))
self.assertFalse(utils.is_project_lead(rando, project_id=project.id))
self.assertFalse(
utils.is_project_lead(staff1b.user, project_id=project.id))
self.assertFalse(
utils.is_project_lead(staff2b.user, project_id=project.id))
self.assertTrue(
utils.is_project_lead(staff1a.user, project_id=project.id))
self.assertTrue(
utils.is_project_lead(staff2a.user, project_id=project.id))
# first with project id
self.assertFalse(
utils.is_project_lead(section_head,
project_year_id=project_year1.id))
self.assertFalse(
utils.is_project_lead(admin, project_year_id=project_year1.id))
self.assertFalse(
utils.is_project_lead(rando, project_year_id=project_year1.id))
self.assertFalse(
utils.is_project_lead(staff1b.user,
project_year_id=project_year1.id))
self.assertFalse(
utils.is_project_lead(staff2b.user,
project_year_id=project_year1.id))
self.assertTrue(
utils.is_project_lead(staff1a.user,
project_year_id=project_year1.id))
self.assertTrue(
utils.is_project_lead(staff2a.user,
project_year_id=project_year1.id))
# can_modify_project
# first make sure the default is not to return bool statement
self.assertIsInstance(utils.can_modify_project(rando, project.id),
bool)
self.assertIsInstance(
utils.can_modify_project(rando, project.id, return_as_dict=True),
dict)
self.assertFalse(utils.can_modify_project(rando, project.id))
self.assertFalse(utils.can_modify_project(section_head, project.id))
self.assertFalse(utils.can_modify_project(division_head, project.id))
self.assertFalse(utils.can_modify_project(branch_head, project.id))
self.assertFalse(utils.can_modify_project(staff1b.user, project.id))
self.assertFalse(utils.can_modify_project(staff2b.user, project.id))
self.assertTrue(utils.can_modify_project(admin, project.id))
self.assertTrue(
utils.can_modify_project(project.section.head, project.id))
self.assertTrue(
utils.can_modify_project(project.section.division.head,
project.id))
self.assertTrue(
utils.can_modify_project(project.section.division.branch.head,
project.id))
self.assertTrue(utils.can_modify_project(staff1a.user, project.id))
self.assertTrue(utils.can_modify_project(staff2a.user, project.id))
# if we delete all staff, then anyone should be allowed to modify
models.Staff.objects.filter(project_year__project=project,
is_lead=True).delete()
self.assertTrue(utils.can_modify_project(rando, project.id))
def get_valid_data():
return {
'user': UserFactory().id,
'sections': SectionFactory().id,
'branches': BranchFactory().id,
}
def test_get_request_reviewers(self):
# create your cast of people
section = SectionFactory(head=UserFactory(), admin=UserFactory())
division = section.division
division.head = UserFactory()
division.save()
branch = division.branch
branch.admin = UserFactory()
branch.head = UserFactory()
branch.save()
region = branch.region
region.head = UserFactory()
region.save()
adm, created = models.DefaultReviewer.objects.get_or_create(user=UserFactory(), special_role=5)
presection2, created = models.DefaultReviewer.objects.get_or_create(user=UserFactory(), order=2)
presection1, created = models.DefaultReviewer.objects.get_or_create(user=UserFactory(), order=1)
presection2.sections.add(section)
presection1.sections.add(section)
prediv2, created = models.DefaultReviewer.objects.get_or_create(user=UserFactory(), order=2)
prediv1, created = models.DefaultReviewer.objects.get_or_create(user=UserFactory(), order=1)
prediv2.divisions.add(division)
prediv1.divisions.add(division)
prebranch2, created = models.DefaultReviewer.objects.get_or_create(user=UserFactory(), order=2)
prebranch1, created = models.DefaultReviewer.objects.get_or_create(user=UserFactory(), order=1)
prebranch2.branches.add(branch)
prebranch1.branches.add(branch)
trip_request = FactoryFloor.TripRequestFactory(status=17, section=section)
trip = trip_request.trip
trip.is_adm_approval_required = True
trip.is_virtual = False
trip.save()
self.assertEqual(trip_request.reviewers.count(), 0)
utils.get_request_reviewers(trip_request)
supposed_reviewer_list = [
presection1.user,
presection2.user,
section.admin,
section.head,
prediv1.user,
prediv2.user,
division.head,
prebranch1.user,
prebranch2.user,
branch.admin,
branch.head,
adm.user,
region.head
]
actual_reviewer_list = [r.user for r in trip_request.reviewers.all()]
self.assertEqual(supposed_reviewer_list, actual_reviewer_list)
# if there is a regional delegate for expenditure initiation, this should take place of RDG
## this only applies to domestic travel... so we will have to remove ADM as well
trip.is_adm_approval_required = False
trip.save()
ei, created = models.DefaultReviewer.objects.get_or_create(user=UserFactory(), expenditure_initiation_region=region)
trip_request.reviewers.all().delete()
supposed_reviewer_list = supposed_reviewer_list[:-1]
supposed_reviewer_list = supposed_reviewer_list[:-1]
supposed_reviewer_list.append(ei.user)
utils.get_request_reviewers(trip_request)
actual_reviewer_list = [r.user for r in trip_request.reviewers.all()]
self.assertEqual(supposed_reviewer_list, actual_reviewer_list)
# if the trip is virtual, there would be no expenditure initiation
trip.is_virtual = True
trip.save()
trip_request.reviewers.all().delete()
supposed_reviewer_list = supposed_reviewer_list[:-1]
utils.get_request_reviewers(trip_request)
actual_reviewer_list = [r.user for r in trip_request.reviewers.all()]
self.assertEqual(supposed_reviewer_list, actual_reviewer_list)
def test_get_requests_with_managerial_access(self):
section1 = SectionFactory(head=UserFactory(), admin=UserFactory())
division = section1.division
division.head = UserFactory()
division.admin = UserFactory()
division.save()
branch = division.branch
branch.admin = UserFactory()
branch.head = UserFactory()
branch.save()
sector = branch.sector
sector.admin = UserFactory()
sector.head = UserFactory()
sector.save()
region = sector.region
region.head = UserFactory()
region.admin = UserFactory()
region.save()
# another section within division
section2 = SectionFactory(head=UserFactory(), admin=UserFactory(), division=division)
# another section within branch
d = DivisionFactory(head=UserFactory(), admin=UserFactory(), branch=branch)
section3 = SectionFactory(head=UserFactory(), admin=UserFactory(), division=d)
# another section within region
b = BranchFactory(head=UserFactory(), admin=UserFactory(), sector=sector)
d = DivisionFactory(head=UserFactory(), admin=UserFactory(), branch=b)
section4 = SectionFactory(head=UserFactory(), admin=UserFactory(), division=d)
# create 4 trip requests, one under each section
r1 = FactoryFloor.TripRequestFactory(section=section1)
r2 = FactoryFloor.TripRequestFactory(section=section2)
r3 = FactoryFloor.TripRequestFactory(section=section3)
r4 = FactoryFloor.TripRequestFactory(section=section4)
# start high: region head should see all four requests
self.assertEqual(utils.get_requests_with_managerial_access(region.head).count(), 4)
self.assertEqual(utils.get_requests_with_managerial_access(region.admin).count(), 4)
for r in [r1, r2, r3, r4]:
self.assertIn(r, utils.get_requests_with_managerial_access(region.head))
self.assertIn(r, utils.get_requests_with_managerial_access(region.admin))
# branch head should see all 3 requests
self.assertEqual(utils.get_requests_with_managerial_access(branch.head).count(), 3)
self.assertEqual(utils.get_requests_with_managerial_access(branch.admin).count(), 3)
for r in [r1, r2, r3]:
self.assertIn(r, utils.get_requests_with_managerial_access(branch.head))
self.assertIn(r, utils.get_requests_with_managerial_access(branch.admin))
# division head should see all 2 requests
self.assertEqual(utils.get_requests_with_managerial_access(division.head).count(), 2)
self.assertEqual(utils.get_requests_with_managerial_access(division.admin).count(), 2)
for r in [r1, r2]:
self.assertIn(r, utils.get_requests_with_managerial_access(division.head))
self.assertIn(r, utils.get_requests_with_managerial_access(division.admin))
# section head should see all 1 requests
self.assertEqual(utils.get_requests_with_managerial_access(section1.head).count(), 1)
self.assertEqual(utils.get_requests_with_managerial_access(section1.admin).count(), 1)
for r in [r1]:
self.assertIn(r, utils.get_requests_with_managerial_access(section1.head))
self.assertIn(r, utils.get_requests_with_managerial_access(section1.admin))
