def setUp(self): """Sets up the client.""" reqs = Requirements(is_admin=True) instance_info.admin_user = CONFIG.users.find_user(reqs) instance_info.dbaas_admin = create_dbaas_client( instance_info.admin_user) global dbaas_admin dbaas_admin = instance_info.dbaas_admin # Make sure we create the client as the correct user if we're using # a pre-built instance. if existing_instance(): mgmt_inst = dbaas_admin.mgmt.instances.show(existing_instance()) t_id = mgmt_inst.tenant_id instance_info.user = CONFIG.users.find_user_by_tenant_id(t_id) else: reqs = Requirements(is_admin=False) instance_info.user = CONFIG.users.find_user(reqs) instance_info.dbaas = create_dbaas_client(instance_info.user) if CONFIG.white_box: instance_info.nova_client = create_nova_client(instance_info.user) instance_info.volume_client = create_nova_client( instance_info.user, service_type=CONFIG.nova_client['volume_service_type']) global dbaas dbaas = instance_info.dbaas if CONFIG.white_box: user = instance_info.user.auth_user tenant = instance_info.user.tenant instance_info.user_context = context.RequestContext(user, tenant)
def setUp(self): admin_req = Requirements(is_admin=True) self.admin_user = test_config.users.find_user(admin_req) self.admin_client = create_dbaas_client(self.admin_user) user_req = Requirements(is_admin=False) self.users = test_config.users.find_all_users_who_satisfy(user_req) self.user_tenant_ids = [user.tenant_id for user in self.users] self._create_instances_for_users()
def setUp(self): rd_user = test_config.users.find_user( Requirements(is_admin=False, services=["reddwarf"])) self.rd_client = create_dbaas_client(rd_user) if test_config.nova_client is not None: nova_user = test_config.users.find_user( Requirements(is_admin=False, services=["nova"])) self.nova_client = create_nova_client(nova_user)
def delete_all(): """Delete every single one.""" user = test_config.users.find_user(Requirements(is_admin=False)) dbaas = create_dbaas_client(user) instances = dbaas.instances.list() for instance in instances: instance.delete()
def setUp(self): self.instances = [] reqs = Requirements(is_admin=True) self.user = CONFIG.users.find_user( reqs, black_list=[]) self.client = create_dbaas_client(self.user) self.mgmt = self.client.management
def __init__(self, instance_id): self.instance_id = instance_id req_admin = Requirements(is_admin=True) self.user = util.test_config.users.find_user(req_admin) self.dbaas_admin = util.create_dbaas_client(self.user) self.instance = self.dbaas_admin.management.show(self.instance_id) self.instance_local_id = self.instance.server["local_id"]
def create_client(*args, **kwargs): """ Using the User Requirements as arguments, finds a user and grabs a new DBAAS client. """ reqs = Requirements(*args, **kwargs) user = test_config.users.find_user(reqs) return create_dbaas_client(user)
def login(): """ This super simple test just logs in. Its useful when running tests in a new environment to troubleshoot connection problems. """ reqs = Requirements(is_admin=False) user = test_config.users.find_user(reqs) dbaas = create_dbaas_client(user) dbaas.instances.list()
def mgmt_instance_get(): """ Tests the mgmt instances index method. """ reqs = Requirements(is_admin=True) user = CONFIG.users.find_user(reqs) client = create_dbaas_client(user) mgmt = client.management # Grab the info.id created by the main instance test which is stored in # a global. id = instance_info.id api_instance = mgmt.show(id) # Print out all fields for extra info if the test fails. for name in dir(api_instance): print(str(name) + "=" + str(getattr(api_instance, name))) with TypeCheck("instance", api_instance) as instance: instance.has_field('created', basestring) instance.has_field('deleted', bool) # If the instance hasn't been deleted, this should be false... but # lets avoid creating more ordering work. instance.has_field('deleted_at', (basestring, None)) instance.has_field('flavor', dict, flavor_check) instance.has_field('guest_status', dict, guest_status_check) instance.has_field('id', basestring) instance.has_field('links', list) instance.has_field('name', basestring) #instance.has_field('server_status', basestring) instance.has_field('status', basestring) instance.has_field('tenant_id', basestring) instance.has_field('updated', basestring) # Can be None if no volume is given on this instance. if CONFIG.reddwarf_volume_support: instance.has_field('volume', dict, volume_check) else: instance.has_field('volume', None) #TODO: Validate additional fields, assert no extra fields exist. with CollectionCheck("server", api_instance.server) as server: server.has_element("addresses", dict) server.has_element("deleted", bool) server.has_element("deleted_at", (basestring, None)) server.has_element("host", basestring) server.has_element("id", basestring) server.has_element("local_id", int) server.has_element("name", basestring) server.has_element("status", basestring) server.has_element("tenant_id", basestring) if (CONFIG.reddwarf_volume_support and CONFIG.reddwarf_main_instance_has_volume): with CollectionCheck("volume", api_instance.volume) as volume: volume.has_element("attachments", list) volume.has_element("availability_zone", basestring) volume.has_element("created_at", (basestring, None)) volume.has_element("id", basestring) volume.has_element("size", int) volume.has_element("status", basestring)
def setUp(): """Set up vars needed by this story.""" user = test_config.users.find_user(Requirements(is_admin=True)) global client client = create_dbaas_client(user) flavors = client.find_flavors_by_ram(ram=8192) assert_true(len(flavors) >= 1, "No flavor found!") flavor = flavors[0] global flavor_href flavor_href = client.find_flavor_self_href(flavor) global original_notification_count original_notification_count = out_of_instance_memory_nofication_count()
def test_all_non_admin_users_are_found(self): normals = set() for x in range(self.NUMBER_OF_USER_TESTS): user = self.users.find_user(Requirements(is_admin=False)) if user not in normals: normals.add(user) self.assertEqual(NUMBER_OF_NORMALS, len(normals)) normal_names = list(user.auth_user for user in normals) self.assertTrue("mike" in normal_names) self.assertTrue("tim" in normal_names) expected_test_count = self.NUMBER_OF_USER_TESTS / NUMBER_OF_NORMALS for user in normals: self.assertFalse(user.requirements.is_admin) self.assertEqual(expected_test_count, user.test_count)
def setUp(self): self.user = test_config.users.find_user(Requirements(is_admin=True)) self.client = create_dbaas_client(self.user) self.name = 'test_SERVER_ERROR' # Create an instance with a broken compute instance. self.response = self.client.instances.create(self.name, 1, {'size': 1}, []) poll_until(lambda: self.client.instances.get(self.response.id), lambda instance: instance.status == 'ERROR', time_out=10) self.instance = self.client.instances.get(self.response.id) print "Status: %s" % self.instance.status msg = "Instance did not drop to error after server prov failure." assert_equal(self.instance.status, "ERROR", msg)
def setUp(self): self.reqs = Requirements(is_admin=False) self.user = CONFIG.users.find_user(self.reqs) self.dbaas = create_dbaas_client(self.user) self.instance = self.dbaas.instances.create(name="qe_instance", flavor_id=1, volume={"size": 1}, databases=[{ "name": "firstdb", "character_set": "latin2", "collate": "latin2_general_ci" }])
def test_all_admin_users_are_found(self): admins = set() for x in range(self.NUMBER_OF_USER_TESTS): user = self.users.find_user(Requirements(is_admin=True)) if user not in admins: admins.add(user) self.assertEqual(NUMBER_OF_ADMINS, len(admins)) admin_names = list(user.auth_user for user in admins) self.assertTrue("admin" in admin_names) self.assertTrue("anne" in admin_names) self.assertTrue("dan" in admin_names) expected_test_count = self.NUMBER_OF_USER_TESTS / NUMBER_OF_ADMINS for user in admins: self.assertTrue(user.requirements.is_admin) self.assertEqual(expected_test_count, user.test_count)
def setUp(self): reqs = Requirements(is_admin=False) self.other_user = CONFIG.users.find_user( reqs, black_list=[instance_info.user.auth_user]) self.other_client = create_dbaas_client(self.other_user)
def set_up(self): reqs = Requirements(is_admin=True) self.user = test_config.users.find_user(reqs) self.dbaas = create_dbaas_client(self.user)
def set_up(self): """Create a ton of instances.""" reqs = Requirements(is_admin=False) self.user = test_config.users.find_user(reqs) self.dbaas = create_dbaas_client(self.user)
def setUp(self): """Create client for mgmt instance test.""" reqs = Requirements(is_admin=True) self.user = CONFIG.users.find_user(reqs) self.client = create_dbaas_client(self.user)
def setUp(self): """ Create the user and client for use in the subsequent tests.""" self.user = test_config.users.find_user(Requirements(is_admin=False)) self.dbaas = create_dbaas_client(self.user)
def setUp(self): self.user = test_config.users.find_user(Requirements(is_admin=True)) self.client = create_dbaas_client(self.user) self.host = None
def setUp(self): """Sets up the client.""" user = test_config.users.find_user(Requirements(is_admin=False)) self.client = create_dbaas_client(user)