def test_base(self):
# Setup Test
user_key = AuthUserEntity(username="******").put()
user_id = get_resource_id_from_key(user_key)
login_key = AuthUserMethodEntity(key=AuthUserMethodEntity.generate_key(
user_key, 'basic', user_id),
auth_type='basic',
auth_key=user_id,
auth_data='hashed_password:salt',
user_key=user_key).put()
user_data = {
'id': user_id,
'login_key': user_id,
'login_type': 'basic',
'version': 1
}
access_token = access_tokens_api.create_access_token(user_data)
# Run Code To Test
result = access_tokens_api.get_user_and_login_from_access_token(
access_token)
# Check results
self.assertEquals(len(result), 2)
self.assertTrue(isinstance(result[0], AuthUser))
self.assertEquals(result[0].id, get_resource_id_from_key(user_key))
self.assertTrue(isinstance(result[1], AuthUserMethodEntity))
self.assertEquals(result[1].key, login_key)
def _populate_model(login_entity):
"""
"""
if not login_entity:
return None
login_model = AuthUserMethod()
login_model.id = get_resource_id_from_key(login_entity.key)
login_model.auth_type = login_entity.auth_type
login_model.auth_key = login_entity.auth_key
login_model.auth_data = login_entity.auth_data
login_model.user_resource_id = get_resource_id_from_key(login_entity.user_key)
# TODO: Eventually it's just resource_id
return login_model
def get_by_username(username, keys_only=False):
"""
Simply search for user by username
"""
e = AuthUserEntity.query().filter(AuthUserEntity.username == username).get(
keys_only=keys_only)
if keys_only:
if e:
return get_resource_id_from_key(e)
return None
return _populate_model(e)
def _populate_model(e):
"""
"""
if not e:
return None
model = AuthUser()
model.id = get_resource_id_from_key(e.key)
model.username = e.username
model.first_name = e.first_name
model.last_name = e.last_name
model.email = e.email
return model
def get_login_properties(user, auth_key=None, auth_data=None):
"""
:param user: Instance of user we're creating Login for
:param auth_key: Ignored
:param auth_data: raw_password
"""
# Take raw password and encrypt
auth_key = get_resource_id_from_key(user.key)
pwhash, pwsalt = encode_password(auth_data)
auth_data = "%s:%s" % (pwhash, pwsalt)
return 'basic', auth_key, auth_data
def make_token_user_data_dict(user, login, version=1):
"""
Create the user data dictionary for a user using v1 format
"""
if (version != 1):
raise Exception('Unsupported token version: %s ' % version)
data = {
TOKEN_KEYS_V1.VERSION: version,
TOKEN_KEYS_V1.USER_ID: get_resource_id_from_key(user.key),
TOKEN_KEYS_V1.LOGIN_TYPE: login.auth_type,
TOKEN_KEYS_V1.LOGIN_KEY: login.auth_key
}
return data
def test_invalid_password(self):
# Create a User
user_key = AuthUserEntity(username="******").put()
# Create a password
pwhash, pwsalt = basic.encode_password('jive')
user_id = get_resource_id_from_key(user_key)
AuthUserMethodEntity(key=AuthUserMethodEntity.generate_key(user_key, 'basic', user_id),
auth_type='basic',
auth_key=user_id,
auth_data="%s:%s" % (pwhash, pwsalt),
user_key=user_key).put()
# Create credential token
credential_token = base64.b64encode('testUser1:nojive')
self.assertRaises(AuthenticationError, basic.get_user_by_token, credential_token)
def test_invalid_login(self):
user_key = AuthUserEntity(username="******").put()
user_id = get_resource_id_from_key(user_key)
login_key = AuthUserMethodEntity(key=AuthUserMethodEntity.generate_key(
user_key, 'basic', user_id),
auth_type='basic',
auth_key=user_id,
auth_data='hashed_password:salt',
user_key=user_key).put()
user_data = {
'id': user_id,
'login_key': user_id,
'login_type': 'invalid_type',
'version': 1
}
access_token = access_tokens_api.create_access_token(user_data)
access_tokens_api.get_user_and_login_from_access_token(access_token)
def test_success(self):
# Create a User
user_key = AuthUserEntity(username="******").put()
# Create a password
pwhash, pwsalt = basic.encode_password('jive')
user_id = get_resource_id_from_key(user_key)
login_key = AuthUserMethodEntity(key=AuthUserMethodEntity.generate_key(user_key, 'basic', user_id),
auth_type='basic',
auth_key=user_id,
auth_data="%s:%s" % (pwhash, pwsalt),
user_key=user_key).put()
# Create credential token
credential_token = base64.b64encode('testUser1:jive')
user, login = basic.get_user_by_token(credential_token)
self.assertEquals(user_key, user.key)
self.assertEquals(login_key, login.key)
def test_base(self):
# Setup Test
user_key = AuthUserEntity(username="******").put()
user_id = get_resource_id_from_key(user_key)
login_key = AuthUserMethodEntity(key=AuthUserMethodEntity.generate_key(
user_key, 'basic', user_id),
auth_type='basic',
auth_key=user_id,
auth_data='hashed_password:salt',
user_key=user_key).put()
# Run Code to Test
result = access_tokens_api.make_token_user_data_dict(user_key.get(),
login_key.get(),
version=1)
# Check Results
self.assertDictEqual(
result, {
'login_type': u'basic',
'version': 1,
'login_key': user_id,
'id': user_id
})
def test_simple(self):
user_key = AuthUserEntity(username="******").put()
user_id = get_resource_id_from_key(user_key)
result = users_api.get_user_by_id(user_id)
self.assertTrue(isinstance(result, AuthUser))
except TypeError, e:
raise AuthenticationError(e)
try:
un, pw = decoded_token.split(':')
except ValueError, e:
raise AuthenticationError(e)
# TODO: Replace with internal.api.users.get_by_username
user = AuthUserEntity.query(AuthUserEntity.username == un).get()
if not user:
raise AuthenticationError('Username is invalid')
# TODO: Reduce this to an api method
l_key = AuthUserMethodEntity.generate_key(
user.key, 'basic', get_resource_id_from_key(user.key))
login = l_key.get()
if not login:
raise AuthenticationError("Could not find login for user")
pwhash, pwsalt = login.auth_data.split(":")
if not validate_password(pw, pwhash, pwsalt):
raise AuthenticationError('Password is invalid')
return user, login
def encode_password(raw_password):
"""
Encrypt a raw password using PBKDF2 with a random salt