-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathtest_users_service.py
177 lines (138 loc) · 6.68 KB
/
test_users_service.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
import unittest
from json import loads
from datetime import datetime, timedelta
import server.tests.utils as test_utils
import server.web.utils as web_utils
import server.services.demos as demo_service
import server.services.users as user_service
from server.exceptions import ResourceDoesNotExistException
def suite():
test_suite = unittest.TestSuite()
test_suite.addTest(CreateUserTestCase('test_user_create_success'))
test_suite.addTest(CreateUserTestCase('test_user_create_invalid_inputs'))
test_suite.addTest(UserLoginTestCase('test_user_login_success'))
test_suite.addTest(UserLoginTestCase('test_user_login_invalid_inputs'))
test_suite.addTest(UserLogoutTestCase('test_user_logout_success'))
test_suite.addTest(UserLogoutTestCase('test_user_logout_invalid_token'))
test_suite.addTest(TokenizeTestCase('test_tokenize_and_detokenize'))
return test_suite
###########################
# Unit Tests #
###########################
class CreateUserTestCase(unittest.TestCase):
"""Tests for `services/users.py - create_user()`."""
def setUp(self):
# Create demo
self.demo = demo_service.create_demo()
self.retailers = demo_service.get_demo_retailers(loads(self.demo).get('guid'))
def test_user_create_success(self):
"""With correct values, is a valid user returned?"""
# Create new user assigned to the first retailer
user = user_service.create_user(loads(self.demo).get('guid'),
loads(self.retailers)[0].get('id'))
# TODO: Update to use assertIsInstance(a,b)
# Check all expected object values are present
user_json = loads(user)
self.assertTrue(user_json.get('id'))
self.assertTrue(user_json.get('demoId'))
self.assertTrue(user_json.get('email'))
self.assertTrue(user_json.get('username'))
def test_user_create_invalid_inputs(self):
"""With invalid inputs, are correct errors thrown?"""
# Attempt to create user with invalid inputs
# Invalid demo guid
self.assertRaises(ResourceDoesNotExistException,
user_service.create_user,
'123321', loads(self.retailers)[0].get('id'))
# Invalid retailer id
self.assertRaises(ResourceDoesNotExistException,
user_service.create_user,
loads(self.demo).get('guid'), '123321')
def tearDown(self):
demo_service.delete_demo_by_guid(loads(self.demo).get('guid'))
class UserLoginTestCase(unittest.TestCase):
"""Tests for `services/users.py - login()`."""
def setUp(self):
# Create demo
self.demo = demo_service.create_demo()
def test_user_login_success(self):
"""With correct values, is a valid user logged in?"""
# Log in user
demo_json = loads(self.demo)
auth_data = user_service.login(demo_json.get('guid'),
demo_json.get('users')[0].get('id'))
# TODO: Update to use assertIsInstance(a,b)
# Check all expected object values are present
self.assertTrue(auth_data.get('loopback_token'))
self.assertTrue(auth_data.get('user'))
user_json = auth_data.get('user')
self.assertTrue(user_json.get('id'))
self.assertTrue(user_json.get('demoId'))
self.assertTrue(user_json.get('username'))
self.assertTrue(user_json.get('email'))
if user_json.get('roles'):
for role_json in user_json.get('roles'):
self.assertTrue(role_json.get('id'))
self.assertTrue(role_json.get('name'))
self.assertTrue(role_json.get('created'))
self.assertTrue(role_json.get('modified'))
def test_user_login_invalid_inputs(self):
"""With invalid inputs, are correct errors thrown?"""
demo_json = loads(self.demo)
self.assertRaises(ResourceDoesNotExistException,
user_service.login,
'123321', demo_json.get('users')[0].get('id'))
self.assertRaises(ResourceDoesNotExistException,
user_service.login,
demo_json.get('guid'), '123321')
def tearDown(self):
demo_service.delete_demo_by_guid(loads(self.demo).get('guid'))
class UserLogoutTestCase(unittest.TestCase):
"""Tests for `services/users.py - logout()`."""
def setUp(self):
# Create demo
self.demo = demo_service.create_demo()
demo_json = loads(self.demo)
demo_guid = demo_json.get('guid')
demo_user_id = demo_json.get('users')[0].get('id')
# Log in user
auth_data = user_service.login(demo_guid, demo_user_id)
self.loopback_token = auth_data.get('loopback_token')
def test_user_logout_success(self):
"""With correct values, is a valid user logged out?"""
self.assertTrue(user_service.logout(self.loopback_token) is None)
def test_user_logout_invalid_token(self):
"""With an invalid token, are correct errors thrown?"""
self.assertRaises(ResourceDoesNotExistException,
user_service.logout,
test_utils.get_bad_token())
def tearDown(self):
demo_service.delete_demo_by_guid(loads(self.demo).get('guid'))
class TokenizeTestCase(unittest.TestCase):
"""Tests for `services/users.py - get_token_for_user() and get_auth_from_token()`."""
def test_tokenize_and_detokenize(self):
"""Is auth data correctly tokenized and later detokenized?"""
# Create demo
demo = demo_service.create_demo()
demo_json = loads(demo)
demo_guid = demo_json.get('guid')
demo_user_id = demo_json.get('users')[0].get('id')
# Log in user and tokenize auth data
auth_data = user_service.login(demo_guid, demo_user_id)
auth_data['exp'] = datetime.utcnow() + timedelta(days=14)
token = web_utils.tokenize(auth_data)
# Detokenize auth data
decrypted_auth_data = web_utils.detokenize(token)
# Check that decrypted data is equivalent to auth data
self.assertTrue(auth_data.get('loopback_token') ==
decrypted_auth_data.get('loopback_token'))
self.assertTrue(auth_data.get('exp') ==
decrypted_auth_data.get('exp'))
self.assertTrue(auth_data.get('user').get('id') ==
decrypted_auth_data.get('user').get('id'))
self.assertTrue(auth_data.get('guid') ==
decrypted_auth_data.get('guid'))
# Destroy demo
demo_service.delete_demo_by_guid(demo_guid)
if __name__ == '__main__':
unittest.main()