def setUp(self):
super().setUp()
# actors
self.tr = FactoryFloor.IndividualTripRequestFactory(
submitted=timezone.now())
self.reviewer1 = FactoryFloor.ReviewerFactory(trip_request=self.tr,
role_id=1,
order=1)
self.reviewer2 = FactoryFloor.ReviewerFactory(trip_request=self.tr,
role_id=5,
order=2)
self.reviewer3 = FactoryFloor.ReviewerFactory(trip_request=self.tr,
role_id=6,
order=3)
# start the review process and get set the first reviewer to "pending"
utils.start_review_process(self.tr)
utils.approval_seeker(self.tr, True)
self.test_url1 = reverse_lazy('travel:tr_review_update',
kwargs={"pk": self.reviewer1.pk})
# there are two cases we will want to test. 1) an admin coming in to approve on behalf of and 2) a reviewer approving their own record
# 2)
self.expected_template = 'travel/reviewer_approval_form.html'
def setUp(self):
super().setUp()
self.instance = FactoryFloor.TripRequestFactory()
FactoryFloor.ReviewerFactory(request=self.instance)
self.test_url = reverse_lazy('travel:request_submit', args=[self.instance.pk])
self.expected_template = 'travel/request_submit.html'
self.user = self.get_and_login_user(self.instance.created_by)
def setUp(self):
super().setUp()
self.reviewer = FactoryFloor.ReviewerFactory()
self.instance = self.reviewer.trip_request
self.user = self.instance.user
self.test_url = reverse_lazy('travel:request_submit',
args=(self.instance.pk, "my"))
self.expected_template = 'travel/trip_request_submission_form.html'
def test_can_modify_rules(self):
activate('en')
# actors
trip_request = FactoryFloor.IndividualTripRequestFactory()
reg_user = self.get_and_login_user()
admin_user = self.get_and_login_user(in_group="travel_admin")
# RULE 1: travel admin = True
self.assertEqual(can_modify_request(admin_user, trip_request.id), True)
# RULE 2: a current reviewer; they must be able to edit a child trip and the parent trip
# a)
my_reviewer = FactoryFloor.ReviewerFactory(trip_request=trip_request, status_id=1)
self.assertEqual(can_modify_request(my_reviewer.user, trip_request.id), True)
# b)
child_trip_request = FactoryFloor.ChildTripRequestFactory()
parent_trip_request = child_trip_request.parent_request
my_reviewer = FactoryFloor.ReviewerFactory(trip_request=parent_trip_request, status_id=1)
self.assertEqual(can_modify_request(my_reviewer.user, child_trip_request.id), True)
self.assertEqual(can_modify_request(my_reviewer.user, parent_trip_request.id), True)
# RULE 3: when a trip is unsubmitted, randos cannot edit
self.assertIsNone(can_modify_request(reg_user, trip_request.id), False)
# ** THERE IS AN EXCEPTION HERE: if the trip request user is None, then anyone can edit
trip_request.user = None
trip_request.save()
self.assertEqual(can_modify_request(reg_user, trip_request.id), True)
trip_request.user = UserFactory()
trip_request.save()
# RULE 4: when a trip is unsubmitted, owners can edit
self.assertEqual(can_modify_request(trip_request.user, trip_request.id), True)
self.assertEqual(can_modify_request(parent_trip_request.user, parent_trip_request.id), True)
self.assertEqual(can_modify_request(parent_trip_request.user, child_trip_request.id), True)
# RULE 5: when a trip is unsubmitted, travellers can edit
self.assertEqual(can_modify_request(child_trip_request.user, child_trip_request.id), True)
self.assertEqual(can_modify_request(child_trip_request.user, parent_trip_request.id), True)
# RULE 6: owners are always able to unsubmit a trip
trip_request.submitted = timezone.now()
trip_request.save()
self.assertEqual(can_modify_request(trip_request.user, trip_request.id, True), True)
def test_tr_review_process(self):
activate('en')
# actors
tr = FactoryFloor.IndividualTripRequestFactory(status_id=8) # draft
reviewer1 = FactoryFloor.ReviewerFactory(trip_request=tr, order=1)
reviewer2 = FactoryFloor.ReviewerFactory(trip_request=tr, order=2)
reviewer3 = FactoryFloor.ReviewerFactory(trip_request=tr, order=3)
utils.start_review_process(tr)
for reviewer in tr.reviewers.all():
self.assertEqual(reviewer.status_id, 20)
self.assertIsNone(reviewer.status_date)
# now let's end the review process
utils.end_review_process(tr)
for reviewer in tr.reviewers.all():
self.assertEqual(reviewer.status_id, 4)
self.assertIsNone(reviewer.status_date)
def test_start_request_review_process(self):
# create your cast of people
trip_request = FactoryFloor.TripRequestFactory(status=8)
for i in range(0, 5):
# add a status date just to make sure it is removed
FactoryFloor.ReviewerFactory(request=trip_request, status=4, status_date=timezone.now())
for r in trip_request.reviewers.all():
self.assertEqual(r.status, 4)
self.assertIsNotNone(r.status_date)
utils.start_request_review_process(trip_request)
for r in trip_request.reviewers.all():
self.assertEqual(r.status, 20)
self.assertIsNone(r.status_date)
def test_end_request_review_process(self):
trip_request = FactoryFloor.TripRequestFactory(status=8)
for i in range(0, 5):
# add a status date just to make sure it is removed
FactoryFloor.ReviewerFactory(request=trip_request, status=20, status_date=timezone.now(), comments="123")
for r in trip_request.reviewers.all():
self.assertEqual(r.status, 20)
self.assertIsNotNone(r.status_date)
self.assertIsNotNone(r.comments)
utils.end_request_review_process(trip_request)
for r in trip_request.reviewers.all():
self.assertEqual(r.status, 4)
self.assertIsNone(r.status_date)
self.assertIsNone(r.comments)
def test_trip_request_model(self):
# a reviewer associated with a trip request can be accessed by the reverse name called `reviewers`
reviewer = FactoryFloor.ReviewerFactory()
tr = reviewer.trip_request
self.assertIn(reviewer, tr.reviewers.all())
# a file associated with a trip request can be accessed by the reverse name called `files`
file = FactoryFloor.FileFactory()
tr = file.trip_request
self.assertIn(file, tr.files.all())
# a file associated with a trip request can be accessed by the reverse name called `files`
tr_cost = FactoryFloor.TripRequestCostTotalFactory()
tr = tr_cost.trip_request
self.assertIn(tr_cost, tr.trip_request_costs.all())
def test_get_related_request_reviewers(self):
# scenario 1 --> they are the active reviewer
user = UserFactory()
trip_request = FactoryFloor.TripRequestFactory(created_by=user, status=17)
reviewer = FactoryFloor.ReviewerFactory(user=user, request=trip_request, status=4) # start in draft
self.assertIsNone(trip_request.current_reviewer)
reviewer.status = 1
reviewer.save()
self.assertEqual(trip_request.current_reviewer, reviewer)
self.assertIn(reviewer, utils.get_related_request_reviewers(user))
trip_request.status = 16
trip_request.save()
self.assertNotIn(reviewer, utils.get_related_request_reviewers(user))
trip_request.status = 14
trip_request.save()
self.assertNotIn(reviewer, utils.get_related_request_reviewers(user))
trip_request.status = 8
trip_request.save()
self.assertNotIn(reviewer, utils.get_related_request_reviewers(user))
def test_reviewer_model(self):
# if you save a reviewer while a request is in NON DRAFT (!=8) and the reviewer is in draft status (=4), there is a problem. the status should
# be queued (=20)
reviewer = FactoryFloor.ReviewerFactory()
tr = reviewer.trip_request
reviewer.status_id = 4 # draft
reviewer.save()
tr.status_id = 2 # pending review
tr.save()
reviewer.save()
self.assertEqual(reviewer.status_id, 20)
# reviewers with a status of pending should be accessible throught the trip_request prop `current_reviewer`
reviewer.status_id = 1 # draft
reviewer.save()
self.assertEqual(tr.current_reviewer, reviewer)
def test_context(self):
context_vars = [
"user_trip_requests",
"tr_reviews_waiting",
"trip_reviews_waiting",
"reviews_waiting",
"is_reviewer",
"is_tr_reviewer",
"is_trip_reviewer",
"is_admin",
"is_adm_admin",
"tab_dict",
]
self.assert_presence_of_context_vars(self.test_url, context_vars)
activate('en')
reg_user = self.get_and_login_user()
response = self.client.get(self.test_url)
# a regular user should not be an admin or a reviewer
self.assertEqual(response.context["is_admin"], False)
self.assertEqual(response.context["is_reviewer"], False)
# if a regular user is also a reviewer, the 'is_reviewer' var should be true
FactoryFloor.ReviewerFactory(user=reg_user)
response = self.client.get(self.test_url)
self.assertEqual(response.context["is_reviewer"], True)
# an admin user should be identified as such by the `is_admin` var in the template
self.client.logout()
admin_user = self.get_and_login_user(in_group="travel_admin")
response = self.client.get(self.test_url)
self.assertEqual(response.context["is_admin"], True)
# an adm admin user should be identified as such by the `is_adm_admin` var in the template
self.client.logout()
admin_user = self.get_and_login_user(in_group="travel_adm_admin")
response = self.client.get(self.test_url)
self.assertEqual(response.context["is_adm_admin"], True)
def test_can_modify_rules(self):
activate('en')
# actors
trip_request = FactoryFloor.TripRequestFactory()
traveller = FactoryFloor.TravellerFactory(request=trip_request)
reg_user = self.get_and_login_user()
admin_user = self.get_and_login_regional_admin()
adm_admin_user = self.get_and_login_admin()
# RULE 1: travel admin = True
self.assertEqual(can_modify_request(admin_user, trip_request.id), True)
self.assertEqual(can_modify_request(adm_admin_user, trip_request.id), True)
# RULE 2: a current reviewer; they must be able to edit a child trip and the parent trip
# a)
my_reviewer = FactoryFloor.ReviewerFactory(request=trip_request, status=1)
trip_request.status = 17
trip_request.save()
self.assertTrue(can_modify_request(my_reviewer.user, trip_request.id))
# RULE 3: when a trip is unsubmitted, randos cannot edit
self.assertFalse(can_modify_request(reg_user, trip_request.id))
# RULE 4: when a trip is unsubmitted, owners can edit
self.assertTrue(can_modify_request(trip_request.created_by, trip_request.id))
# RULE 5: when a trip is unsubmitted, travellers can edit
self.assertTrue(can_modify_request(traveller.user, trip_request.id))
# RULE 6: owners are always able to unsubmit a trip
trip_request.submitted = timezone.now()
trip_request.save()
self.assertTrue(can_modify_request(trip_request.created_by, trip_request.id, True))
trip_request.status = 22
trip_request.save()
self.assertTrue(can_modify_request(trip_request.created_by, trip_request.id, True))
def test_context(self):
context_vars = [
"field_list",
"child_field_list",
"reviewer_field_list",
"conf_field_list",
"cost_field_list",
"help_text_dict",
"help_text_dict",
"fy",
"is_admin",
"is_owner",
"is_current_reviewer",
"can_modify",
"trip",
"triprequest",
]
self.assert_presence_of_context_vars(self.test_url, context_vars)
activate('en')
reg_user = self.get_and_login_user()
response = self.client.get(self.test_url)
# expected to determine if the user is authorized to add content
# a random user should not be an admin, owner, current_reviewer, able-to-modify
self.assertEqual(response.context["is_admin"], False)
self.assertEqual(response.context["is_owner"], False)
# self.assertEqual(response.context["report_mode"], True)
# self.assertIsNone(response.context["can_modify"], False)
self.assertIsNone(response.context["is_current_reviewer"], True)
# if owner, the is_owner var should be true
self.trip_request.user = reg_user
self.trip_request.save()
response = self.client.get(self.test_url)
self.assertEqual(response.context["is_admin"], False)
self.assertEqual(response.context["is_owner"], True)
self.assertIsNone(response.context["is_current_reviewer"], True)
# if a user is an admin, they should be able to modify and are also always the current_reviewer
self.get_and_login_user(in_group='travel_admin')
response = self.client.get(self.test_url)
self.assertEqual(response.context["is_admin"], True)
self.assertEqual(response.context["is_owner"], False)
self.assertEqual(response.context["is_current_reviewer"], True)
# if a regular user is the current reviewer
my_reviewer = FactoryFloor.ReviewerFactory(
trip_request=self.trip_request, status_id=1)
self.get_and_login_user(user=my_reviewer.user)
response = self.client.get(self.test_url)
self.assertEqual(response.context["is_admin"], False)
self.assertEqual(response.context["is_owner"], False)
self.assertEqual(response.context["is_current_reviewer"], True)
# a submitted project being viewed by someone who is not admin or not current reviewer should have report_mode set to True
self.trip_request.submitted = timezone.now()
self.trip_request.save()
reg_user = self.get_and_login_user()
response = self.client.get(self.test_url)
self.assertEqual(response.context["report_mode"], True)
def test_is_approver(self):
user = self.get_and_login_user()
trip_request = FactoryFloor.TripRequestFactory(status=17)
self.assertFalse(utils.is_approver(user, trip_request))
FactoryFloor.ReviewerFactory(user=user, request=trip_request, status=1)
self.assertTrue(utils.is_approver(user, trip_request))