def test_accept_invite(self):
email = rand_email()
invite = self.uk.invites.create_invite(to_email=email)
user = self.uk.users.create_user(email=rand_email(),
password=rand_str(14))
invite = self.uk.invites.accept_invite(user.id, invite.token_raw)
self.assertTrue(invite.accepted)
def test_refresh_session(self):
email, password = rand_email(), rand_str(14)
u = self.uk.users.create_user(email=email, password=password)
session1 = self.uk.users.login_user(email, password)
session2 = self.uk.users.refresh_session(session1.token)
self.assertTrue(hasattr(session2, 'token'))
self.assertTrue(hasattr(session2, 'expires_in_secs'))
def test_get_current_user(self):
email, password = rand_email(), rand_str(14)
u = self.uk.users.create_user(email=email, password=password)
session = self.uk.users.login_user(email, password)
user = self.uk.users.get_current_user(session.token)
self.assertEqual(user.id, u.id)
def test_custom_audit_log_invalid_actor(self):
# create a test user
email = rand_email()
user = self.uk.users.create_user(email=email, password=rand_str(14))
self.assertRaises(error.InvalidRequestError, self.uk.logs.log_event,
actor='NOT_A_VAlID_USER_ID', actor_ip='::1', actor_useragent='TestLogs',
actee=user.id, action='test.custom_audit_log', details='Testing custom audit logs')
def test_request_password_reset(self):
u = self.uk.users.create_user(email=rand_email(),
password=rand_str(14))
try:
self.uk.users.request_password_reset(u.email)
except Exception as e:
self.fail(e)
def test_create_user(self):
email = rand_email()
extras = {'score': 100}
user = self.uk.users.create_user(email=email,
password=rand_str(14),
extras=extras)
self.assertEqual(user.email, email.lower())
self.assertEqual(user.extras['score'], extras['score'])
def test_get_invite_by_token(self):
email = rand_email()
created_invite = self.uk.invites.create_invite(to_email=email)
token = created_invite.token_raw
fetched_invite = self.uk.invites.get_by_token(token)
self.assertIsNotNone(created_invite)
self.assertIsNotNone(fetched_invite)
self.assertEqual(fetched_invite.id, created_invite.id)
def test_get_invite(self):
email = rand_email()
extras = {'score': 200}
created_invite = self.uk.invites.create_invite(to_email=email,
extras=extras)
fetched_invite = self.uk.invites.get_invite(created_invite.id)
self.assertEqual(fetched_invite.id, created_invite.id)
self.assertEqual(fetched_invite.to_email, created_invite.to_email)
self.assertEqual(fetched_invite.extras['score'], extras['score'])
def test_create_invite(self):
email = rand_email()
# Include an ampersand to test that data is unescaped
extras = {'team': 'run&jump'}
invite = self.uk.invites.create_invite(to_email=email, extras=extras)
self.assertEqual(invite.to_email, email.lower())
self.assertTrue(hasattr(invite, 'token_raw'))
self.assertIsNotNone(invite.extras)
self.assertEqual(invite.extras['team'], extras['team'])
def test_update_user(self):
extras = {'score': 200}
u = self.uk.users.create_user(email=rand_email(),
password=rand_str(14),
name="Name",
extras=extras)
new_name = "Test Name {}".format(rand_str())
user = self.uk.users.update_user(u.id, name=new_name)
self.assertEqual(user.name, new_name)
self.assertEqual(user.extras['score'], extras['score'])
def test_save_user(self):
u = self.uk.users.create_user(email=rand_email(),
password=rand_str(14),
name="Name")
new_name = "Test Name {}".format(rand_str())
user = self.uk.users.get_user(u.id)
user.name = new_name
user.save()
self.assertEqual(user.name, new_name)
def test_disable_user(self):
u = self.uk.users.create_user(email=rand_email(),
password=rand_str(14))
# Test the disable_user() function
disabled = True
user = self.uk.users.disable_user(u.id, disabled)
self.assertEqual(user.disabled, disabled)
# Return to original value (and test the user.disable() method)
disabled = False
user.disable(disabled)
self.assertEqual(user.disabled, disabled)
def test_login_and_logout_user(self):
email, password = rand_email(), rand_str(14)
u = self.uk.users.create_user(email=email, password=password)
# Test login
session = self.uk.users.login_user(email, password)
self.assertTrue(hasattr(session, 'token'))
# Test logout
try:
self.uk.users.logout_user(session.token)
except Exception as e:
self.fail(e)
def test_get_invite_once_by_token(self):
email = rand_email()
created_invite = self.uk.invites.create_invite(to_email=email)
token = created_invite.token_raw
# Should fetch invite first time
fetched_invite = self.uk.invites.get_once(token)
self.assertIsNotNone(created_invite)
self.assertIsNotNone(fetched_invite)
self.assertEqual(fetched_invite.id, created_invite.id)
# Should fail second time for same invite
fetched_invite = self.uk.invites.get_once(token)
self.assertIsNone(fetched_invite)
def test_custom_audit_log(self):
# create a test user
email = rand_email()
user = self.uk.users.create_user(email=email, password=rand_str(14))
# create a test audit log
log = self.uk.logs.log_event(actor=user.id, actor_ip='::1', actor_useragent='TestLogs', actee=user.id,
action='test.custom_audit_log', details='Testing custom audit logs')
self.assertEqual(log.actor, user.id)
self.assertEqual(log.actor_ip, '::1')
self.assertEqual(log.actor_useragent, 'TestLogs')
self.assertEqual(log.actee, user.id)
self.assertEqual(log.action, 'test.custom_audit_log')
self.assertEqual(log.details, 'Testing custom audit logs')
def setUp(self):
super(TestUsers, self).setUp()
# Create a user for use with various tests
user_data = {
'email': rand_email(),
'password': rand_str(14),
'extras': {
'score': 100
},
}
body = widget_body('post', 'users', user_data)
resp = self.uk.widget.proxy(body)
self.user1 = resp.response_dict['data']['user']
self.user1_password = user_data['password']
self.user1_token = resp.response_dict['data']['session']['token']
self.user1_token_private = resp.token_private
def test_wprox_create_user(self):
user_data = {
'email': rand_email(),
'password': rand_str(14),
'extras': {
'score': 100
},
}
body = widget_body('post', 'users', user_data)
resp = self.uk.widget.proxy(body)
user = resp.response_dict['data']['user']
# Should create and return the new user
self.assertEqual(user['email'], user_data['email'].lower())
self.assertEqual(user['extras']['score'], user_data['extras']['score'])
# Should contain correct JSON string in resp.response
response_str = json.dumps(resp.response_dict)
self.assertEqual(resp.response, response_str)
def DISABLED_test_send_invite(self):
# TODO: re-enable after turning on send-invite endpoint again
email = rand_email()
invite = self.uk.invites.send_invite(to_email=email)
self.assertEqual(invite.to_email, email.lower())
def test_get_invite_once_bad_token(self):
email = rand_email()
created_invite = self.uk.invites.create_invite(to_email=email)
bad_token = created_invite.token_raw + 'bad'
fetched_invite = self.uk.invites.get_once(bad_token)
self.assertIsNone(fetched_invite)
def test_invite__str__method(self):
invite = self.uk.invites.create_invite(to_email=rand_email())
try:
s = invite.__str__()
except Exception as e:
self.fail('user.__str__() raises exception: %r' % e)
def test_get_user(self):
u = self.uk.users.create_user(email=rand_email(),
password=rand_str(14))
user = self.uk.users.get_user(u.id)
self.assertEqual(user.id, u.id)
