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