def test_start_trip_review_process(self):
trip = FactoryFloor.TripFactory(status=41)
for i in range(0, 5):
# add a status date just to make sure it is removed
FactoryFloor.TripReviewerFactory(trip=trip, status=23, status_date=timezone.now(), comments="123")
for r in trip.reviewers.all():
self.assertEqual(r.status, 23)
self.assertIsNotNone(r.status_date)
utils.start_trip_review_process(trip, False)
self.assertEqual(trip.status, 31)
for r in trip.reviewers.all():
self.assertEqual(r.status, 24)
self.assertIsNone(r.status_date)
# do it again but with rest=True
trip = FactoryFloor.TripFactory(status=41)
for i in range(0, 5):
# add a status date just to make sure it is removed
FactoryFloor.TripReviewerFactory(trip=trip, status=23, status_date=timezone.now(), comments="123")
for r in trip.reviewers.all():
self.assertEqual(r.status, 23)
self.assertIsNotNone(r.status_date)
utils.start_trip_review_process(trip, True)
self.assertEqual(trip.status, 41)
for r in trip.reviewers.all():
self.assertEqual(r.status, 24)
self.assertIsNotNone(r.status_date)
def setUp(self):
super().setUp()
self.instance0 = FactoryFloor.TripFactory()
self.instance1 = FactoryFloor.TripFactory()
self.instance2 = FactoryFloor.TripFactory(lead=RegionFactory())
self.instance3 = FactoryFloor.TripFactory(
is_adm_approval_required=True)
self.test_url0 = reverse_lazy('travel:trip_delete',
kwargs={
"pk": self.instance0.pk,
"type": "adm-hit-list"
})
self.test_url1 = reverse_lazy('travel:trip_delete',
kwargs={
"pk": self.instance1.pk,
"type": "region-1"
})
self.test_url2 = reverse_lazy('travel:trip_delete',
kwargs={
"pk": self.instance2.pk,
"type": "back_to_verify"
})
self.test_url3 = reverse_lazy('travel:trip_delete',
kwargs={
"pk": self.instance3.pk,
"type": "all"
})
self.expected_template = 'travel/confirm_delete.html'
def test_trip_review_process(self):
activate('en')
# actors
trip = FactoryFloor.TripFactory(status_id=41) # unreviewed, verified
reviewer1 = FactoryFloor.TripReviewerFactory(trip=trip, order=1)
reviewer2 = FactoryFloor.TripReviewerFactory(trip=trip, order=2)
reviewer3 = FactoryFloor.TripReviewerFactory(trip=trip, order=3)
self.assertIsNone(trip.review_start_date)
utils.start_trip_review_process(trip)
self.assertEqual(trip.status_id, 31)
self.assertIsNotNone(trip.review_start_date)
for reviewer in trip.reviewers.all():
self.assertEqual(reviewer.status_id, 24)
self.assertIsNone(reviewer.status_date)
# now let's end the review process
utils.end_trip_review_process(trip)
self.assertEqual(trip.status_id, 41)
# the timestamp should not be undone
self.assertIsNotNone(trip.review_start_date)
for reviewer in trip.reviewers.all():
self.assertEqual(reviewer.status_id, 23)
self.assertIsNone(reviewer.status_date)
def test_trip_request_cost_model(self):
# if you save a tr cost with a rate and days, it should provide a total equal to the product of the two
tr_cost_1 = FactoryFloor.TripRequestCostDayXRateFactory()
rate = tr_cost_1.rate_cad
days = tr_cost_1.number_of_days
tr_cost_1.save()
self.assertEqual(rate * days, tr_cost_1.amount_cad)
# if a tr_cost has only an amount, the save method should not override if there is a zero value in either rate or days
tr_cost_2 = FactoryFloor.TripRequestCostTotalFactory()
amount = tr_cost_2.amount_cad
tr_cost_2.save()
self.assertEqual(amount, tr_cost_2.amount_cad)
tr_cost_2.rate_cad = rate
tr_cost_2.number_of_days = 0
tr_cost_2.save()
self.assertEqual(amount, tr_cost_2.amount_cad)
tr_cost_2.rate_cad = 0
tr_cost_2.number_of_days = days
tr_cost_2.save()
self.assertEqual(amount, tr_cost_2.amount_cad)
tr_cost_2.rate_cad = rate
tr_cost_2.number_of_days = days
tr_cost_2.save()
self.assertEqual(rate * days, tr_cost_2.amount_cad)
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.trip_request = FactoryFloor.TripRequestFactory()
self.trip = FactoryFloor.TripFactory()
self.test_url1 = reverse_lazy('travel:export_cfts_list', args=[])
self.test_url2 = reverse_lazy('travel:export_cfts_request', args=[self.trip_request.id])
self.test_url3 = reverse_lazy('travel:export_cfts_trip', args=[self.trip.id])
self.user = self.get_and_login_user(in_group="travel_admin")
def setUp(self):
super().setUp()
self.instance1 = FactoryFloor.TripFactory(is_adm_approval_required=True)
self.instance2 = FactoryFloor.TripFactory(is_adm_approval_required=False)
self.test_url1 = reverse_lazy('travel:trip_verify', args=[self.instance1.pk])
self.test_url2 = reverse_lazy('travel:trip_verify', args=[self.instance2.pk])
self.expected_template = 'travel/trip_verification_form.html'
self.regional_admin_user = self.get_and_login_user(in_group="travel_admin")
self.ncr_admin_user = self.get_and_login_user(in_group="travel_adm_admin")
def test_get_related_requests(self):
user = UserFactory()
# scenario 1 --> they are a creator
trip_request1 = FactoryFloor.TripRequestFactory(created_by=user)
self.assertIn(trip_request1, utils.get_related_requests(user))
# scenario 2 --> they are a traveller
trip_request2 = FactoryFloor.TripRequestFactory(created_by=UserFactory())
FactoryFloor.TravellerFactory(request=trip_request2, user=user)
self.assertIn(trip_request2, utils.get_related_requests(user))
def setUp(self):
super().setUp()
self.instance = FactoryFloor.IndividualTripRequestFactory()
self.instance_child = FactoryFloor.IndividualTripRequestFactory()
self.test_url = reverse_lazy('travel:request_edit',
args=(self.instance.pk, "my"))
self.test_url1 = reverse_lazy('travel:request_edit',
args=(self.instance_child.pk, "pop"))
self.expected_template = 'travel/trip_request_form.html'
self.expected_template1 = 'travel/trip_request_form_popout.html'
def setUp(self):
super().setUp()
self.tr = FactoryFloor.IndividualTripRequestFactory()
self.tr1 = FactoryFloor.ChildTripRequestFactory()
self.test_url = reverse_lazy('travel:request_delete',
args=(self.tr.pk, "my"))
self.test_url1 = reverse_lazy('travel:request_delete',
args=(self.tr1.pk, "pop"))
self.expected_template = 'travel/confirm_delete.html'
self.expected_template1 = 'shared_models/generic_popout_form.html'
self.admin_user = self.get_and_login_user(in_group="travel_admin")
def setUp(self):
super().setUp()
self.instance1 = FactoryFloor.TripFactory(
is_adm_approval_required=True)
self.instance2 = FactoryFloor.TripFactory(
is_adm_approval_required=False)
self.test_url1 = reverse_lazy('travel:trip_delete',
args=[self.instance1.pk])
self.test_url2 = reverse_lazy('travel:trip_delete',
args=[self.instance2.pk])
self.expected_template = 'travel/confirm_delete.html'
self.regional_admin_user = self.get_and_login_regional_admin()
self.ncr_admin_user = self.get_and_login_admin()
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 setUp(self):
super().setUp()
# individual
self.instance1 = FactoryFloor.TripRequestFactory()
FactoryFloor.TravellerFactory(request=self.instance1)
# group
self.instance2 = FactoryFloor.TripRequestFactory()
FactoryFloor.TravellerFactory(request=self.instance2)
FactoryFloor.TravellerFactory(request=self.instance2)
self.test_url1 = reverse_lazy('travel:request_print', args=[self.instance1.pk])
self.test_url2 = reverse_lazy('travel:request_print', args=[self.instance2.pk])
self.expected_template1 = 'travel/traf/single.html'
self.expected_template2 = 'travel/traf/group.html'
self.user1 = self.get_and_login_user(self.instance1.created_by)
self.user2 = self.get_and_login_user(self.instance2.created_by)
def test_get_adm_eligible_trips(self):
trip = FactoryFloor.TripFactory(is_adm_approval_required=False, start_date=timezone.now(), trip_subcategory_id=8)
self.assertNotIn(trip, utils.get_adm_eligible_trips())
trip.is_adm_approval_required = True
trip.save()
self.assertNotIn(trip, utils.get_adm_eligible_trips())
trip.status = 41
trip.save()
self.assertNotIn(trip, utils.get_adm_eligible_trips())
trip_request = FactoryFloor.TripRequestFactory(trip=trip)
FactoryFloor.TravellerFactory(request=trip_request)
self.assertNotIn(trip, utils.get_adm_eligible_trips())
trip_request.status = 12
trip_request.save()
self.assertIn(trip, utils.get_adm_eligible_trips())
def setUp(self):
super().setUp()
self.instance = FactoryFloor.TripRequestFactory()
self.test_url1 = reverse_lazy('travel:request_detail', args=[self.instance.pk])
self.test_url2 = reverse_lazy('travel:request_detail_by_uuid', args=[self.instance.uuid])
self.expected_template = 'travel/request_detail.html'
self.user = self.get_and_login_user()
def setUp(self):
super().setUp()
self.instance = FactoryFloor.TripRequestFactory()
self.test_url = reverse_lazy('travel:request_cancel', args=[self.instance.pk])
self.expected_template = 'travel/form.html'
self.user1 = self.get_and_login_user(in_group="travel_adm_admin")
self.user2 = self.get_and_login_user(in_group="travel_adm_admin")
def setUp(self):
super().setUp()
self.instance = FactoryFloor.TripFactory()
self.test_url1 = reverse_lazy('travel:trip_new', args=[])
self.test_url2 = reverse_lazy('travel:trip_new', args=[]) + "?pop=true"
self.expected_template = 'travel/trip_form.html'
self.user = self.get_and_login_user()
def setUp(self):
super().setUp()
self.instance = FactoryFloor.DefaultReviewerFactory()
self.test_url = reverse_lazy('travel:default_reviewer_edit',
kwargs={"pk": self.instance.pk})
self.admin_user = self.get_and_login_user(in_group="travel_admin")
self.expected_template = 'travel/default_reviewer_form.html'
def setUp(self):
super().setUp()
self.instance = FactoryFloor.UserFactory()
self.test_url1 = reverse_lazy('travel:user_list')
self.test_url2 = reverse_lazy('travel:user_list') + "?travel_only=true"
self.expected_template = 'travel/user_list.html'
self.user = self.get_and_login_user(in_group="travel_adm_admin")
def setUp(self):
super().setUp()
self.instance = FactoryFloor.TripRequestFactory()
self.test_url = reverse_lazy('travel:request_delete',
args=[self.instance.pk])
self.expected_template = 'travel/confirm_delete.html'
self.user = self.get_and_login_user(self.instance.created_by)
def setUp(self):
super().setUp()
self.instance = FactoryFloor.TripRequestFactory()
self.test_url = reverse_lazy('travel:request_clone',
args=[self.instance.pk])
self.expected_template = 'travel/request_form.html'
self.user = self.get_and_login_user()
def setUp(self):
super().setUp()
self.instance = FactoryFloor.TripFactory()
self.test_url = reverse_lazy('travel:trip_detail',
args=[self.instance.pk])
self.expected_template = 'travel/trip_detail.html'
self.user = self.get_and_login_user()
def setUp(self):
super().setUp()
self.instance = FactoryFloor.TripFactory()
self.user = self.get_and_login_user(in_group="travel_adm_admin")
self.test_url = reverse_lazy('travel:trip_review_toggle',
kwargs={"pk": self.instance.pk})
self.expected_template = 'travel/trip_review_process_form.html'
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 setUp(self):
super().setUp()
self.instance1 = FactoryFloor.TripFactory(
is_adm_approval_required=True)
self.test_url1 = reverse_lazy('travel:trip_review_toggle',
args=[self.instance1.pk])
self.expected_template = 'travel/form.html'
self.ncr_admin_user = self.get_and_login_admin()
def setUp(self):
super().setUp()
self.test_url2 = reverse_lazy('travel:trip_list', kwargs={"type": "upcoming"}) # should be accessible by anyone
self.test_url3 = reverse_lazy('travel:trip_list', kwargs={"type": "adm-hit-list"})
self.test_url1 = reverse_lazy('travel:trip_list', kwargs={"type": "all"})
self.expected_template = 'travel/trip_list.html'
self.admin_user = self.get_and_login_user(in_group="travel_admin")
# in order for this to work, we have to make sure there is a trip obj in the db
FactoryFloor.TripFactory()
def setUp(self):
super().setUp()
self.instance = FactoryFloor.DefaultReviewerFactory()
self.test_url = reverse_lazy('travel:default_reviewer_delete',
args=[
self.instance.pk,
])
self.expected_template = 'travel/default_reviewer/default_reviewer_confirm_delete.html'
self.user = self.get_and_login_admin()
