def test_create_admin_user(self):
"""
Tests the creation of an OpenStack user.
"""
self.user_creator = OpenStackUser(self.os_creds, self.user_settings)
created_user = self.user_creator.create()
self.assertIsNotNone(created_user)
retrieved_user = keystone_utils.get_user(self.keystone,
self.user_settings.name)
self.assertIsNotNone(retrieved_user)
self.assertEqual(created_user, retrieved_user)
role = keystone_utils.get_role_by_name(self.keystone, 'admin')
if not role:
role = keystone_utils.get_role_by_name(self.keystone, 'Admin')
self.assertIsNotNone(role)
os_proj = keystone_utils.get_project(
keystone=self.keystone, project_name=self.os_creds.project_name)
user_roles = keystone_utils.get_roles_by_user(self.keystone,
retrieved_user, os_proj)
self.assertIsNotNone(user_roles)
self.assertEqual(1, len(user_roles))
self.assertEqual(role.id, user_roles[0].id)
def initialize(self):
"""
Creates the user in OpenStack if it does not already exist
:return: The User domain object
"""
super(self.__class__, self).initialize()
self.__user = keystone_utils.get_user(self._keystone,
self.user_settings.name)
return self.__user
def test_create_user(self):
"""
Tests the creation of an OpenStack user.
"""
self.user_creator = OpenStackUser(self.os_creds, self.user_settings)
created_user = self.user_creator.create()
self.assertIsNotNone(created_user)
retrieved_user = keystone_utils.get_user(self.keystone,
self.user_settings.name)
self.assertIsNotNone(retrieved_user)
self.assertEqual(created_user, retrieved_user)
def test_create_user_minimal(self):
"""
Tests the keystone_utils.create_user() function
"""
user_settings = UserConfig(name=self.username,
password=str(uuid.uuid4()),
domain_name=self.os_creds.user_domain_name)
self.user = keystone_utils.create_user(self.keystone, user_settings)
self.assertEqual(self.username, self.user.name)
user = keystone_utils.get_user(self.keystone, self.username)
self.assertIsNotNone(user)
self.assertEqual(self.user, user)
def __start__(self):
"""
Creates a project and user to be leveraged by subclass test methods. If
implementing class uses this method, it must call __clean__() else you
will be left with unwanted users and tenants
"""
self.project_creator = None
self.user_creator = None
self.admin_os_creds = self.os_creds
self.admin_os_session = self.os_session
self.keystone = keystone_utils.keystone_client(self.admin_os_creds,
self.admin_os_session)
if self.use_keystone:
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())[:-19]
project_name = guid + '-proj'
self.project_creator = deploy_utils.create_project(
self.admin_os_creds,
ProjectConfig(name=project_name,
domain=self.admin_os_creds.project_domain_name))
# Set by implementing class for setting the user's roles
roles = dict()
if self.user_roles and isinstance(self.user_roles, list):
for user_role in self.user_roles:
roles[user_role] = project_name
self.user_creator = deploy_utils.create_user(
self.admin_os_creds,
UserConfig(name=guid + '-user',
password=guid,
project_name=project_name,
roles=roles,
domain_name=self.admin_os_creds.user_domain_name))
self.os_creds = self.user_creator.get_os_creds(
self.project_creator.project_settings.name)
self.os_session = keystone_utils.keystone_session(self.os_creds)
# add user to project
self.project_creator.assoc_user(self.user_creator.get_user())
if self.proj_users and isinstance(self.proj_users, list):
for user_name in self.proj_users:
user = keystone_utils.get_user(self.keystone, user_name)
if user:
self.project_creator.assoc_user(user)
def test_create_user_2x(self):
"""
Tests the creation of an OpenStack user twice to ensure it only creates
one.
"""
self.user_creator = OpenStackUser(self.os_creds, self.user_settings)
created_user = self.user_creator.create()
self.assertIsNotNone(created_user)
retrieved_user = keystone_utils.get_user(self.keystone,
self.user_settings.name)
self.assertIsNotNone(retrieved_user)
self.assertEqual(created_user, retrieved_user)
# Create user for the second time to ensure it is the same
user2 = OpenStackUser(self.os_creds, self.user_settings).create()
self.assertEqual(retrieved_user, user2)
def create(self):
"""
Creates a Project/Tenant in OpenStack if it does not already exist
:return: The Project domain object
"""
self.initialize()
if not self.__project:
self.__project = keystone_utils.create_project(
self._keystone, self.project_settings)
for username in self.project_settings.users:
user = keystone_utils.get_user(self._keystone, username)
if user:
try:
self.assoc_user(user)
except Conflict as e:
logger.warn('Unable to associate user %s due to %s',
user.name, e)
if self.project_settings.quotas:
quota_dict = self.project_settings.quotas
nova = nova_utils.nova_client(self._os_creds, self._os_session)
quotas = nova_utils.get_compute_quotas(nova, self.__project.id)
if quotas:
if 'cores' in quota_dict:
quotas.cores = quota_dict['cores']
if 'instances' in quota_dict:
quotas.instances = quota_dict['instances']
if 'injected_files' in quota_dict:
quotas.injected_files = quota_dict['injected_files']
if 'injected_file_content_bytes' in quota_dict:
quotas.injected_file_content_bytes = \
quota_dict['injected_file_content_bytes']
if 'ram' in quota_dict:
quotas.ram = quota_dict['ram']
if 'fixed_ips' in quota_dict:
quotas.fixed_ips = quota_dict['fixed_ips']
if 'key_pairs' in quota_dict:
quotas.key_pairs = quota_dict['key_pairs']
nova_utils.update_quotas(nova, self.__project.id, quotas)
return self.__project