Пример #1
0
    def test_get_related_trips(self):
        activate('en')

        # actors
        ind_request = FactoryFloor.IndividualTripRequestFactory()
        child_request = FactoryFloor.ChildTripRequestFactory()
        child_request1 = FactoryFloor.ChildTripRequestFactory()
        parent_request = child_request.parent_request
        random_request = FactoryFloor.IndividualTripRequestFactory()

        reg_user = self.get_and_login_user()

        # to start, this user should have 0 trips
        self.assertEqual(utils.get_related_trips(reg_user).count(), 0)

        # setting the individual request to user should result in 1 trip
        ind_request.user = reg_user
        ind_request.save()
        self.assertIn(ind_request, utils.get_related_trips(reg_user))
        self.assertEqual(utils.get_related_trips(reg_user).count(), 1)

        # setting parent of group trip to user should increase by 1...
        parent_request.user = reg_user
        parent_request.save()
        self.assertIn(parent_request, utils.get_related_trips(reg_user))
        self.assertEqual(utils.get_related_trips(reg_user).count(), 2)

        # setting parent of child trip to user should NOT increase by 1, since this is the same trip as the parent trip...
        child_request.user = reg_user
        child_request.save()
        self.assertNotIn(child_request, utils.get_related_trips(reg_user))
        self.assertEqual(utils.get_related_trips(reg_user).count(), 2)

        # setting parent of child trip to user should increase by 1...
        child_request1.user = reg_user
        child_request1.save()
        self.assertIn(child_request1.parent_request, utils.get_related_trips(reg_user))
        self.assertEqual(utils.get_related_trips(reg_user).count(), 3)

        # setting created_by of random trip to user should increase by 1...
        random_request.created_by = reg_user
        random_request.save()
        self.assertIn(random_request, utils.get_related_trips(reg_user))
        self.assertEqual(utils.get_related_trips(reg_user).count(), 4)
Пример #2
0
 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")
Пример #3
0
    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)
Пример #4
0
    def test_trip_model(self):
        # the requests associated with a trip can be accessed by the reverse name called `trips`
        trip_request = FactoryFloor.IndividualTripRequestFactory()
        trip = trip_request.trip
        # create a group travel request
        child_trip_request = FactoryFloor.ChildTripRequestFactory()
        # now we have to set the parent tr to have the same trip
        parent_trip_request = child_trip_request.parent_request
        parent_trip_request.trip = trip
        parent_trip_request.save()

        self.assertIn(trip_request, trip.trip_requests.all())
        self.assertIn(parent_trip_request, trip.trip_requests.all())

        # get_connected_active_request prop should get a qs of all connected trip request, excluding any parent requests (for group travel only)
        self.assertNotIn(trip_request, trip.get_connected_active_requests())
        self.assertNotIn(child_trip_request,
                         trip.get_connected_active_requests())
        self.assertNotIn(parent_trip_request,
                         trip.get_connected_active_requests())

        trip_request.status_id = 11
        trip_request.save()

        parent_trip_request.status_id = 11
        parent_trip_request.save()

        self.assertIn(trip_request, trip.get_connected_active_requests())
        self.assertIn(child_trip_request, trip.get_connected_active_requests())
        self.assertNotIn(
            parent_trip_request,
            trip.get_connected_active_requests())  # parent should not turn up

        # any traveller on a group or individual request should be listed in the trip.traveller_list prop
        # ONLY IF THE STATUS IS NOT EQUAL TO draft, denied or cancelled
        self.assertIn(trip_request.user, trip.traveller_list)
        self.assertIn(child_trip_request.user, trip.traveller_list)
        # the owner of the group trip should NOT be on the list
        self.assertNotIn(parent_trip_request.user, trip.traveller_list)
        # there should be a total of 2 travellers at this point

        self.assertEqual(trip.trip_requests.count(), 2)
        self.assertEqual(len(trip.traveller_list), 2)