Project for the UPV to develop an app like BlaBlaCar but only for UPV people.
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

added filter for groups

+348 -111
+2
.env
··· 1 + UPV_LOGIN_DATA_USERNAME=carshare 2 + UPV_LOGIN_DATA_PASSWORD=
+1 -1
requirements/local.txt
··· 1 1 -r base.txt 2 2 coverage==4.0.3 3 3 django-test-plus==1.0.16 4 - factory_boy==2.7.0 4 + factory_boy==2.8.0 5 5 django-debug-toolbar==1.4
+4
upvcarshare/config/settings/base.py
··· 358 358 GOOGLE_MAPS_API_KEY = env('GOOGLE_MAPS_API_KEY', default="AIzaSyAUuXiJ-kthJMHdXerksxYbqIbrRFrVfG4") 359 359 360 360 361 + # UPV CREDENTIALS 362 + # ------------------------------------------------------------------------------ 363 + # UPV_LOGIN_DATA_USERNAME = env("UPV_LOGIN_DATA_USERNAME") 364 + # UPV_LOGIN_DATA_PASSWORD = env("UPV_LOGIN_DATA_PASSWORD")
+22 -5
upvcarshare/journeys/managers.py
··· 47 47 ) 48 48 49 49 50 + class JourneyQuerySet(models.QuerySet): 51 + 52 + def visible(self, user=None): 53 + """Journey visible for the given user.""" 54 + if user is not None: 55 + return self.filter(user__groups=user.groups.all()) 56 + return self 57 + 58 + 50 59 class JourneyManager(models.GeoManager): 51 60 """Manager for Journeys.""" 52 61 62 + def get_queryset(self): 63 + return JourneyQuerySet(self.model, using=self._db) 64 + 65 + def visible(self, user=None): 66 + """Journey visible for the given user.""" 67 + return self.get_queryset().visible(user=user) 68 + 53 69 def smart_create(self, user, origin, destination, departure, transport=None): 54 70 """Enhanced method to create journeys""" 55 71 assert origin.__class__.__name__.lower() == "residence" or \ ··· 70 86 data["free_places"] = transport.default_places 71 87 return self.create(**data) 72 88 73 - def available(self, kind=None, ignore_full=False): 89 + def available(self, user=None, kind=None, ignore_full=False): 74 90 """Gets all available journeys. 91 + :param user: 75 92 :param kind: GOING, RETURN 76 93 :param ignore_full: 77 94 """ 78 95 now = timezone.now() 79 - queryset = self.filter(driver__isnull=False, departure__gt=now) 96 + queryset = self.visible(user).filter(driver__isnull=False, departure__gt=now) 80 97 if kind is not None: 81 98 queryset = queryset.filter(kind=kind) 82 99 if ignore_full: ··· 93 110 :param kind: GOING, RETURN 94 111 """ 95 112 96 - nearby = self.available(kind) 113 + nearby = self.available(kind=kind) 97 114 if kind is not None: 98 115 key = "residence{}" if kind == GOING else "campus{}" 99 116 key = key.format("__position__distance_lte") ··· 135 152 if not conditions: 136 153 return self.none() 137 154 now = timezone.now() 138 - queryset = self.available(kind=kind, ignore_full=ignore_full).exclude(user=user, departure__lt=now)\ 155 + queryset = self.available(user=user, kind=kind, ignore_full=ignore_full).exclude(user=user, departure__lt=now)\ 139 156 .filter(reduce(lambda x, y: x | y, conditions))\ 140 157 .order_by("departure") 141 158 return queryset ··· 170 187 "departure__gte": departure_lower, 171 188 })) 172 189 now = timezone.now() 173 - queryset = self.available(ignore_full=ignore_full).exclude(user=user, departure__lt=now) \ 190 + queryset = self.available(user=user, ignore_full=ignore_full).exclude(user=user, departure__lt=now) \ 174 191 .filter(reduce(lambda x, y: x | y, conditions)) \ 175 192 .order_by("departure") 176 193 return queryset
+22 -11
upvcarshare/journeys/tests/test_api.py
··· 2 2 from __future__ import unicode_literals, print_function, absolute_import 3 3 4 4 import json 5 - import random 6 5 6 + import random 7 7 from django.contrib.gis.geos import Point 8 8 from rest_framework import status 9 9 from rest_framework.test import APITestCase ··· 12 12 from journeys.models import Transport, Journey 13 13 from journeys.tests.factories import TransportFactory, ResidenceFactory, CampusFactory, JourneyFactory, MessageFactory 14 14 from users.tests.factories import UserFactory 15 + from users.tests.mocks import UPVLoginDataService 15 16 17 + try: 18 + import unittest.mock as mock 19 + except ImportError: 20 + import mock 16 21 17 - class TransportsAPITests(APITestCase): 18 22 19 - def setUp(self): 20 - self.user = UserFactory() 21 - self.transports = [TransportFactory(user=self.user) for _ in range(5)] 22 - self.other_transport = TransportFactory(user=UserFactory()) 23 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 24 + class TransportsAPITests(APITestCase): 23 25 24 26 def test_get_transports(self): 27 + user = UserFactory() 28 + transports = [TransportFactory(user=user) for _ in range(5)] 29 + TransportFactory(user=UserFactory()) 25 30 url = "/api/v1/transports/" 26 - self.client.force_authenticate(user=self.user) 31 + self.client.force_authenticate(user=user) 27 32 response = self.client.get(url) 28 33 self.assertEqual(response.status_code, status.HTTP_200_OK) 29 34 response_data = json.loads(response.content.decode('utf-8')) 30 - self.assertEquals(len(self.transports), len(response_data['results'])) 35 + self.assertEquals(len(transports), len(response_data['results'])) 31 36 32 37 def test_update_transport(self): 33 - url = "/api/v1/transports/{}/".format(self.transports[0].pk) 38 + user = UserFactory() 39 + transports = [TransportFactory(user=user) for _ in range(5)] 40 + url = "/api/v1/transports/{}/".format(transports[0].pk) 34 41 data = { 35 42 "default_places": 2 36 43 } 37 - self.client.force_authenticate(user=self.user) 44 + self.client.force_authenticate(user=user) 38 45 response = self.client.patch(url, data=data) 39 46 self.assertEqual(response.status_code, status.HTTP_200_OK) 40 - transport = Transport.objects.get(pk=self.transports[0].pk) 47 + transport = Transport.objects.get(pk=transports[0].pk) 41 48 self.assertEquals(2, transport.default_places) 42 49 43 50 51 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 44 52 class ResidenceAPITest(APITestCase): 45 53 46 54 def test_get_residences(self): ··· 54 62 self.assertEquals(len(residences), len(response_data['results'])) 55 63 56 64 65 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 57 66 class CampusAPITest(APITestCase): 58 67 59 68 def test_get_residences(self): ··· 68 77 self.assertEquals(len(campus) + 3, len(response_data['results'])) 69 78 70 79 80 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 71 81 class JourneyAPITest(APITestCase): 72 82 73 83 @staticmethod ··· 209 219 self.assertEquals(2, len(response_data['results'])) 210 220 211 221 222 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 212 223 class MessageAPITest(APITestCase): 213 224 214 225 def test_get_messages_journey(self):
+8
upvcarshare/journeys/tests/test_forms.py
··· 2 2 from __future__ import unicode_literals, print_function, absolute_import 3 3 4 4 import datetime 5 + 5 6 import six 6 7 from test_plus import TestCase 7 8 ··· 10 11 from journeys.helpers import make_point 11 12 from journeys.tests.factories import JourneyFactory 12 13 from users.tests.factories import UserFactory 14 + from users.tests.mocks import UPVLoginDataService 13 15 16 + try: 17 + import unittest.mock as mock 18 + except ImportError: 19 + import mock 14 20 21 + 22 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 15 23 class JourneysFormsTest(TestCase): 16 24 17 25 def test_search_form(self):
+7 -1
upvcarshare/journeys/tests/test_helpers.py
··· 6 6 import recurrence 7 7 from django.contrib.gis.geos import Point 8 8 from django.utils.timezone import make_naive 9 - 10 9 from test_plus import TestCase 11 10 12 11 from journeys import DEFAULT_PROJECTED_SRID, DEFAULT_WGS84_SRID 13 12 from journeys.helpers import make_point_wgs84, make_point_projected, date_to_datetime, first_day_current_week, \ 14 13 last_day_current_week, expand 15 14 from journeys.tests.factories import JourneyFactory 15 + from users.tests.mocks import UPVLoginDataService 16 16 17 + try: 18 + import unittest.mock as mock 19 + except ImportError: 20 + import mock 17 21 22 + 23 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 18 24 class JourneysHelpersTest(TestCase): 19 25 20 26 def test_make_point_wgs84(self):
+11 -3
upvcarshare/journeys/tests/test_models.py
··· 13 13 from journeys.models import Journey, Passenger, Residence 14 14 from journeys.tests.factories import ResidenceFactory, CampusFactory, TransportFactory, JourneyFactory 15 15 from users.tests.factories import UserFactory 16 + from users.tests.mocks import UPVLoginDataService 17 + 18 + try: 19 + import unittest.mock as mock 20 + except ImportError: 21 + import mock 16 22 17 23 24 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 18 25 class JourneyTest(TestCase): 19 26 """Test related with Journey model and manager methods.""" 20 27 ··· 130 137 user3 = UserFactory() 131 138 residence3 = ResidenceFactory(user=user3, position=Point(882454.58, 545877.33, srid=DEFAULT_PROJECTED_SRID)) 132 139 JourneyFactory(user=user3, residence=residence3, campus=campus) 133 - self.assertEquals(Journey.objects.available(kind=GOING).count(), 2) 140 + self.assertEquals(Journey.objects.available(user=user3, kind=GOING).count(), 2) 134 141 135 142 def test_available_return_query(self): 136 143 # Creates the available journeys with driver... ··· 145 152 user3 = UserFactory() 146 153 residence3 = ResidenceFactory(user=user3, position=Point(865621.24, 545877.33, srid=DEFAULT_PROJECTED_SRID)) 147 154 JourneyFactory(user=user3, residence=residence3, campus=campus, kind=RETURN) 148 - self.assertEquals(Journey.objects.available(kind=RETURN).count(), 1) 155 + self.assertEquals(Journey.objects.available(user=user3, kind=RETURN).count(), 1) 149 156 150 157 def test_available_query(self): 151 158 # Creates the available journeys with driver... ··· 160 167 user3 = UserFactory() 161 168 residence3 = ResidenceFactory(user=user3, position=Point(865621.24, 545274.90, srid=DEFAULT_PROJECTED_SRID)) 162 169 JourneyFactory(user=user3, residence=residence3, campus=campus, kind=RETURN) 163 - self.assertEquals(Journey.objects.available().count(), 2) 170 + self.assertEquals(Journey.objects.available(user=user3).count(), 2) 164 171 165 172 def test_nearby_query(self): 166 173 # Creates the available journeys with driver... ··· 248 255 self.assertTrue(Journey.objects.get(pk=journey.pk).disabled) 249 256 250 257 258 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 251 259 class ResidenceTest(TestCase): 252 260 253 261 def test_smart_create(self):
+90 -61
upvcarshare/journeys/tests/test_views.py
··· 10 10 from journeys.models import Journey, Residence, Passenger 11 11 from journeys.tests.factories import JourneyFactory, ResidenceFactory, CampusFactory 12 12 from users.tests.factories import UserFactory 13 + from users.tests.mocks import UPVLoginDataService 13 14 15 + try: 16 + import unittest.mock as mock 17 + except ImportError: 18 + import mock 14 19 20 + 21 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 15 22 class JourneyViewTests(TestCase): 16 23 user_factory = UserFactory 17 - 18 - def setUp(self): 19 - self.user = self.make_user(username="foo") 20 24 21 25 def test_get_create_journey(self): 26 + user = self.make_user(username="foo") 22 27 url_name = "journeys:create" 23 28 self.assertLoginRequired(url_name) 24 - with self.login(self.user): 29 + with self.login(user): 25 30 response = self.get(url_name) 26 31 self.response_200(response=response) 27 32 28 33 def test_post_create_journey(self): 34 + user = self.make_user(username="foo") 29 35 self.assertLoginRequired("journeys:create") 30 - with self.login(self.user): 36 + with self.login(user): 31 37 data = { 32 - "origin": "residence:%s" % ResidenceFactory(user=self.user).pk, 38 + "origin": "residence:%s" % ResidenceFactory(user=user).pk, 33 39 "destiny": "campus:%s" % CampusFactory().pk, 34 40 "free_places": 4, 35 41 "time_window": 30, ··· 41 47 self.assertEquals(1, Journey.objects.count()) 42 48 43 49 def test_post_create_arrival_journey(self): 50 + user = self.make_user(username="foo") 44 51 self.assertLoginRequired("journeys:create") 45 - with self.login(self.user): 52 + with self.login(user): 46 53 data = { 47 - "origin": "residence:%s" % ResidenceFactory(user=self.user).pk, 54 + "origin": "residence:%s" % ResidenceFactory(user=user).pk, 48 55 "destiny": "campus:%s" % CampusFactory().pk, 49 56 "free_places": 4, 50 57 "time_window": 30, ··· 57 64 self.assertEquals(1, Journey.objects.count()) 58 65 59 66 def test_post_create_bad_arrival_journey(self): 67 + user = self.make_user(username="foo") 60 68 self.assertLoginRequired("journeys:create") 61 - with self.login(self.user): 69 + with self.login(user): 62 70 data = { 63 - "origin": "residence:%s" % ResidenceFactory(user=self.user).pk, 71 + "origin": "residence:%s" % ResidenceFactory(user=user).pk, 64 72 "destiny": "campus:%s" % CampusFactory().pk, 65 73 "free_places": 4, 66 74 "time_window": 30, ··· 73 81 self.assertEquals(0, Journey.objects.count()) 74 82 75 83 def test_post_create_bad_departure_journey(self): 84 + user = self.make_user(username="foo") 76 85 self.assertLoginRequired("journeys:create") 77 - with self.login(self.user): 86 + with self.login(user): 78 87 data = { 79 - "origin": "residence:%s" % ResidenceFactory(user=self.user).pk, 88 + "origin": "residence:%s" % ResidenceFactory(user=user).pk, 80 89 "destiny": "campus:%s" % CampusFactory().pk, 81 90 "free_places": 4, 82 91 "time_window": 30, ··· 89 98 self.assertEquals(0, Journey.objects.count()) 90 99 91 100 def test_get_edit_journey(self): 92 - journey = JourneyFactory(user=self.user) 101 + user = self.make_user(username="foo") 102 + journey = JourneyFactory(user=user) 93 103 url_name = "journeys:edit" 94 104 self.assertLoginRequired(url_name, pk=journey.pk) 95 - with self.login(self.user): 105 + with self.login(user): 96 106 response = self.get(url_name, pk=journey.pk) 97 107 self.response_200(response=response) 98 108 99 109 def test_post_edit_journey(self): 100 - journey = JourneyFactory(user=self.user, kind=GOING) 110 + user = self.make_user(username="foo") 111 + journey = JourneyFactory(user=user, kind=GOING) 101 112 url_name = "journeys:edit" 102 113 self.assertLoginRequired(url_name, pk=journey.pk) 103 - with self.login(self.user): 114 + with self.login(user): 104 115 data = { 105 - "residence": ResidenceFactory(user=self.user).pk, 116 + "residence": ResidenceFactory(user=user).pk, 106 117 "campus": CampusFactory().pk, 107 118 "kind": RETURN, 108 119 "free_places": 4, ··· 116 127 self.assertEquals(RETURN, journey.kind) 117 128 118 129 def test_get_recommended_journey(self): 130 + user = self.make_user(username="foo") 119 131 url_name = "journeys:recommended" 120 132 self.assertLoginRequired(url_name) 121 - with self.login(self.user): 133 + with self.login(user): 122 134 response = self.get(url_name) 123 135 self.response_200(response=response) 124 136 125 137 def test_get_recommended_journey_filter(self): 138 + user = self.make_user(username="foo") 126 139 url_name = "journeys:recommended" 127 140 self.assertLoginRequired(url_name) 128 - with self.login(self.user): 141 + with self.login(user): 129 142 response = self.get(url_name, data={"distance": 200, "kind": GOING}) 130 143 self.response_200(response=response) 131 144 132 145 def test_get_list_journey(self): 146 + user = self.make_user(username="foo") 133 147 url_name = "journeys:list" 134 148 self.assertLoginRequired(url_name) 135 - with self.login(self.user): 149 + with self.login(user): 136 150 response = self.get(url_name) 137 151 self.response_200(response=response) 138 152 139 153 def test_post_join(self): 140 - journey = JourneyFactory(user=self.user, kind=GOING) 154 + user = self.make_user(username="foo") 155 + journey = JourneyFactory(user=user, kind=GOING) 141 156 url_name = "journeys:join" 142 157 self.assertLoginRequired(url_name, pk=journey.pk) 143 - with self.login(self.user): 158 + with self.login(user): 144 159 response = self.post(url_name=url_name, pk=journey.pk) 145 160 self.response_302(response=response) 146 161 147 162 def test_post_join_recurrence_all(self): 148 - journey = JourneyFactory(user=self.user, kind=GOING) 149 - journeys = [JourneyFactory(user=self.user, kind=GOING, parent=journey) for _ in range(10)] 163 + user = self.make_user(username="foo") 164 + journey = JourneyFactory(user=user, kind=GOING) 165 + journeys = [JourneyFactory(user=user, kind=GOING, parent=journey) for _ in range(10)] 150 166 url_name = "journeys:join" 151 167 self.assertLoginRequired(url_name, pk=journey.pk) 152 - with self.login(self.user): 168 + with self.login(user): 153 169 data = { 154 170 "join_to": "all" 155 171 } ··· 158 174 self.assertEquals(len(journeys) + 1, Passenger.objects.count()) 159 175 160 176 def test_post_join_recurrence_one(self): 161 - journey = JourneyFactory(user=self.user, kind=GOING) 162 - [JourneyFactory(user=self.user, kind=GOING, parent=journey) for _ in range(10)] 177 + user = self.make_user(username="foo") 178 + journey = JourneyFactory(user=user, kind=GOING) 179 + [JourneyFactory(user=user, kind=GOING, parent=journey) for _ in range(10)] 163 180 url_name = "journeys:join" 164 181 self.assertLoginRequired(url_name, pk=journey.pk) 165 - with self.login(self.user): 182 + with self.login(user): 166 183 data = { 167 184 "join_to": "one" 168 185 } ··· 171 188 self.assertEquals(1, Passenger.objects.count()) 172 189 173 190 def test_post_leave(self): 174 - journey = JourneyFactory(user=self.user, kind=GOING) 175 - journey.join_passenger(self.user) 191 + user = self.make_user(username="foo") 192 + journey = JourneyFactory(user=user, kind=GOING) 193 + journey.join_passenger(user) 176 194 url_name = "journeys:leave" 177 195 self.assertLoginRequired(url_name, pk=journey.pk) 178 - with self.login(self.user): 196 + with self.login(user): 179 197 response = self.post(url_name=url_name, pk=journey.pk) 180 198 self.response_302(response=response) 181 199 182 200 def test_post_throw_out(self): 183 - journey = JourneyFactory(user=self.user, kind=GOING) 184 - passenger = journey.join_passenger(self.user) 201 + user = self.make_user(username="foo") 202 + journey = JourneyFactory(user=user, kind=GOING) 203 + passenger = journey.join_passenger(user) 185 204 url_name = "journeys:throw-out" 186 205 self.assertLoginRequired(url_name, pk=passenger.pk) 187 - with self.login(self.user): 206 + with self.login(user): 188 207 response = self.post(url_name=url_name, pk=passenger.pk) 189 208 self.response_302(response=response) 190 209 191 210 def test_cancel_journey(self): 192 - journey = JourneyFactory(user=self.user) 211 + user = self.make_user(username="foo") 212 + journey = JourneyFactory(user=user) 193 213 url_name = "journeys:cancel" 194 214 self.assertLoginRequired(url_name, pk=journey.pk) 195 - with self.login(self.user): 215 + with self.login(user): 196 216 response = self.get(url_name, pk=journey.pk) 197 217 self.response_200(response=response) 198 218 199 219 def test_post_cancel_journey(self): 200 - journey = JourneyFactory(user=self.user) 220 + user = self.make_user(username="foo") 221 + journey = JourneyFactory(user=user) 201 222 url_name = "journeys:cancel" 202 223 self.assertLoginRequired(url_name, pk=journey.pk) 203 - with self.login(self.user): 224 + with self.login(user): 204 225 response = self.post(url_name, pk=journey.pk) 205 226 self.response_302(response=response) 206 227 self.assertTrue(Journey.objects.get(pk=journey.pk).disabled) 207 228 208 229 def test_delete_journey(self): 209 - journeys = [JourneyFactory(user=self.user) for _ in range(10)] 210 - journey = JourneyFactory(user=self.user) 230 + user = self.make_user(username="foo") 231 + journeys = [JourneyFactory(user=user) for _ in range(10)] 232 + journey = JourneyFactory(user=user) 211 233 url_name = "journeys:delete" 212 234 self.assertLoginRequired(url_name, pk=journey.pk) 213 235 self.assertEquals(len(journeys) + 1, Journey.objects.count()) 214 - with self.login(self.user): 236 + with self.login(user): 215 237 response = self.get(url_name, pk=journey.pk) 216 238 self.response_302(response=response) 217 239 self.assertFalse(Journey.objects.filter(pk=journey.pk).exists()) 218 240 self.assertEquals(len(journeys), Journey.objects.count()) 219 241 220 242 def test_delete_parent_journeys(self): 221 - journey = JourneyFactory(user=self.user) 222 - journeys = [JourneyFactory(user=self.user, parent=journey) for _ in range(10)] 243 + user = self.make_user(username="foo") 244 + journey = JourneyFactory(user=user) 245 + journeys = [JourneyFactory(user=user, parent=journey) for _ in range(10)] 223 246 url_name = "journeys:delete" 224 247 self.assertLoginRequired(url_name, pk=journey.pk) 225 248 self.assertEquals(len(journeys) + 1, Journey.objects.count()) 226 - with self.login(self.user): 249 + with self.login(user): 227 250 response = self.get(url_name, pk=journey.pk) 228 251 self.response_302(response=response) 229 252 self.assertFalse(Journey.objects.filter(pk=journey.pk).exists()) 230 253 self.assertEquals(len(journeys), Journey.objects.count()) 231 254 232 255 def test_delete_all_journeys(self): 233 - journey = JourneyFactory(user=self.user) 234 - journeys = [JourneyFactory(user=self.user, parent=journey) for _ in range(10)] 256 + user = self.make_user(username="foo") 257 + journey = JourneyFactory(user=user) 258 + journeys = [JourneyFactory(user=user, parent=journey) for _ in range(10)] 235 259 other_journeys = [JourneyFactory() for _ in range(5)] 236 260 url_name = "journeys:delete-all" 237 261 self.assertLoginRequired(url_name, pk=journey.pk) 238 262 self.assertEquals(len(journeys) + len(other_journeys) + 1, Journey.objects.count()) 239 - with self.login(self.user): 263 + with self.login(user): 240 264 response = self.get(url_name, pk=journey.pk) 241 265 self.response_302(response=response) 242 266 self.assertFalse(Journey.objects.filter(pk=journey.pk).exists()) 243 267 self.assertEquals(len(other_journeys), Journey.objects.count()) 244 268 245 269 270 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 246 271 class ResidenceViewTests(TestCase): 247 272 user_factory = UserFactory 248 273 249 - def setUp(self): 250 - self.user = self.make_user(username="foo") 251 - 252 274 def test_get_create_residence(self): 275 + user = self.make_user(username="foo") 253 276 url_name = "journeys:create-residence" 254 277 self.assertLoginRequired(url_name) 255 - with self.login(self.user): 278 + with self.login(user): 256 279 response = self.get(url_name) 257 280 self.response_200(response=response) 258 281 259 282 def test_post_create_residence(self): 283 + user = self.make_user(username="foo") 260 284 self.assertLoginRequired("journeys:create-residence") 261 - with self.login(self.user): 285 + with self.login(user): 262 286 data = { 263 287 "name": "Home", 264 288 "address": "foo", ··· 270 294 self.assertEquals(1, Residence.objects.count()) 271 295 272 296 def test_get_edit_residence(self): 273 - residence = ResidenceFactory(user=self.user) 297 + user = self.make_user(username="foo") 298 + residence = ResidenceFactory(user=user) 274 299 url_name = "journeys:edit-residence" 275 300 self.assertLoginRequired(url_name, pk=residence.pk) 276 - with self.login(self.user): 301 + with self.login(user): 277 302 response = self.get(url_name, pk=residence.pk) 278 303 self.response_200(response=response) 279 304 280 305 def test_post_edit_residence(self): 281 - residence = ResidenceFactory(user=self.user) 306 + user = self.make_user(username="foo") 307 + residence = ResidenceFactory(user=user) 282 308 url_name = "journeys:edit-residence" 283 309 self.assertLoginRequired(url_name, pk=residence.pk) 284 - with self.login(self.user): 310 + with self.login(user): 285 311 data = { 286 312 "name": "Home", 287 313 "address": "bar", ··· 294 320 self.assertEquals(data["address"], residence.address) 295 321 296 322 def test_residences(self): 297 - ResidenceFactory(user=self.user) 323 + user = self.make_user(username="foo") 324 + ResidenceFactory(user=user) 298 325 url_name = "journeys:residences" 299 326 self.assertLoginRequired(url_name) 300 - with self.login(self.user): 327 + with self.login(user): 301 328 response = self.get(url_name) 302 329 self.response_200(response=response) 303 330 304 331 def test_delete_residence(self): 305 - residence = ResidenceFactory(user=self.user) 332 + user = self.make_user(username="foo") 333 + residence = ResidenceFactory(user=user) 306 334 url_name = "journeys:delete-residence" 307 335 self.assertLoginRequired(url_name, pk=residence.pk) 308 - with self.login(self.user): 336 + with self.login(user): 309 337 response = self.get(url_name, pk=residence.pk) 310 338 self.response_302(response=response) 311 339 312 340 def test_no_delete_residence(self): 341 + initial_user = self.make_user(username="foo") 313 342 user = UserFactory() 314 - residence = ResidenceFactory(user=self.user) 343 + residence = ResidenceFactory(user=initial_user) 315 344 url_name = "journeys:delete-residence" 316 345 self.assertLoginRequired(url_name, pk=residence.pk) 317 346 with self.login(user):
+13 -8
upvcarshare/notifications/tests/test_api.py
··· 2 2 from __future__ import unicode_literals, print_function, absolute_import 3 3 4 4 import json 5 - import random 6 5 6 + import random 7 7 from rest_framework import status 8 8 from rest_framework.test import APITestCase 9 9 ··· 14 14 from notifications import LEAVE 15 15 from notifications.tests.factories import NotificationFactory 16 16 from users.tests.factories import UserFactory 17 + from users.tests.mocks import UPVLoginDataService 17 18 19 + try: 20 + import unittest.mock as mock 21 + except ImportError: 22 + import mock 18 23 24 + 25 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 19 26 class NotificationAPITests(APITestCase): 20 27 21 - def setUp(self): 22 - self.user = UserFactory() 23 - 24 28 @staticmethod 25 29 def _make_journey(user=None, kind=GOING): 26 30 user = UserFactory() if user is None else user ··· 29 33 return JourneyFactory(user=user, residence=origin, campus=destination, kind=kind) 30 34 31 35 def test_get_notifications(self): 36 + user = UserFactory() 32 37 [NotificationFactory( 33 - user=self.user, 38 + user=user, 34 39 verb=random.choice([JOIN, LEAVE]), 35 40 actor=UserFactory(), 36 - target=self._make_journey(self.user) 41 + target=self._make_journey(user) 37 42 ) for _ in range(5)] 38 43 [NotificationFactory( 39 44 user=UserFactory(), 40 45 verb=random.choice([JOIN, LEAVE]), 41 46 actor=UserFactory(), 42 - target=self._make_journey(self.user) 47 + target=self._make_journey(user) 43 48 ) for _ in range(5)] 44 49 url = "/api/v1/notifications/" 45 - self.client.force_authenticate(user=self.user) 50 + self.client.force_authenticate(user=user) 46 51 response = self.client.get(url) 47 52 self.assertEqual(response.status_code, status.HTTP_200_OK) 48 53 response_data = json.loads(response.content.decode('utf-8'))
+14 -8
upvcarshare/notifications/tests/test_models.py
··· 9 9 from notifications import JOIN, LEAVE 10 10 from notifications.models import Notification 11 11 from users.tests.factories import UserFactory 12 + from users.tests.mocks import UPVLoginDataService 13 + 14 + try: 15 + import unittest.mock as mock 16 + except ImportError: 17 + import mock 12 18 13 19 20 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 14 21 class NotificationTests(TestCase): 15 - 16 - def setUp(self): 17 - self.user = UserFactory() 18 22 19 23 @staticmethod 20 24 def _make_journey(user=None, kind=GOING): ··· 24 28 return JourneyFactory(user=user, residence=origin, campus=destination, kind=kind) 25 29 26 30 def test_join_generation(self): 31 + initial_user = UserFactory() 27 32 user = UserFactory() 28 - journey = self._make_journey(self.user) 33 + journey = self._make_journey(initial_user) 29 34 journey.join_passenger(user) 30 - self.assertEquals(1, Notification.objects.filter(user=self.user, verb=JOIN).count()) 35 + self.assertEquals(1, Notification.objects.filter(user=initial_user, verb=JOIN).count()) 31 36 32 37 def test_leave_generation(self): 38 + initial_user = UserFactory() 33 39 user = UserFactory() 34 - journey = self._make_journey(self.user) 40 + journey = self._make_journey(initial_user) 35 41 journey.join_passenger(user) 36 42 journey.confirm_passenger(user) 37 43 journey.leave_passenger(user) 38 - self.assertEquals(1, Notification.objects.filter(user=self.user, verb=JOIN).count()) 39 - self.assertEquals(1, Notification.objects.filter(user=self.user, verb=LEAVE).count()) 44 + self.assertEquals(1, Notification.objects.filter(user=initial_user, verb=JOIN).count()) 45 + self.assertEquals(1, Notification.objects.filter(user=initial_user, verb=LEAVE).count())
+8
upvcarshare/users/__init__.py
··· 1 1 # -*- coding: utf-8 -*- 2 2 from __future__ import unicode_literals, print_function, absolute_import 3 + 4 + STUDENTS_GROUP = "students" 5 + STAFF_GROUP = "staff" 6 + UPVCARSHARE_GROUPS = (STUDENTS_GROUP, STAFF_GROUP) 7 + 8 + UPV_STUDENT_ROLES = ("ALUMNO", ) 9 + 10 + default_app_config = 'users.apps.UsersConfig'
+15
upvcarshare/users/apps.py
··· 1 + # -*- coding: utf-8 -*- 2 + from __future__ import unicode_literals, print_function, division, absolute_import 3 + 4 + from django.apps import AppConfig 5 + from django.db.models.signals import post_migrate 6 + 7 + from users.signals import create_default_groups 8 + 9 + 10 + class UsersConfig(AppConfig): 11 + name = "users" 12 + 13 + def ready(self): 14 + """Connects signals with their managers.""" 15 + post_migrate.connect(create_default_groups, sender=self)
+46
upvcarshare/users/helpers.py
··· 1 + # -*- coding: utf-8 -*- 2 + from __future__ import unicode_literals, print_function, division, absolute_import 3 + 4 + import requests 5 + from django.conf import settings 6 + from django.contrib.auth.models import Group 7 + 8 + from users import UPV_STUDENT_ROLES, STUDENTS_GROUP, STAFF_GROUP 9 + 10 + 11 + class UPVLoginDataService(object): 12 + """Class to access to data user from UPV.""" 13 + 14 + BASE_URL = "https://piolin.upv.es/consultas/?c=datosLG1" 15 + 16 + @classmethod 17 + def credentials(cls): 18 + user = settings.UPV_LOGIN_DATA_USERNAME 19 + password = settings.UPV_LOGIN_DATA_PASSWORD 20 + return user, password 21 + 22 + @classmethod 23 + def user_data(cls, username): 24 + response = requests.post( 25 + url=cls.BASE_URL, 26 + data={ 27 + "login": username 28 + }, 29 + auth=cls.credentials() 30 + ) 31 + if response != 200: 32 + return {} 33 + return response.json() 34 + 35 + 36 + def from_roles_to_groups(roles): 37 + """Uses UPV roles to select the correct internal group. Returns always a list of 38 + groups, even if it's now fixed to a single one. 39 + """ 40 + try: 41 + roles = [] if roles is None else roles 42 + if set(roles).intersection(set(UPV_STUDENT_ROLES)): 43 + return [Group.objects.get(name=STUDENTS_GROUP)] 44 + return [Group.objects.get(name=STAFF_GROUP)] 45 + except Group.DoesNotExist: 46 + return list()
+10
upvcarshare/users/models.py
··· 12 12 13 13 from core.files import UploadToDir 14 14 from journeys import DEFAULT_PROJECTED_SRID, DEFAULT_DISTANCE, DEFAULT_WGS84_SRID 15 + from users.helpers import UPVLoginDataService, from_roles_to_groups 15 16 16 17 17 18 @python_2_unicode_compatible ··· 87 88 self.default_position = position 88 89 return self.default_position 89 90 91 + def update_groups(self): 92 + """Updates the groups using the UPV service.""" 93 + username = self.email.split("@")[0] 94 + user_data = UPVLoginDataService.user_data(username=username) 95 + roles = user_data.get("roles") 96 + groups = from_roles_to_groups(roles) 97 + self.groups.add(*groups) 98 + 90 99 def save(self, *args, **kwargs): 91 100 """Override to create API Token.""" 92 101 created = self.pk is None 93 102 result = super(User, self).save(*args, **kwargs) 103 + self.update_groups() 94 104 if created: 95 105 Token.objects.create(user=self) 96 106 return result
+15
upvcarshare/users/signals.py
··· 1 + # -*- coding: utf-8 -*- 2 + from __future__ import unicode_literals, print_function, division, absolute_import 3 + 4 + from users import UPVCARSHARE_GROUPS 5 + 6 + 7 + def create_default_groups(sender, **kwargs): 8 + """Creates the default groups.""" 9 + from django.contrib.auth.models import Group 10 + 11 + for group_name in UPVCARSHARE_GROUPS: 12 + group, _ = Group.objects.get_or_create( 13 + defaults={"name": group_name}, 14 + name=group_name 15 + )
+1
upvcarshare/users/tests/factories.py
··· 12 12 13 13 class Meta: 14 14 model = "users.User" 15 +
+26
upvcarshare/users/tests/mocks.py
··· 1 + # -*- coding: utf-8 -*- 2 + from __future__ import unicode_literals, print_function, division, absolute_import 3 + 4 + try: 5 + import unittest.mock as mock 6 + except ImportError: 7 + import mock 8 + 9 + 10 + class UPVLoginDataService(mock.MagicMock): 11 + 12 + PRESETS = { 13 + "margain": { 14 + "nombre": "Marcos", 15 + "apellidos": "Gabarda Inat", 16 + "dni": "53252985", 17 + "correo": "margain@upvnet.upv.es", 18 + "roles": ["EXTUPV", "UPVNET"], 19 + "centros": [], 20 + "titulaciones": [] 21 + } 22 + } 23 + 24 + @classmethod 25 + def user_data(cls, username): 26 + return cls.PRESETS.get(username, {})
+13 -7
upvcarshare/users/tests/test_api.py
··· 9 9 from journeys import DEFAULT_PROJECTED_SRID 10 10 from users.models import User 11 11 from users.tests.factories import UserFactory 12 + from users.tests.mocks import UPVLoginDataService 12 13 14 + try: 15 + import unittest.mock as mock 16 + except ImportError: 17 + import mock 13 18 19 + 20 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 14 21 class UsersAPITests(APITestCase): 15 - 16 - def setUp(self): 17 - self.user = UserFactory(default_position=Point(882823.07, 545542.48, srid=DEFAULT_PROJECTED_SRID)) 18 22 19 23 def test_get_current_user(self): 24 + user = UserFactory(default_position=Point(882823.07, 545542.48, srid=DEFAULT_PROJECTED_SRID)) 20 25 url = "/api/v1/users/me/" 21 - self.client.force_authenticate(user=self.user) 26 + self.client.force_authenticate(user=user) 22 27 response = self.client.get(url) 23 28 self.assertEqual(response.status_code, status.HTTP_200_OK) 24 29 25 30 def test_update_current_user(self): 31 + user = UserFactory(default_position=Point(882823.07, 545542.48, srid=DEFAULT_PROJECTED_SRID)) 26 32 url = "/api/v1/users/me/" 27 - self.client.force_authenticate(user=self.user) 33 + self.client.force_authenticate(user=user) 28 34 data = { 29 35 "default_address": "foo", 30 36 "default_position": { ··· 34 40 } 35 41 response = self.client.patch(url, data, format="json") 36 42 self.assertEqual(response.status_code, status.HTTP_200_OK) 37 - user = User.objects.get(pk=self.user.pk) 43 + user = User.objects.get(pk=user.pk) 38 44 self.assertEquals( 39 - "SRID=4326;POINT (-0.3767699999989411 39.46913999999702)", 45 + "SRID=4326;POINT (-0.3767699999989399 39.46913999999703)", 40 46 six.text_type(user.get_default_position_wgs84()) 41 47 ) 42 48 self.assertEquals("foo", user.default_address)
+7
upvcarshare/users/tests/test_forms.py
··· 5 5 6 6 from users.forms import SignInForm 7 7 from users.tests.factories import UserFactory 8 + from users.tests.mocks import UPVLoginDataService 9 + 10 + try: 11 + import unittest.mock as mock 12 + except ImportError: 13 + import mock 8 14 9 15 16 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 10 17 class SigInFormTests(TestCase): 11 18 user_factory = UserFactory 12 19
+13 -6
upvcarshare/users/tests/test_views.py
··· 5 5 6 6 from users.models import User 7 7 from users.tests.factories import UserFactory 8 + from users.tests.mocks import UPVLoginDataService 9 + 10 + try: 11 + import unittest.mock as mock 12 + except ImportError: 13 + import mock 8 14 9 15 16 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 10 17 class SigInViewTests(TestCase): 11 18 user_factory = UserFactory 12 19 ··· 33 40 self.response_200(response=response) 34 41 35 42 43 + @mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService) 36 44 class EditProfileViewTests(TestCase): 37 45 user_factory = UserFactory 38 46 39 - def setUp(self): 40 - self.user = self.make_user(username="foo") 41 - 42 47 def test_get_edit_profile(self): 48 + user = self.make_user(username="foo") 43 49 url_name = "users:edit" 44 50 self.assertLoginRequired(url_name) 45 - with self.login(self.user): 51 + with self.login(user): 46 52 response = self.get(url_name) 47 53 self.response_200(response=response) 48 54 49 55 def test_post_edit_profile(self): 56 + user = self.make_user(username="foo") 50 57 url_name = "users:edit" 51 58 self.assertLoginRequired(url_name) 52 - with self.login(self.user): 59 + with self.login(user): 53 60 data = { 54 61 "first_name": "foo", 55 62 "last_name": "bar" 56 63 } 57 64 response = self.post(url_name, data=data) 58 65 self.response_302(response=response) 59 - user = User.objects.get(pk=self.user.pk) 66 + user = User.objects.get(pk=user.pk) 60 67 self.assertEquals(data["first_name"], user.first_name) 61 68 self.assertEquals(data["last_name"], user.last_name)