Project for the UPV to develop an app like BlaBlaCar but only for UPV people.
added filter for groups
+348
-111
21 changed files
requirements
upvcarshare
config
settings
journeys
notifications
tests
+1
-1
requirements/local.txt
+1
-1
requirements/local.txt
+4
upvcarshare/config/settings/base.py
+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
361
+
# UPV CREDENTIALS
362
362
+
# ------------------------------------------------------------------------------
363
363
+
# UPV_LOGIN_DATA_USERNAME = env("UPV_LOGIN_DATA_USERNAME")
364
364
+
# UPV_LOGIN_DATA_PASSWORD = env("UPV_LOGIN_DATA_PASSWORD")
+22
-5
upvcarshare/journeys/managers.py
+22
-5
upvcarshare/journeys/managers.py
···
47
47
)
48
48
49
49
50
50
+
class JourneyQuerySet(models.QuerySet):
51
51
+
52
52
+
def visible(self, user=None):
53
53
+
"""Journey visible for the given user."""
54
54
+
if user is not None:
55
55
+
return self.filter(user__groups=user.groups.all())
56
56
+
return self
57
57
+
58
58
+
50
59
class JourneyManager(models.GeoManager):
51
60
"""Manager for Journeys."""
52
61
62
62
+
def get_queryset(self):
63
63
+
return JourneyQuerySet(self.model, using=self._db)
64
64
+
65
65
+
def visible(self, user=None):
66
66
+
"""Journey visible for the given user."""
67
67
+
return self.get_queryset().visible(user=user)
68
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
73
-
def available(self, kind=None, ignore_full=False):
89
89
+
def available(self, user=None, kind=None, ignore_full=False):
74
90
"""Gets all available journeys.
91
91
+
:param user:
75
92
:param kind: GOING, RETURN
76
93
:param ignore_full:
77
94
"""
78
95
now = timezone.now()
79
79
-
queryset = self.filter(driver__isnull=False, departure__gt=now)
96
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
96
-
nearby = self.available(kind)
113
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
138
-
queryset = self.available(kind=kind, ignore_full=ignore_full).exclude(user=user, departure__lt=now)\
155
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
173
-
queryset = self.available(ignore_full=ignore_full).exclude(user=user, departure__lt=now) \
190
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
+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
5
-
import random
6
5
6
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
15
+
from users.tests.mocks import UPVLoginDataService
15
16
17
17
+
try:
18
18
+
import unittest.mock as mock
19
19
+
except ImportError:
20
20
+
import mock
16
21
17
17
-
class TransportsAPITests(APITestCase):
18
22
19
19
-
def setUp(self):
20
20
-
self.user = UserFactory()
21
21
-
self.transports = [TransportFactory(user=self.user) for _ in range(5)]
22
22
-
self.other_transport = TransportFactory(user=UserFactory())
23
23
+
@mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService)
24
24
+
class TransportsAPITests(APITestCase):
23
25
24
26
def test_get_transports(self):
27
27
+
user = UserFactory()
28
28
+
transports = [TransportFactory(user=user) for _ in range(5)]
29
29
+
TransportFactory(user=UserFactory())
25
30
url = "/api/v1/transports/"
26
26
-
self.client.force_authenticate(user=self.user)
31
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
30
-
self.assertEquals(len(self.transports), len(response_data['results']))
35
35
+
self.assertEquals(len(transports), len(response_data['results']))
31
36
32
37
def test_update_transport(self):
33
33
-
url = "/api/v1/transports/{}/".format(self.transports[0].pk)
38
38
+
user = UserFactory()
39
39
+
transports = [TransportFactory(user=user) for _ in range(5)]
40
40
+
url = "/api/v1/transports/{}/".format(transports[0].pk)
34
41
data = {
35
42
"default_places": 2
36
43
}
37
37
-
self.client.force_authenticate(user=self.user)
44
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
40
-
transport = Transport.objects.get(pk=self.transports[0].pk)
47
47
+
transport = Transport.objects.get(pk=transports[0].pk)
41
48
self.assertEquals(2, transport.default_places)
42
49
43
50
51
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
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
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
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
+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
+
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
14
+
from users.tests.mocks import UPVLoginDataService
13
15
16
16
+
try:
17
17
+
import unittest.mock as mock
18
18
+
except ImportError:
19
19
+
import mock
14
20
21
21
+
22
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
+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
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
15
+
from users.tests.mocks import UPVLoginDataService
16
16
17
17
+
try:
18
18
+
import unittest.mock as mock
19
19
+
except ImportError:
20
20
+
import mock
17
21
22
22
+
23
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
+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
16
+
from users.tests.mocks import UPVLoginDataService
17
17
+
18
18
+
try:
19
19
+
import unittest.mock as mock
20
20
+
except ImportError:
21
21
+
import mock
16
22
17
23
24
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
133
-
self.assertEquals(Journey.objects.available(kind=GOING).count(), 2)
140
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
148
-
self.assertEquals(Journey.objects.available(kind=RETURN).count(), 1)
155
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
163
-
self.assertEquals(Journey.objects.available().count(), 2)
170
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
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
+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
13
+
from users.tests.mocks import UPVLoginDataService
13
14
15
15
+
try:
16
16
+
import unittest.mock as mock
17
17
+
except ImportError:
18
18
+
import mock
14
19
20
20
+
21
21
+
@mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService)
15
22
class JourneyViewTests(TestCase):
16
23
user_factory = UserFactory
17
17
-
18
18
-
def setUp(self):
19
19
-
self.user = self.make_user(username="foo")
20
24
21
25
def test_get_create_journey(self):
26
26
+
user = self.make_user(username="foo")
22
27
url_name = "journeys:create"
23
28
self.assertLoginRequired(url_name)
24
24
-
with self.login(self.user):
29
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
34
+
user = self.make_user(username="foo")
29
35
self.assertLoginRequired("journeys:create")
30
30
-
with self.login(self.user):
36
36
+
with self.login(user):
31
37
data = {
32
32
-
"origin": "residence:%s" % ResidenceFactory(user=self.user).pk,
38
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
50
+
user = self.make_user(username="foo")
44
51
self.assertLoginRequired("journeys:create")
45
45
-
with self.login(self.user):
52
52
+
with self.login(user):
46
53
data = {
47
47
-
"origin": "residence:%s" % ResidenceFactory(user=self.user).pk,
54
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
67
+
user = self.make_user(username="foo")
60
68
self.assertLoginRequired("journeys:create")
61
61
-
with self.login(self.user):
69
69
+
with self.login(user):
62
70
data = {
63
63
-
"origin": "residence:%s" % ResidenceFactory(user=self.user).pk,
71
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
84
+
user = self.make_user(username="foo")
76
85
self.assertLoginRequired("journeys:create")
77
77
-
with self.login(self.user):
86
86
+
with self.login(user):
78
87
data = {
79
79
-
"origin": "residence:%s" % ResidenceFactory(user=self.user).pk,
88
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
92
-
journey = JourneyFactory(user=self.user)
101
101
+
user = self.make_user(username="foo")
102
102
+
journey = JourneyFactory(user=user)
93
103
url_name = "journeys:edit"
94
104
self.assertLoginRequired(url_name, pk=journey.pk)
95
95
-
with self.login(self.user):
105
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
100
-
journey = JourneyFactory(user=self.user, kind=GOING)
110
110
+
user = self.make_user(username="foo")
111
111
+
journey = JourneyFactory(user=user, kind=GOING)
101
112
url_name = "journeys:edit"
102
113
self.assertLoginRequired(url_name, pk=journey.pk)
103
103
-
with self.login(self.user):
114
114
+
with self.login(user):
104
115
data = {
105
105
-
"residence": ResidenceFactory(user=self.user).pk,
116
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
130
+
user = self.make_user(username="foo")
119
131
url_name = "journeys:recommended"
120
132
self.assertLoginRequired(url_name)
121
121
-
with self.login(self.user):
133
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
138
+
user = self.make_user(username="foo")
126
139
url_name = "journeys:recommended"
127
140
self.assertLoginRequired(url_name)
128
128
-
with self.login(self.user):
141
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
146
+
user = self.make_user(username="foo")
133
147
url_name = "journeys:list"
134
148
self.assertLoginRequired(url_name)
135
135
-
with self.login(self.user):
149
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
140
-
journey = JourneyFactory(user=self.user, kind=GOING)
154
154
+
user = self.make_user(username="foo")
155
155
+
journey = JourneyFactory(user=user, kind=GOING)
141
156
url_name = "journeys:join"
142
157
self.assertLoginRequired(url_name, pk=journey.pk)
143
143
-
with self.login(self.user):
158
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
148
-
journey = JourneyFactory(user=self.user, kind=GOING)
149
149
-
journeys = [JourneyFactory(user=self.user, kind=GOING, parent=journey) for _ in range(10)]
163
163
+
user = self.make_user(username="foo")
164
164
+
journey = JourneyFactory(user=user, kind=GOING)
165
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
152
-
with self.login(self.user):
168
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
161
-
journey = JourneyFactory(user=self.user, kind=GOING)
162
162
-
[JourneyFactory(user=self.user, kind=GOING, parent=journey) for _ in range(10)]
177
177
+
user = self.make_user(username="foo")
178
178
+
journey = JourneyFactory(user=user, kind=GOING)
179
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
165
-
with self.login(self.user):
182
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
174
-
journey = JourneyFactory(user=self.user, kind=GOING)
175
175
-
journey.join_passenger(self.user)
191
191
+
user = self.make_user(username="foo")
192
192
+
journey = JourneyFactory(user=user, kind=GOING)
193
193
+
journey.join_passenger(user)
176
194
url_name = "journeys:leave"
177
195
self.assertLoginRequired(url_name, pk=journey.pk)
178
178
-
with self.login(self.user):
196
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
183
-
journey = JourneyFactory(user=self.user, kind=GOING)
184
184
-
passenger = journey.join_passenger(self.user)
201
201
+
user = self.make_user(username="foo")
202
202
+
journey = JourneyFactory(user=user, kind=GOING)
203
203
+
passenger = journey.join_passenger(user)
185
204
url_name = "journeys:throw-out"
186
205
self.assertLoginRequired(url_name, pk=passenger.pk)
187
187
-
with self.login(self.user):
206
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
192
-
journey = JourneyFactory(user=self.user)
211
211
+
user = self.make_user(username="foo")
212
212
+
journey = JourneyFactory(user=user)
193
213
url_name = "journeys:cancel"
194
214
self.assertLoginRequired(url_name, pk=journey.pk)
195
195
-
with self.login(self.user):
215
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
200
-
journey = JourneyFactory(user=self.user)
220
220
+
user = self.make_user(username="foo")
221
221
+
journey = JourneyFactory(user=user)
201
222
url_name = "journeys:cancel"
202
223
self.assertLoginRequired(url_name, pk=journey.pk)
203
203
-
with self.login(self.user):
224
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
209
-
journeys = [JourneyFactory(user=self.user) for _ in range(10)]
210
210
-
journey = JourneyFactory(user=self.user)
230
230
+
user = self.make_user(username="foo")
231
231
+
journeys = [JourneyFactory(user=user) for _ in range(10)]
232
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
214
-
with self.login(self.user):
236
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
221
-
journey = JourneyFactory(user=self.user)
222
222
-
journeys = [JourneyFactory(user=self.user, parent=journey) for _ in range(10)]
243
243
+
user = self.make_user(username="foo")
244
244
+
journey = JourneyFactory(user=user)
245
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
226
-
with self.login(self.user):
249
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
233
-
journey = JourneyFactory(user=self.user)
234
234
-
journeys = [JourneyFactory(user=self.user, parent=journey) for _ in range(10)]
256
256
+
user = self.make_user(username="foo")
257
257
+
journey = JourneyFactory(user=user)
258
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
239
-
with self.login(self.user):
263
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
270
+
@mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService)
246
271
class ResidenceViewTests(TestCase):
247
272
user_factory = UserFactory
248
273
249
249
-
def setUp(self):
250
250
-
self.user = self.make_user(username="foo")
251
251
-
252
274
def test_get_create_residence(self):
275
275
+
user = self.make_user(username="foo")
253
276
url_name = "journeys:create-residence"
254
277
self.assertLoginRequired(url_name)
255
255
-
with self.login(self.user):
278
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
283
+
user = self.make_user(username="foo")
260
284
self.assertLoginRequired("journeys:create-residence")
261
261
-
with self.login(self.user):
285
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
273
-
residence = ResidenceFactory(user=self.user)
297
297
+
user = self.make_user(username="foo")
298
298
+
residence = ResidenceFactory(user=user)
274
299
url_name = "journeys:edit-residence"
275
300
self.assertLoginRequired(url_name, pk=residence.pk)
276
276
-
with self.login(self.user):
301
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
281
-
residence = ResidenceFactory(user=self.user)
306
306
+
user = self.make_user(username="foo")
307
307
+
residence = ResidenceFactory(user=user)
282
308
url_name = "journeys:edit-residence"
283
309
self.assertLoginRequired(url_name, pk=residence.pk)
284
284
-
with self.login(self.user):
310
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
297
-
ResidenceFactory(user=self.user)
323
323
+
user = self.make_user(username="foo")
324
324
+
ResidenceFactory(user=user)
298
325
url_name = "journeys:residences"
299
326
self.assertLoginRequired(url_name)
300
300
-
with self.login(self.user):
327
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
305
-
residence = ResidenceFactory(user=self.user)
332
332
+
user = self.make_user(username="foo")
333
333
+
residence = ResidenceFactory(user=user)
306
334
url_name = "journeys:delete-residence"
307
335
self.assertLoginRequired(url_name, pk=residence.pk)
308
308
-
with self.login(self.user):
336
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
341
+
initial_user = self.make_user(username="foo")
313
342
user = UserFactory()
314
314
-
residence = ResidenceFactory(user=self.user)
343
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
+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
5
-
import random
6
5
6
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
17
+
from users.tests.mocks import UPVLoginDataService
17
18
19
19
+
try:
20
20
+
import unittest.mock as mock
21
21
+
except ImportError:
22
22
+
import mock
18
23
24
24
+
25
25
+
@mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService)
19
26
class NotificationAPITests(APITestCase):
20
27
21
21
-
def setUp(self):
22
22
-
self.user = UserFactory()
23
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
36
+
user = UserFactory()
32
37
[NotificationFactory(
33
33
-
user=self.user,
38
38
+
user=user,
34
39
verb=random.choice([JOIN, LEAVE]),
35
40
actor=UserFactory(),
36
36
-
target=self._make_journey(self.user)
41
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
42
-
target=self._make_journey(self.user)
47
47
+
target=self._make_journey(user)
43
48
) for _ in range(5)]
44
49
url = "/api/v1/notifications/"
45
45
-
self.client.force_authenticate(user=self.user)
50
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
+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
12
+
from users.tests.mocks import UPVLoginDataService
13
13
+
14
14
+
try:
15
15
+
import unittest.mock as mock
16
16
+
except ImportError:
17
17
+
import mock
12
18
13
19
20
20
+
@mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService)
14
21
class NotificationTests(TestCase):
15
15
-
16
16
-
def setUp(self):
17
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
31
+
initial_user = UserFactory()
27
32
user = UserFactory()
28
28
-
journey = self._make_journey(self.user)
33
33
+
journey = self._make_journey(initial_user)
29
34
journey.join_passenger(user)
30
30
-
self.assertEquals(1, Notification.objects.filter(user=self.user, verb=JOIN).count())
35
35
+
self.assertEquals(1, Notification.objects.filter(user=initial_user, verb=JOIN).count())
31
36
32
37
def test_leave_generation(self):
38
38
+
initial_user = UserFactory()
33
39
user = UserFactory()
34
34
-
journey = self._make_journey(self.user)
40
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
38
-
self.assertEquals(1, Notification.objects.filter(user=self.user, verb=JOIN).count())
39
39
-
self.assertEquals(1, Notification.objects.filter(user=self.user, verb=LEAVE).count())
44
44
+
self.assertEquals(1, Notification.objects.filter(user=initial_user, verb=JOIN).count())
45
45
+
self.assertEquals(1, Notification.objects.filter(user=initial_user, verb=LEAVE).count())
+8
upvcarshare/users/__init__.py
+8
upvcarshare/users/__init__.py
···
1
1
# -*- coding: utf-8 -*-
2
2
from __future__ import unicode_literals, print_function, absolute_import
3
3
+
4
4
+
STUDENTS_GROUP = "students"
5
5
+
STAFF_GROUP = "staff"
6
6
+
UPVCARSHARE_GROUPS = (STUDENTS_GROUP, STAFF_GROUP)
7
7
+
8
8
+
UPV_STUDENT_ROLES = ("ALUMNO", )
9
9
+
10
10
+
default_app_config = 'users.apps.UsersConfig'
+15
upvcarshare/users/apps.py
+15
upvcarshare/users/apps.py
···
1
1
+
# -*- coding: utf-8 -*-
2
2
+
from __future__ import unicode_literals, print_function, division, absolute_import
3
3
+
4
4
+
from django.apps import AppConfig
5
5
+
from django.db.models.signals import post_migrate
6
6
+
7
7
+
from users.signals import create_default_groups
8
8
+
9
9
+
10
10
+
class UsersConfig(AppConfig):
11
11
+
name = "users"
12
12
+
13
13
+
def ready(self):
14
14
+
"""Connects signals with their managers."""
15
15
+
post_migrate.connect(create_default_groups, sender=self)
+46
upvcarshare/users/helpers.py
+46
upvcarshare/users/helpers.py
···
1
1
+
# -*- coding: utf-8 -*-
2
2
+
from __future__ import unicode_literals, print_function, division, absolute_import
3
3
+
4
4
+
import requests
5
5
+
from django.conf import settings
6
6
+
from django.contrib.auth.models import Group
7
7
+
8
8
+
from users import UPV_STUDENT_ROLES, STUDENTS_GROUP, STAFF_GROUP
9
9
+
10
10
+
11
11
+
class UPVLoginDataService(object):
12
12
+
"""Class to access to data user from UPV."""
13
13
+
14
14
+
BASE_URL = "https://piolin.upv.es/consultas/?c=datosLG1"
15
15
+
16
16
+
@classmethod
17
17
+
def credentials(cls):
18
18
+
user = settings.UPV_LOGIN_DATA_USERNAME
19
19
+
password = settings.UPV_LOGIN_DATA_PASSWORD
20
20
+
return user, password
21
21
+
22
22
+
@classmethod
23
23
+
def user_data(cls, username):
24
24
+
response = requests.post(
25
25
+
url=cls.BASE_URL,
26
26
+
data={
27
27
+
"login": username
28
28
+
},
29
29
+
auth=cls.credentials()
30
30
+
)
31
31
+
if response != 200:
32
32
+
return {}
33
33
+
return response.json()
34
34
+
35
35
+
36
36
+
def from_roles_to_groups(roles):
37
37
+
"""Uses UPV roles to select the correct internal group. Returns always a list of
38
38
+
groups, even if it's now fixed to a single one.
39
39
+
"""
40
40
+
try:
41
41
+
roles = [] if roles is None else roles
42
42
+
if set(roles).intersection(set(UPV_STUDENT_ROLES)):
43
43
+
return [Group.objects.get(name=STUDENTS_GROUP)]
44
44
+
return [Group.objects.get(name=STAFF_GROUP)]
45
45
+
except Group.DoesNotExist:
46
46
+
return list()
+10
upvcarshare/users/models.py
+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
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
91
+
def update_groups(self):
92
92
+
"""Updates the groups using the UPV service."""
93
93
+
username = self.email.split("@")[0]
94
94
+
user_data = UPVLoginDataService.user_data(username=username)
95
95
+
roles = user_data.get("roles")
96
96
+
groups = from_roles_to_groups(roles)
97
97
+
self.groups.add(*groups)
98
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
103
+
self.update_groups()
94
104
if created:
95
105
Token.objects.create(user=self)
96
106
return result
+15
upvcarshare/users/signals.py
+15
upvcarshare/users/signals.py
···
1
1
+
# -*- coding: utf-8 -*-
2
2
+
from __future__ import unicode_literals, print_function, division, absolute_import
3
3
+
4
4
+
from users import UPVCARSHARE_GROUPS
5
5
+
6
6
+
7
7
+
def create_default_groups(sender, **kwargs):
8
8
+
"""Creates the default groups."""
9
9
+
from django.contrib.auth.models import Group
10
10
+
11
11
+
for group_name in UPVCARSHARE_GROUPS:
12
12
+
group, _ = Group.objects.get_or_create(
13
13
+
defaults={"name": group_name},
14
14
+
name=group_name
15
15
+
)
+1
upvcarshare/users/tests/factories.py
+1
upvcarshare/users/tests/factories.py
+26
upvcarshare/users/tests/mocks.py
+26
upvcarshare/users/tests/mocks.py
···
1
1
+
# -*- coding: utf-8 -*-
2
2
+
from __future__ import unicode_literals, print_function, division, absolute_import
3
3
+
4
4
+
try:
5
5
+
import unittest.mock as mock
6
6
+
except ImportError:
7
7
+
import mock
8
8
+
9
9
+
10
10
+
class UPVLoginDataService(mock.MagicMock):
11
11
+
12
12
+
PRESETS = {
13
13
+
"margain": {
14
14
+
"nombre": "Marcos",
15
15
+
"apellidos": "Gabarda Inat",
16
16
+
"dni": "53252985",
17
17
+
"correo": "margain@upvnet.upv.es",
18
18
+
"roles": ["EXTUPV", "UPVNET"],
19
19
+
"centros": [],
20
20
+
"titulaciones": []
21
21
+
}
22
22
+
}
23
23
+
24
24
+
@classmethod
25
25
+
def user_data(cls, username):
26
26
+
return cls.PRESETS.get(username, {})
+13
-7
upvcarshare/users/tests/test_api.py
+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
12
+
from users.tests.mocks import UPVLoginDataService
12
13
14
14
+
try:
15
15
+
import unittest.mock as mock
16
16
+
except ImportError:
17
17
+
import mock
13
18
19
19
+
20
20
+
@mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService)
14
21
class UsersAPITests(APITestCase):
15
15
-
16
16
-
def setUp(self):
17
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
24
+
user = UserFactory(default_position=Point(882823.07, 545542.48, srid=DEFAULT_PROJECTED_SRID))
20
25
url = "/api/v1/users/me/"
21
21
-
self.client.force_authenticate(user=self.user)
26
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
31
+
user = UserFactory(default_position=Point(882823.07, 545542.48, srid=DEFAULT_PROJECTED_SRID))
26
32
url = "/api/v1/users/me/"
27
27
-
self.client.force_authenticate(user=self.user)
33
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
37
-
user = User.objects.get(pk=self.user.pk)
43
43
+
user = User.objects.get(pk=user.pk)
38
44
self.assertEquals(
39
39
-
"SRID=4326;POINT (-0.3767699999989411 39.46913999999702)",
45
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
+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
8
+
from users.tests.mocks import UPVLoginDataService
9
9
+
10
10
+
try:
11
11
+
import unittest.mock as mock
12
12
+
except ImportError:
13
13
+
import mock
8
14
9
15
16
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
+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
8
+
from users.tests.mocks import UPVLoginDataService
9
9
+
10
10
+
try:
11
11
+
import unittest.mock as mock
12
12
+
except ImportError:
13
13
+
import mock
8
14
9
15
16
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
43
+
@mock.patch('users.models.UPVLoginDataService', new=UPVLoginDataService)
36
44
class EditProfileViewTests(TestCase):
37
45
user_factory = UserFactory
38
46
39
39
-
def setUp(self):
40
40
-
self.user = self.make_user(username="foo")
41
41
-
42
47
def test_get_edit_profile(self):
48
48
+
user = self.make_user(username="foo")
43
49
url_name = "users:edit"
44
50
self.assertLoginRequired(url_name)
45
45
-
with self.login(self.user):
51
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
56
+
user = self.make_user(username="foo")
50
57
url_name = "users:edit"
51
58
self.assertLoginRequired(url_name)
52
52
-
with self.login(self.user):
59
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
59
-
user = User.objects.get(pk=self.user.pk)
66
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)