def setUpClass(cls): cls.config = config.TempestConfig() cls.isolated_creds = [] if cls.config.compute.allow_tenant_isolation: creds = cls._get_isolated_creds() username, tenant_name, password = creds os = openstack.Manager(username=username, password=password, tenant_name=tenant_name) else: os = openstack.Manager() cls.os = os cls.volumes_client = os.volumes_client cls.servers_client = os.servers_client cls.image_ref = cls.config.compute.image_ref cls.flavor_ref = cls.config.compute.flavor_ref cls.build_interval = cls.config.volume.build_interval cls.build_timeout = cls.config.volume.build_timeout cls.volumes = {} skip_msg = ("%s skipped as Cinder endpoint is not available" % cls.__name__) try: cls.volumes_client.keystone_auth(cls.os.username, cls.os.password, cls.os.auth_url, cls.volumes_client.service, cls.os.tenant_name) except exceptions.EndpointNotFound: cls.clear_isolated_creds() raise nose.SkipTest(skip_msg)
def status_timeout(self, things, thing_id, expected_status): """ Given a thing and an expected status, do a loop, sleeping for a configurable amount of time, checking for the expected status to show. At any time, if the returned status of the thing is ERROR, fail out. """ def check_status(): # python-novaclient has resources available to its client # that all implement a get() method taking an identifier # for the singular resource to retrieve. thing = things.get(thing_id) new_status = thing.status if new_status == 'ERROR': self.fail("%s failed to get to expected status." "In ERROR state." % thing) elif new_status == expected_status: return True # All good. LOG.debug( "Waiting for %s to get to %s status. " "Currently in %s status", thing, expected_status, new_status) conf = config.TempestConfig() if not call_until_true(check_status, conf.compute.build_timeout, conf.compute.build_interval): self.fail("Timed out waiting for thing %s to become %s" % (thing_id, expected_status))
def __init__(self, interface='json'): conf = config.TempestConfig() base = super(ComputeAdminManager, self) base.__init__(conf.compute_admin.username, conf.compute_admin.password, conf.compute_admin.tenant_name, interface=interface)
class AuthTokenTestJSON(base.BaseV2ComputeTest): _interface = 'json' @classmethod def setUpClass(cls): super(AuthTokenTestJSON, cls).setUpClass() cls.servers_v2 = cls.os.servers_client cls.servers_v3 = cls.os.servers_client_v3_auth def test_v2_token(self): # Can get a token using v2 of the identity API and use that to perform # an operation on the compute service. # Doesn't matter which compute API is used, # picking list_servers because it's easy. self.servers_v2.list_servers() @testtools.skipIf(not config.TempestConfig().identity.uri_v3, 'v3 auth client not configured') def test_v3_token(self): # Can get a token using v3 of the identity API and use that to perform # an operation on the compute service. # Doesn't matter which compute API is used, # picking list_servers because it's easy. self.servers_v3.list_servers()
def setUpClass(cls): cls.config = config.TempestConfig() cls.isolated_creds = [] if cls.config.compute.allow_tenant_isolation: creds = cls._get_isolated_creds() username, tenant_name, password = creds os = openstack.Manager(username=username, password=password, tenant_name=tenant_name, interface=cls._interface) else: os = openstack.Manager(interface=cls._interface) cls.os = os cls.servers_client = os.servers_client cls.flavors_client = os.flavors_client cls.images_client = os.images_client cls.extensions_client = os.extensions_client cls.floating_ips_client = os.floating_ips_client cls.keypairs_client = os.keypairs_client cls.security_groups_client = os.security_groups_client cls.console_outputs_client = os.console_outputs_client cls.quotas_client = os.quotas_client cls.limits_client = os.limits_client cls.volumes_extensions_client = os.volumes_extensions_client cls.volumes_client = os.volumes_client cls.build_interval = cls.config.compute.build_interval cls.build_timeout = cls.config.compute.build_timeout cls.ssh_user = cls.config.compute.ssh_user cls.image_ref = cls.config.compute.image_ref cls.image_ref_alt = cls.config.compute.image_ref_alt cls.flavor_ref = cls.config.compute.flavor_ref cls.flavor_ref_alt = cls.config.compute.flavor_ref_alt cls.servers = []
def __init__(self, username=None, password=None, tenant_name=None, interface='json'): """ We allow overriding of the credentials used within the various client classes managed by the Manager object. Left as None, the standard username/password/tenant_name is used. :param username: Override of the username :param password: Override of the password :param tenant_name: Override of the tenant name """ self.config = config.TempestConfig() # If no creds are provided, we fall back on the defaults # in the config file for the Compute API. self.username = username or self.config.identity.username self.password = password or self.config.identity.password self.tenant_name = tenant_name or self.config.identity.tenant_name if None in (self.username, self.password, self.tenant_name): msg = ("Missing required credentials. " "username: %(u)s, password: %(p)s, " "tenant_name: %(t)s" % {'u': username, 'p': password, 't': tenant_name}) raise exceptions.InvalidConfiguration(msg) self.auth_url = self.config.identity.uri client_args = (self.config, self.username, self.password, self.auth_url, self.tenant_name) # common clients self.dynamodb_client = botoclients.APIClientDynamoDB(*client_args) self.magnetodb_client = MagnetoDBClientJSON(*client_args)
def __init__(self, interface='json'): conf = config.TempestConfig() base = super(OrchestrationManager, self) base.__init__(conf.identity.admin_username, conf.identity.admin_password, conf.identity.admin_tenant_name, interface=interface)
class BaseTestCase(testtools.TestCase, testtools.testcase.WithAttributes, testresources.ResourcedTestCase): config = config.TempestConfig() @classmethod def setUpClass(cls): if hasattr(super(BaseTestCase, cls), 'setUpClass'): super(BaseTestCase, cls).setUpClass()
class FixedIPsTestJson(FixedIPsBase): _interface = 'json' CONF = config.TempestConfig() @testtools.skipIf(CONF.network.quantum_available, "This feature is not" + "implemented by Quantum. See bug: #1194569") @attr(type='gate') def test_list_fixed_ip_details(self): resp, fixed_ip = self.client.get_fixed_ip_details(self.ip) self.assertEqual(fixed_ip['address'], self.ip) @attr(type=['negative', 'gate']) def test_list_fixed_ip_details_with_non_admin_user(self): self.assertRaises(exceptions.Unauthorized, self.non_admin_client.get_fixed_ip_details, self.ip) @attr(type='gate') def test_set_reserve(self): body = {"reserve": "None"} resp, body = self.client.reserve_fixed_ip(self.ip, body) self.assertEqual(resp.status, 202) @attr(type='gate') def test_set_unreserve(self): body = {"unreserve": "None"} resp, body = self.client.reserve_fixed_ip(self.ip, body) self.assertEqual(resp.status, 202) @attr(type=['negative', 'gate']) def test_set_reserve_with_non_admin_user(self): body = {"reserve": "None"} self.assertRaises(exceptions.Unauthorized, self.non_admin_client.reserve_fixed_ip, self.ip, body) @attr(type=['negative', 'gate']) def test_set_unreserve_with_non_admin_user(self): body = {"unreserve": "None"} self.assertRaises(exceptions.Unauthorized, self.non_admin_client.reserve_fixed_ip, self.ip, body) @attr(type=['negative', 'gate']) def test_set_reserve_with_invalid_ip(self): # NOTE(maurosr): since this exercises the same code snippet, we do it # only for reserve action body = {"reserve": "None"} self.assertRaises(exceptions.NotFound, self.client.reserve_fixed_ip, "my.invalid.ip", body) @attr(type=['negative', 'gate']) def test_fixed_ip_with_invalid_action(self): body = {"invalid_action": "None"} self.assertRaises(exceptions.BadRequest, self.client.reserve_fixed_ip, self.ip, body)
def __init__(self, name, tempest_client=True, interface='json', password='******'): self.isolated_creds = {} self.name = name self.config = config.TempestConfig() self.tempest_client = tempest_client self.interface = interface self.password = password self.admin_client = self._get_identity_admin_client()
def setUpClass(cls): cls.config = config.TempestConfig() cls.admin_username = cls.config.compute_admin.username cls.admin_password = cls.config.compute_admin.password cls.admin_tenant = cls.config.compute_admin.tenant_name if not cls.admin_username and cls.admin_password and cls.admin_tenant: msg = ("Missing Compute Admin API credentials " "in configuration.") raise nose.SkipTest(msg) cls.os = openstack.AdminManager(interface=cls._interface)
def __init__(self, username=None, password=None, tenant_name=None, interface='json'): """ We allow overriding of the credentials used within the various client classes managed by the Manager object. Left as None, the standard username/password/tenant_name is used. :param username: Override of the username :param password: Override of the password :param tenant_name: Override of the tenant name """ self.config = config.TempestConfig() # If no creds are provided, we fall back on the defaults # in the config file for the Compute API. self.username = username or self.config.compute.username self.password = password or self.config.compute.password self.tenant_name = tenant_name or self.config.compute.tenant_name if None in (self.username, self.password, self.tenant_name): msg = ("Missing required credentials. " "username: %(username)s, password: %(password)s, " "tenant_name: %(tenant_name)s") % locals() raise exceptions.InvalidConfiguration(msg) self.auth_url = self.config.identity.auth_url if self.config.identity.strategy == 'keystone': client_args = (self.config, self.username, self.password, self.auth_url, self.tenant_name) else: client_args = (self.config, self.username, self.password, self.auth_url) try: self.servers_client = SERVERS_CLIENTS[interface](*client_args) self.limits_client = LIMITS_CLIENTS[interface](*client_args) self.keypairs_client = KEYPAIRS_CLIENTS[interface](*client_args) self.flavors_client = FLAVORS_CLIENTS[interface](*client_args) self.extensions_client = \ EXTENSIONS_CLIENTS[interface](*client_args) self.volumes_extensions_client = \ VOLUMES_EXTENSIONS_CLIENTS[interface](*client_args) except KeyError: msg = "Unsupported interface type `%s'" % interface raise exceptions.InvalidConfiguration(msg) self.images_client = ImagesClient(*client_args) self.security_groups_client = SecurityGroupsClient(*client_args) self.floating_ips_client = FloatingIPsClient(*client_args) self.console_outputs_client = ConsoleOutputsClient(*client_args) self.network_client = NetworkClient(*client_args) self.volumes_client = VolumesClient(*client_args)
def __init__(self, name, tempest_client=True, interface='json', password='******'): self.isolated_creds = {} self.isolated_net_resources = {} self.ports = [] self.name = name self.config = config.TempestConfig() self.tempest_client = tempest_client self.interface = interface self.password = password self.identity_admin_client, self.network_admin_client = ( self._get_admin_clients())
def log_ip_ns(): if not config.TempestConfig().debug.enable: return LOG.info("Host Addr:\n" + commands.ip_addr_raw()) LOG.info("Host Route:\n" + commands.ip_route_raw()) for table in ['filter', 'nat', 'mangle']: LOG.info('Host %s table:\n%s', table, commands.iptables_raw(table)) ns_list = commands.ip_ns_list() LOG.info("Host ns list" + str(ns_list)) for ns in ns_list: LOG.info("ns(%s) Addr:\n%s", ns, commands.ip_ns_addr(ns)) LOG.info("ns(%s) Route:\n%s", ns, commands.ip_ns_route(ns)) for table in ['filter', 'nat', 'mangle']: LOG.info('ns(%s) table(%s):\n%s', ns, table, commands.iptables_ns(ns, table))
def __init__(self, username=None, password=None, tenant_name=None): """ We allow overriding of the credentials used within the various client classes managed by the Manager object. Left as None, the standard username/password/tenant_name is used. :param username: Override of the username :param password: Override of the password :param tenant_name: Override of the tenant name """ self.config = config.TempestConfig() # If no creds are provided, we fall back on the defaults # in the config file for the Compute API. username = username or self.config.compute.username password = password or self.config.compute.password tenant_name = tenant_name or self.config.compute.tenant_name if None in (username, password, tenant_name): msg = ("Missing required credentials. " "username: %(username)s, password: %(password)s, " "tenant_name: %(tenant_name)s") % locals() raise exceptions.InvalidConfiguration(msg) auth_url = self.config.identity.auth_url if self.config.identity.strategy == 'keystone': client_args = (self.config, username, password, auth_url, tenant_name) else: client_args = (self.config, username, password, auth_url) self.servers_client = ServersClient(*client_args) self.flavors_client = FlavorsClient(*client_args) self.images_client = ImagesClient(*client_args) self.limits_client = LimitsClient(*client_args) self.extensions_client = ExtensionsClient(*client_args) self.keypairs_client = KeyPairsClient(*client_args) self.security_groups_client = SecurityGroupsClient(*client_args) self.floating_ips_client = FloatingIPsClient(*client_args) self.volumes_client = VolumesClient(*client_args) self.console_outputs_client = ConsoleOutputsClient(*client_args) self.network_client = NetworkClient(*client_args)
class BaseTestCase(testtools.TestCase, testtools.testcase.WithAttributes, testresources.ResourcedTestCase): config = config.TempestConfig() @classmethod def setUpClass(cls): if hasattr(super(BaseTestCase, cls), 'setUpClass'): super(BaseTestCase, cls).setUpClass() def setUp(cls): super(BaseTestCase, cls).setUp() test_timeout = os.environ.get('OS_TEST_TIMEOUT', 0) try: test_timeout = int(test_timeout) except ValueError: test_timeout = 0 if test_timeout > 0: cls.useFixture(fixtures.Timeout(test_timeout, gentle=True)) if (os.environ.get('OS_STDOUT_CAPTURE') == 'True' or os.environ.get('OS_STDOUT_CAPTURE') == '1'): stdout = cls.useFixture(fixtures.StringStream('stdout')).stream cls.useFixture(fixtures.MonkeyPatch('sys.stdout', stdout)) if (os.environ.get('OS_STDERR_CAPTURE') == 'True' or os.environ.get('OS_STDERR_CAPTURE') == '1'): stderr = cls.useFixture(fixtures.StringStream('stderr')).stream cls.useFixture(fixtures.MonkeyPatch('sys.stderr', stderr)) @classmethod def _get_identity_admin_client(cls): """ Returns an instance of the Identity Admin API client """ os = clients.AdminManager(interface=cls._interface) admin_client = os.identity_client return admin_client @classmethod def _get_client_args(cls): return (cls.config, cls.config.identity.admin_username, cls.config.identity.admin_password, cls.config.identity.uri)
class VirtualInterfacesTestJSON(base.BaseComputeTest): _interface = 'json' CONF = config.TempestConfig() @classmethod def setUpClass(cls): super(VirtualInterfacesTestJSON, cls).setUpClass() cls.client = cls.servers_client resp, server = cls.create_server(wait_until='ACTIVE') cls.server_id = server['id'] @testtools.skipIf(CONF.service_available.neutron, "This feature is not " + "implemented by Neutron. See bug: #1183436") @attr(type='gate') def test_list_virtual_interfaces(self): # Positive test:Should be able to GET the virtual interfaces list # for a given server_id resp, output = self.client.list_virtual_interfaces(self.server_id) self.assertEqual(200, resp.status) self.assertNotEqual(output, None) virt_ifaces = output self.assertNotEqual(0, len(virt_ifaces['virtual_interfaces']), 'Expected virtual interfaces, got 0 interfaces.') for virt_iface in virt_ifaces['virtual_interfaces']: mac_address = virt_iface['mac_address'] self.assertTrue(netaddr.valid_mac(mac_address), "Invalid mac address detected.") @attr(type=['negative', 'gate']) def test_list_virtual_interfaces_invalid_server_id(self): # Negative test: Should not be able to GET virtual interfaces # for an invalid server_id invalid_server_id = rand_name('!@#$%^&*()') self.assertRaises(exceptions.NotFound, self.client.list_virtual_interfaces, invalid_server_id)
class SecurityGroupsTestJSON(base.BaseComputeTest): _interface = 'json' @classmethod def setUpClass(cls): super(SecurityGroupsTestJSON, cls).setUpClass() cls.client = cls.security_groups_client def _delete_security_group(self, securitygroup_id): resp, _ = self.client.delete_security_group(securitygroup_id) self.assertEqual(202, resp.status) @attr(type='gate') def test_security_groups_create_list_delete(self): # Positive test:Should return the list of Security Groups # Create 3 Security Groups security_group_list = list() for i in range(3): s_name = rand_name('securitygroup-') s_description = rand_name('description-') resp, securitygroup = \ self.client.create_security_group(s_name, s_description) self.assertEqual(200, resp.status) self.addCleanup(self._delete_security_group, securitygroup['id']) security_group_list.append(securitygroup) # Fetch all Security Groups and verify the list # has all created Security Groups resp, fetched_list = self.client.list_security_groups() self.assertEqual(200, resp.status) # Now check if all the created Security Groups are in fetched list missing_sgs = \ [sg for sg in security_group_list if sg not in fetched_list] self.assertFalse( missing_sgs, "Failed to find Security Group %s in fetched " "list" % ', '.join(m_group['name'] for m_group in missing_sgs)) # TODO(afazekas): scheduled for delete, # test_security_group_create_get_delete covers it @attr(type='gate') def test_security_group_create_delete(self): # Security Group should be created, verified and deleted s_name = rand_name('securitygroup-') s_description = rand_name('description-') resp, securitygroup = \ self.client.create_security_group(s_name, s_description) self.assertIn('id', securitygroup) securitygroup_id = securitygroup['id'] self.addCleanup(self._delete_security_group, securitygroup_id) self.assertEqual(200, resp.status) self.assertFalse(securitygroup_id is None) self.assertIn('name', securitygroup) securitygroup_name = securitygroup['name'] self.assertEqual( securitygroup_name, s_name, "The created Security Group name is " "not equal to the requested name") @attr(type='gate') def test_security_group_create_get_delete(self): # Security Group should be created, fetched and deleted s_name = rand_name('securitygroup-') s_description = rand_name('description-') resp, securitygroup = \ self.client.create_security_group(s_name, s_description) self.addCleanup(self._delete_security_group, securitygroup['id']) self.assertEqual(200, resp.status) self.assertIn('name', securitygroup) securitygroup_name = securitygroup['name'] self.assertEqual( securitygroup_name, s_name, "The created Security Group name is " "not equal to the requested name") # Now fetch the created Security Group by its 'id' resp, fetched_group = \ self.client.get_security_group(securitygroup['id']) self.assertEqual(200, resp.status) self.assertEqual( securitygroup, fetched_group, "The fetched Security Group is different " "from the created Group") @attr(type=['negative', 'gate']) def test_security_group_get_nonexistant_group(self): # Negative test:Should not be able to GET the details # of nonexistant Security Group security_group_id = [] resp, body = self.client.list_security_groups() for i in range(len(body)): security_group_id.append(body[i]['id']) # Creating a nonexistant Security Group id while True: non_exist_id = rand_name('999') if non_exist_id not in security_group_id: break self.assertRaises(exceptions.NotFound, self.client.get_security_group, non_exist_id) @attr(type=['negative', 'gate']) def test_security_group_create_with_invalid_group_name(self): # Negative test: Security Group should not be created with group name # as an empty string/with white spaces/chars more than 255 s_description = rand_name('description-') # Create Security Group with empty string as group name self.assertRaises(exceptions.BadRequest, self.client.create_security_group, "", s_description) # Create Security Group with white space in group name self.assertRaises(exceptions.BadRequest, self.client.create_security_group, " ", s_description) # Create Security Group with group name longer than 255 chars s_name = 'securitygroup-'.ljust(260, '0') self.assertRaises(exceptions.BadRequest, self.client.create_security_group, s_name, s_description) @attr(type=['negative', 'gate']) def test_security_group_create_with_invalid_group_description(self): # Negative test:Security Group should not be created with description # as an empty string/with white spaces/chars more than 255 s_name = rand_name('securitygroup-') # Create Security Group with empty string as description self.assertRaises(exceptions.BadRequest, self.client.create_security_group, s_name, "") # Create Security Group with white space in description self.assertRaises(exceptions.BadRequest, self.client.create_security_group, s_name, " ") # Create Security Group with group description longer than 255 chars s_description = 'description-'.ljust(260, '0') self.assertRaises(exceptions.BadRequest, self.client.create_security_group, s_name, s_description) @testtools.skipIf(config.TempestConfig().service_available.neutron, "Neutron allows duplicate names for security groups") @attr(type=['negative', 'gate']) def test_security_group_create_with_duplicate_name(self): # Negative test:Security Group with duplicate name should not # be created s_name = rand_name('securitygroup-') s_description = rand_name('description-') resp, security_group =\ self.client.create_security_group(s_name, s_description) self.assertEqual(200, resp.status) self.addCleanup(self.client.delete_security_group, security_group['id']) # Now try the Security Group with the same 'Name' self.assertRaises(exceptions.BadRequest, self.client.create_security_group, s_name, s_description) @attr(type=['negative', 'gate']) def test_delete_the_default_security_group(self): # Negative test:Deletion of the "default" Security Group should Fail default_security_group_id = None resp, body = self.client.list_security_groups() for i in range(len(body)): if body[i]['name'] == 'default': default_security_group_id = body[i]['id'] break # Deleting the "default" Security Group self.assertRaises(exceptions.BadRequest, self.client.delete_security_group, default_security_group_id) @attr(type=['negative', 'gate']) def test_delete_nonexistant_security_group(self): # Negative test:Deletion of a nonexistant Security Group should Fail security_group_id = [] resp, body = self.client.list_security_groups() for i in range(len(body)): security_group_id.append(body[i]['id']) # Creating Non Existant Security Group while True: non_exist_id = rand_name('999') if non_exist_id not in security_group_id: break self.assertRaises(exceptions.NotFound, self.client.delete_security_group, non_exist_id) @attr(type=['negative', 'gate']) def test_delete_security_group_without_passing_id(self): # Negative test:Deletion of a Security Group with out passing ID # should Fail self.assertRaises(exceptions.NotFound, self.client.delete_security_group, '') @attr(type='gate') def test_server_security_groups(self): # Checks that security groups may be added and linked to a server # and not deleted if the server is active. # Create a couple security groups that we will use # for the server resource this test creates sg_name = rand_name('sg') sg_desc = rand_name('sg-desc') resp, sg = self.client.create_security_group(sg_name, sg_desc) sg_id = sg['id'] sg2_name = rand_name('sg') sg2_desc = rand_name('sg-desc') resp, sg2 = self.client.create_security_group(sg2_name, sg2_desc) sg2_id = sg2['id'] # Create server and add the security group created # above to the server we just created server_name = rand_name('server') resp, server = self.servers_client.create_server( server_name, self.image_ref, self.flavor_ref) server_id = server['id'] self.servers_client.wait_for_server_status(server_id, 'ACTIVE') resp, body = self.servers_client.add_security_group(server_id, sg_name) # Check that we are not able to delete the security # group since it is in use by an active server self.assertRaises(exceptions.BadRequest, self.client.delete_security_group, sg_id) # Reboot and add the other security group resp, body = self.servers_client.reboot(server_id, 'HARD') self.servers_client.wait_for_server_status(server_id, 'ACTIVE') resp, body = self.servers_client.add_security_group( server_id, sg2_name) # Check that we are not able to delete the other security # group since it is in use by an active server self.assertRaises(exceptions.BadRequest, self.client.delete_security_group, sg2_id) # Shutdown the server and then verify we can destroy the # security groups, since no active server instance is using them self.servers_client.delete_server(server_id) self.servers_client.wait_for_server_termination(server_id) self.client.delete_security_group(sg_id) self.assertEqual(202, resp.status) self.client.delete_security_group(sg2_id) self.assertEqual(202, resp.status)
class ContainerQuotasTest(base.BaseObjectTest): """Attemps to test the perfect behavior of quotas in a container.""" container_quotas_available = \ config.TempestConfig().object_storage.container_quotas_available def setUp(self): """Creates and sets a container with quotas. Quotas are set by adding meta values to the container, and are validated when set: - X-Container-Meta-Quota-Bytes: Maximum size of the container, in bytes. - X-Container-Meta-Quota-Count: Maximum object count of the container. """ super(ContainerQuotasTest, self).setUp() self.container_name = rand_name(name="TestContainer") self.container_client.create_container(self.container_name) metadata = { "quota-bytes": str(QUOTA_BYTES), "quota-count": str(QUOTA_COUNT), } self.container_client.update_container_metadata( self.container_name, metadata) def tearDown(self): """Cleans the container of any object after each test.""" self.delete_containers([self.container_name]) super(ContainerQuotasTest, self).tearDown() @testtools.skipIf(not container_quotas_available, SKIP_MSG) @attr(type="smoke") def test_upload_valid_object(self): """Attempts to uploads an object smaller than the bytes quota.""" object_name = rand_name(name="TestObject") data = arbitrary_string(QUOTA_BYTES) nbefore = self._get_bytes_used() resp, _ = self.object_client.create_object(self.container_name, object_name, data) self.assertIn(int(resp['status']), HTTP_SUCCESS) nafter = self._get_bytes_used() self.assertEqual(nbefore + len(data), nafter) @testtools.skipIf(not container_quotas_available, SKIP_MSG) @attr(type="smoke") def test_upload_large_object(self): """Attempts to upload an object lagger than the bytes quota.""" object_name = rand_name(name="TestObject") data = arbitrary_string(QUOTA_BYTES + 1) nbefore = self._get_bytes_used() self.assertRaises(exceptions.OverLimit, self.object_client.create_object, self.container_name, object_name, data) nafter = self._get_bytes_used() self.assertEqual(nbefore, nafter) @testtools.skipIf(not container_quotas_available, SKIP_MSG) @attr(type="smoke") def test_upload_too_many_objects(self): """Attempts to upload many objects that exceeds the count limit.""" for _ in range(QUOTA_COUNT): name = rand_name(name="TestObject") self.object_client.create_object(self.container_name, name, "") nbefore = self._get_object_count() self.assertEqual(nbefore, QUOTA_COUNT) self.assertRaises(exceptions.OverLimit, self.object_client.create_object, self.container_name, "OverQuotaObject", "") nafter = self._get_object_count() self.assertEqual(nbefore, nafter) def _get_container_metadata(self): resp, _ = self.container_client.list_container_metadata( self.container_name) return resp def _get_object_count(self): resp = self._get_container_metadata() return int(resp["x-container-object-count"]) def _get_bytes_used(self): resp = self._get_container_metadata() return int(resp["x-container-bytes-used"])
def __init__(self): conf = config.TempestConfig() super(AltManager, self).__init__(conf.identity.alt_username, conf.identity.alt_password, conf.identity.alt_tenant_name)
def __init__(self, interface='json'): conf = config.TempestConfig() super(AdminManager, self).__init__(conf.identity.admin_username, conf.identity.admin_password, conf.identity.admin_tenant_name, interface=interface)
class SecurityGroupRulesTestJSON(base.BaseComputeTest): _interface = 'json' @classmethod def setUpClass(cls): super(SecurityGroupRulesTestJSON, cls).setUpClass() cls.client = cls.security_groups_client @attr(type='gate') def test_security_group_rules_create(self): # Positive test: Creation of Security Group rule # should be successfull # Creating a Security Group to add rules to it s_name = rand_name('securitygroup-') s_description = rand_name('description-') resp, securitygroup = \ self.client.create_security_group(s_name, s_description) securitygroup_id = securitygroup['id'] self.addCleanup(self.client.delete_security_group, securitygroup_id) # Adding rules to the created Security Group ip_protocol = 'tcp' from_port = 22 to_port = 22 resp, rule = \ self.client.create_security_group_rule(securitygroup_id, ip_protocol, from_port, to_port) self.addCleanup(self.client.delete_security_group_rule, rule['id']) self.assertEqual(200, resp.status) @attr(type='gate') def test_security_group_rules_create_with_optional_arguments(self): # Positive test: Creation of Security Group rule # with optional arguments # should be successfull secgroup1 = None secgroup2 = None # Creating a Security Group to add rules to it s_name = rand_name('securitygroup-') s_description = rand_name('description-') resp, securitygroup = \ self.client.create_security_group(s_name, s_description) secgroup1 = securitygroup['id'] self.addCleanup(self.client.delete_security_group, secgroup1) # Creating a Security Group so as to assign group_id to the rule s_name2 = rand_name('securitygroup-') s_description2 = rand_name('description-') resp, securitygroup = \ self.client.create_security_group(s_name2, s_description2) secgroup2 = securitygroup['id'] self.addCleanup(self.client.delete_security_group, secgroup2) # Adding rules to the created Security Group with optional arguments parent_group_id = secgroup1 ip_protocol = 'tcp' from_port = 22 to_port = 22 cidr = '10.2.3.124/24' group_id = secgroup2 resp, rule = \ self.client.create_security_group_rule(parent_group_id, ip_protocol, from_port, to_port, cidr=cidr, group_id=group_id) self.addCleanup(self.client.delete_security_group_rule, rule['id']) self.assertEqual(200, resp.status) @testtools.skipIf(config.TempestConfig().service_available.neutron, "Skipped until the Bug #1182384 is resolved") @attr(type=['negative', 'gate']) def test_security_group_rules_create_with_invalid_id(self): # Negative test: Creation of Security Group rule should FAIL # with invalid Parent group id # Adding rules to the invalid Security Group id parent_group_id = rand_name('999') ip_protocol = 'tcp' from_port = 22 to_port = 22 self.assertRaises(exceptions.NotFound, self.client.create_security_group_rule, parent_group_id, ip_protocol, from_port, to_port) @attr(type=['negative', 'gate']) def test_security_group_rules_create_with_invalid_ip_protocol(self): # Negative test: Creation of Security Group rule should FAIL # with invalid ip_protocol # Creating a Security Group to add rule to it s_name = rand_name('securitygroup-') s_description = rand_name('description-') resp, securitygroup = self.client.create_security_group( s_name, s_description) # Adding rules to the created Security Group parent_group_id = securitygroup['id'] ip_protocol = rand_name('999') from_port = 22 to_port = 22 self.addCleanup(self.client.delete_security_group, securitygroup['id']) self.assertRaises(exceptions.BadRequest, self.client.create_security_group_rule, parent_group_id, ip_protocol, from_port, to_port) @attr(type=['negative', 'gate']) def test_security_group_rules_create_with_invalid_from_port(self): # Negative test: Creation of Security Group rule should FAIL # with invalid from_port # Creating a Security Group to add rule to it s_name = rand_name('securitygroup-') s_description = rand_name('description-') resp, securitygroup = self.client.create_security_group( s_name, s_description) # Adding rules to the created Security Group parent_group_id = securitygroup['id'] ip_protocol = 'tcp' from_port = rand_name('999') to_port = 22 self.addCleanup(self.client.delete_security_group, securitygroup['id']) self.assertRaises(exceptions.BadRequest, self.client.create_security_group_rule, parent_group_id, ip_protocol, from_port, to_port) @attr(type=['negative', 'gate']) def test_security_group_rules_create_with_invalid_to_port(self): # Negative test: Creation of Security Group rule should FAIL # with invalid from_port # Creating a Security Group to add rule to it s_name = rand_name('securitygroup-') s_description = rand_name('description-') resp, securitygroup = self.client.create_security_group( s_name, s_description) # Adding rules to the created Security Group parent_group_id = securitygroup['id'] ip_protocol = 'tcp' from_port = 22 to_port = rand_name('999') self.addCleanup(self.client.delete_security_group, securitygroup['id']) self.assertRaises(exceptions.BadRequest, self.client.create_security_group_rule, parent_group_id, ip_protocol, from_port, to_port) @attr(type=['negative', 'gate']) def test_security_group_rules_create_with_invalid_port_range(self): # Negative test: Creation of Security Group rule should FAIL # with invalid port range. # Creating a Security Group to add rule to it. s_name = rand_name('securitygroup-') s_description = rand_name('description-') resp, securitygroup = self.client.create_security_group( s_name, s_description) # Adding a rule to the created Security Group secgroup_id = securitygroup['id'] ip_protocol = 'tcp' from_port = 22 to_port = 21 self.addCleanup(self.client.delete_security_group, securitygroup['id']) self.assertRaises(exceptions.BadRequest, self.client.create_security_group_rule, secgroup_id, ip_protocol, from_port, to_port) @testtools.skipIf(config.TempestConfig().service_available.neutron, "Skipped until the Bug #1182384 is resolved") @attr(type=['negative', 'gate']) def test_security_group_rules_delete_with_invalid_id(self): # Negative test: Deletion of Security Group rule should be FAIL # with invalid rule id self.assertRaises(exceptions.NotFound, self.client.delete_security_group_rule, rand_name('999')) @attr(type='gate') def test_security_group_rules_list(self): # Positive test: Created Security Group rules should be # in the list of all rules # Creating a Security Group to add rules to it s_name = rand_name('securitygroup-') s_description = rand_name('description-') resp, securitygroup = \ self.client.create_security_group(s_name, s_description) securitygroup_id = securitygroup['id'] # Delete the Security Group at the end of this method self.addCleanup(self.client.delete_security_group, securitygroup_id) # Add a first rule to the created Security Group ip_protocol1 = 'tcp' from_port1 = 22 to_port1 = 22 resp, rule = \ self.client.create_security_group_rule(securitygroup_id, ip_protocol1, from_port1, to_port1) rule1_id = rule['id'] # Delete the Security Group rule1 at the end of this method self.addCleanup(self.client.delete_security_group_rule, rule1_id) # Add a second rule to the created Security Group ip_protocol2 = 'icmp' from_port2 = -1 to_port2 = -1 resp, rule = \ self.client.create_security_group_rule(securitygroup_id, ip_protocol2, from_port2, to_port2) rule2_id = rule['id'] # Delete the Security Group rule2 at the end of this method self.addCleanup(self.client.delete_security_group_rule, rule2_id) # Get rules of the created Security Group resp, rules = \ self.client.list_security_group_rules(securitygroup_id) self.assertTrue(any([i for i in rules if i['id'] == rule1_id])) self.assertTrue(any([i for i in rules if i['id'] == rule2_id]))
def __init__(self, username=None, password=None, tenant_name=None, interface='json'): """ We allow overriding of the credentials used within the various client classes managed by the Manager object. Left as None, the standard username/password/tenant_name is used. :param username: Override of the username :param password: Override of the password :param tenant_name: Override of the tenant name """ self.config = config.TempestConfig() # If no creds are provided, we fall back on the defaults # in the config file for the Compute API. self.username = username or self.config.identity.username self.password = password or self.config.identity.password self.tenant_name = tenant_name or self.config.identity.tenant_name if None in (self.username, self.password, self.tenant_name): msg = ("Missing required credentials. " "username: %(username)s, password: %(password)s, " "tenant_name: %(tenant_name)s") % locals() raise exceptions.InvalidConfiguration(msg) self.auth_url = self.config.identity.uri self.auth_url_v3 = self.config.identity.uri_v3 if self.config.identity.strategy == 'keystone': client_args = (self.config, self.username, self.password, self.auth_url, self.tenant_name) if self.auth_url_v3: auth_version = 'v3' client_args_v3_auth = (self.config, self.username, self.password, self.auth_url_v3, self.tenant_name, auth_version) else: client_args_v3_auth = None else: client_args = (self.config, self.username, self.password, self.auth_url) client_args_v3_auth = None try: self.servers_client = SERVERS_CLIENTS[interface](*client_args) self.limits_client = LIMITS_CLIENTS[interface](*client_args) self.images_client = IMAGES_CLIENTS[interface](*client_args) self.keypairs_client = KEYPAIRS_CLIENTS[interface](*client_args) self.quotas_client = QUOTAS_CLIENTS[interface](*client_args) self.flavors_client = FLAVORS_CLIENTS[interface](*client_args) ext_cli = EXTENSIONS_CLIENTS[interface](*client_args) self.extensions_client = ext_cli vol_ext_cli = VOLUMES_EXTENSIONS_CLIENTS[interface](*client_args) self.volumes_extensions_client = vol_ext_cli self.floating_ips_client = FLOAT_CLIENTS[interface](*client_args) self.snapshots_client = SNAPSHOTS_CLIENTS[interface](*client_args) self.volumes_client = VOLUMES_CLIENTS[interface](*client_args) self.volume_types_client = \ VOLUME_TYPES_CLIENTS[interface](*client_args) self.identity_client = IDENTITY_CLIENT[interface](*client_args) self.identity_v3_client = \ IDENTITY_V3_CLIENT[interface](*client_args) self.token_client = TOKEN_CLIENT[interface](self.config) self.security_groups_client = \ SECURITY_GROUPS_CLIENT[interface](*client_args) self.interfaces_client = INTERFACES_CLIENT[interface](*client_args) self.endpoints_client = ENDPOINT_CLIENT[interface](*client_args) self.fixed_ips_client = FIXED_IPS_CLIENT[interface](*client_args) self.availability_zone_client = \ AVAILABILITY_ZONE_CLIENT[interface](*client_args) self.service_client = SERVICE_CLIENT[interface](*client_args) self.aggregates_client = AGGREGATES_CLIENT[interface](*client_args) self.services_client = SERVICES_CLIENT[interface](*client_args) self.tenant_usages_client = \ TENANT_USAGES_CLIENT[interface](*client_args) self.policy_client = POLICY_CLIENT[interface](*client_args) if client_args_v3_auth: self.servers_client_v3_auth = SERVERS_CLIENTS[interface]( *client_args_v3_auth) else: self.servers_client_v3_auth = None except KeyError: msg = "Unsupported interface type `%s'" % interface raise exceptions.InvalidConfiguration(msg) self.network_client = NetworkClient(*client_args) self.hosts_client = HostsClientJSON(*client_args) self.account_client = AccountClient(*client_args) self.image_client = ImageClientJSON(*client_args) self.image_client_v2 = ImageClientV2JSON(*client_args) self.container_client = ContainerClient(*client_args) self.object_client = ObjectClient(*client_args) self.orchestration_client = OrchestrationClient(*client_args) self.ec2api_client = botoclients.APIClientEC2(*client_args) self.s3_client = botoclients.ObjectClientS3(*client_args) self.custom_object_client = ObjectClientCustomizedHeader(*client_args) self.custom_account_client = \ AccountClientCustomizedHeader(*client_args)
class LiveBlockMigrationTestJSON(base.BaseComputeAdminTest): _host_key = 'OS-EXT-SRV-ATTR:host' _interface = 'json' CONF = config.TempestConfig() @classmethod def setUpClass(cls): super(LiveBlockMigrationTestJSON, cls).setUpClass() cls.admin_hosts_client = cls.os_adm.hosts_client cls.admin_servers_client = cls.os_adm.servers_client cls.created_server_ids = [] def _get_compute_hostnames(self): _resp, body = self.admin_hosts_client.list_hosts() return [ host_record['host_name'] for host_record in body if host_record['service'] == 'compute' ] def _get_server_details(self, server_id): _resp, body = self.admin_servers_client.get_server(server_id) return body def _get_host_for_server(self, server_id): return self._get_server_details(server_id)[self._host_key] def _migrate_server_to(self, server_id, dest_host): _resp, body = self.admin_servers_client.live_migrate_server( server_id, dest_host, self.config.compute.use_block_migration_for_live_migration) return body def _get_host_other_than(self, host): for target_host in self._get_compute_hostnames(): if host != target_host: return target_host def _get_non_existing_host_name(self): random_name = ''.join( random.choice(string.ascii_uppercase) for x in range(20)) self.assertNotIn(random_name, self._get_compute_hostnames()) return random_name def _get_server_status(self, server_id): return self._get_server_details(server_id)['status'] def _get_an_active_server(self): for server_id in self.created_server_ids: if 'ACTIVE' == self._get_server_status(server_id): return server_id else: _, server = self.create_server(wait_until="ACTIVE") server_id = server['id'] self.password = server['adminPass'] self.password = '******' self.created_server_ids.append(server_id) return server_id def _volume_clean_up(self, server_id, volume_id): resp, body = self.volumes_client.get_volume(volume_id) if body['status'] == 'in-use': self.servers_client.detach_volume(server_id, volume_id) self.volumes_client.wait_for_volume_status(volume_id, 'available') self.volumes_client.delete_volume(volume_id) @testtools.skipIf(not CONF.compute.live_migration_available, 'Live migration not available') @attr(type='gate') def test_live_block_migration(self): # Live block migrate an instance to another host if len(self._get_compute_hostnames()) < 2: raise self.skipTest( "Less than 2 compute nodes, skipping migration test.") server_id = self._get_an_active_server() actual_host = self._get_host_for_server(server_id) target_host = self._get_host_other_than(actual_host) self._migrate_server_to(server_id, target_host) self.servers_client.wait_for_server_status(server_id, 'ACTIVE') self.assertEquals(target_host, self._get_host_for_server(server_id)) @testtools.skipIf(not CONF.compute.live_migration_available, 'Live migration not available') @attr(type='gate') def test_invalid_host_for_migration(self): # Migrating to an invalid host should not change the status server_id = self._get_an_active_server() target_host = self._get_non_existing_host_name() self.assertRaises(exceptions.BadRequest, self._migrate_server_to, server_id, target_host) self.assertEquals('ACTIVE', self._get_server_status(server_id)) @testtools.skipIf(not CONF.compute.live_migration_available or not CONF.compute.use_block_migration_for_live_migration, 'Block Live migration not available') @testtools.skipIf(not CONF.compute.block_migrate_supports_cinder_iscsi, 'Block Live migration not configured for iSCSI') @attr(type='gate') def test_iscsi_volume(self): # Live block migrate an instance to another host if len(self._get_compute_hostnames()) < 2: raise self.skipTest( "Less than 2 compute nodes, skipping migration test.") server_id = self._get_an_active_server() actual_host = self._get_host_for_server(server_id) target_host = self._get_host_other_than(actual_host) resp, volume = self.volumes_client.create_volume(1, display_name='test') self.volumes_client.wait_for_volume_status(volume['id'], 'available') self.addCleanup(self._volume_clean_up, server_id, volume['id']) # Attach the volume to the server self.servers_client.attach_volume(server_id, volume['id'], device='/dev/xvdb') self.volumes_client.wait_for_volume_status(volume['id'], 'in-use') self._migrate_server_to(server_id, target_host) self.servers_client.wait_for_server_status(server_id, 'ACTIVE') self.assertEquals(target_host, self._get_host_for_server(server_id)) @classmethod def tearDownClass(cls): for server_id in cls.created_server_ids: cls.servers_client.delete_server(server_id) super(LiveBlockMigrationTestJSON, cls).tearDownClass()
# Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import logging import nose from tempest import config from tempest import openstack LOG = logging.getLogger(__name__) CONFIG = config.TempestConfig() CREATE_IMAGE_ENABLED = CONFIG.compute.create_image_enabled RESIZE_AVAILABLE = CONFIG.compute.resize_available DISK_CONFIG_ENABLED = False FLAVOR_EXTRA_DATA_ENABLED = False MULTI_USER = False # All compute tests -- single setup function def setup_package(): LOG.debug("Entering tempest.tests.compute.setup_package") global MULTI_USER, DISK_CONFIG_ENABLED, FLAVOR_EXTRA_DATA_ENABLED os = openstack.Manager() images_client = os.images_client flavors_client = os.flavors_client
def __init__(self): self.config = config.TempestConfig() self.services = {} self.services['image'] = image_service.Service(self.config) self.images = self.services['image']
def __init__(self, interface='json'): conf = config.TempestConfig() super(IdentityManager, self).__init__(conf.identity_admin.username, conf.identity_admin.password, conf.identity_admin.tenant_name, interface)
class VolumeMultiBackendTest(base.BaseVolumeAdminTest): _interface = "json" multi_backend_enabled = config.TempestConfig().volume.multi_backend_enabled backend1_name = config.TempestConfig().volume.backend1_name backend2_name = config.TempestConfig().volume.backend2_name backend_names_equal = False if (backend1_name == backend2_name): backend_names_equal = True @classmethod @testtools.skipIf(not multi_backend_enabled, "Cinder multi-backend feature is not available") def setUpClass(cls): super(VolumeMultiBackendTest, cls).setUpClass() adm_user = cls.config.identity.admin_username adm_pass = cls.config.identity.admin_password adm_tenant = cls.config.identity.admin_tenant_name auth_url = cls.config.identity.uri cls.client = volumes_client.VolumesClientJSON(cls.config, adm_user, adm_pass, auth_url, adm_tenant) cls.client2 = volume_types_client.VolumeTypesClientJSON( cls.config, adm_user, adm_pass, auth_url, adm_tenant) ## variables initialization type_name1 = rand_name('type-') type_name2 = rand_name('type-') cls.volume_type_list = [] vol_name1 = rand_name('Volume-') vol_name2 = rand_name('Volume-') cls.volume_id_list = [] try: ## Volume types creation extra_specs1 = {"volume_backend_name": cls.backend1_name} resp, cls.body1 = cls.client2.create_volume_type( type_name1, extra_specs=extra_specs1) cls.volume_type_list.append(cls.body1) extra_specs2 = {"volume_backend_name": cls.backend2_name} resp, cls.body2 = cls.client2.create_volume_type( type_name2, extra_specs=extra_specs2) cls.volume_type_list.append(cls.body2) ## Volumes creation resp, cls.volume1 = cls.client.create_volume( size=1, display_name=vol_name1, volume_type=type_name1) cls.client.wait_for_volume_status(cls.volume1['id'], 'available') cls.volume_id_list.append(cls.volume1['id']) resp, cls.volume2 = cls.client.create_volume( size=1, display_name=vol_name2, volume_type=type_name2) cls.client.wait_for_volume_status(cls.volume2['id'], 'available') cls.volume_id_list.append(cls.volume2['id']) except Exception: LOG.exception("setup failed") cls.tearDownClass() raise @classmethod def tearDownClass(cls): ## volumes deletion for volume_id in cls.volume_id_list: cls.client.delete_volume(volume_id) cls.client.wait_for_resource_deletion(volume_id) ## volume types deletion for volume_type in cls.volume_type_list: cls.client2.delete_volume_type(volume_type) super(VolumeMultiBackendTest, cls).tearDownClass() @attr(type=['smoke']) def test_multi_backend_enabled(self): # this test checks that multi backend is enabled for at least the # computes where the volumes created in setUp were made # if multi-backend is enabled: os-vol-attr:host should be like: # host@backend_name # this test fails if: # - multi backend is not enabled resp, fetched_volume = self.client.get_volume(self.volume1['id']) self.assertEqual(200, resp.status) volume_host1 = fetched_volume['os-vol-host-attr:host'] msg = ("Multi-backend is not available for at least host " "%(volume_host1)s") % locals() self.assertTrue(len(volume_host1.split("@")) > 1, msg) resp, fetched_volume = self.client.get_volume(self.volume2['id']) self.assertEqual(200, resp.status) volume_host2 = fetched_volume['os-vol-host-attr:host'] msg = ("Multi-backend is not available for at least host " "%(volume_host2)s") % locals() self.assertTrue(len(volume_host2.split("@")) > 1, msg) @attr(type='gate') def test_backend_name_distinction(self): # this test checks that the two volumes created at setUp doesn't # belong to the same backend (if they are in the same backend, that # means, volume_backend_name distinction is not working properly) # this test fails if: # - tempest.conf is not well configured # - the two volumes belongs to the same backend # checks tempest.conf msg = ("tempest.conf is not well configured, " "backend1_name and backend2_name are equal") self.assertEqual(self.backend_names_equal, False, msg) # checks the two volumes belongs to different backend resp, fetched_volume = self.client.get_volume(self.volume1['id']) volume_host1 = fetched_volume['os-vol-host-attr:host'] resp, fetched_volume = self.client.get_volume(self.volume2['id']) volume_host2 = fetched_volume['os-vol-host-attr:host'] msg = ("volume2 was created in the same backend as volume1: " "%(volume_host2)s.") % locals() self.assertNotEqual(volume_host2, volume_host1, msg)
def __init__(self, interface='json'): conf = config.TempestConfig() super(IdentityNaManager, self).__init__(conf.compute.username, conf.compute.password, conf.compute.tenant_name, interface)
class ListServerFiltersTestJSON(base.BaseV2ComputeTest): _interface = 'json' @classmethod def setUpClass(cls): super(ListServerFiltersTestJSON, cls).setUpClass() cls.client = cls.servers_client # Check to see if the alternate image ref actually exists... images_client = cls.images_client resp, images = images_client.list_images() if cls.image_ref != cls.image_ref_alt and \ any([image for image in images if image['id'] == cls.image_ref_alt]): cls.multiple_images = True else: cls.image_ref_alt = cls.image_ref # Do some sanity checks here. If one of the images does # not exist, fail early since the tests won't work... try: cls.images_client.get_image(cls.image_ref) except exceptions.NotFound: raise RuntimeError("Image %s (image_ref) was not found!" % cls.image_ref) try: cls.images_client.get_image(cls.image_ref_alt) except exceptions.NotFound: raise RuntimeError("Image %s (image_ref_alt) was not found!" % cls.image_ref_alt) cls.s1_name = rand_name(cls.__name__ + '-instance') resp, cls.s1 = cls.create_server(name=cls.s1_name, image_id=cls.image_ref, flavor=cls.flavor_ref, wait_until='ACTIVE') cls.s2_name = rand_name(cls.__name__ + '-instance') resp, cls.s2 = cls.create_server(name=cls.s2_name, image_id=cls.image_ref_alt, flavor=cls.flavor_ref, wait_until='ACTIVE') cls.s3_name = rand_name(cls.__name__ + '-instance') resp, cls.s3 = cls.create_server(name=cls.s3_name, image_id=cls.image_ref, flavor=cls.flavor_ref_alt, wait_until='ACTIVE') cls.fixed_network_name = cls.config.compute.fixed_network_name @utils.skip_unless_attr('multiple_images', 'Only one image found') @attr(type='gate') def test_list_servers_filter_by_image(self): # Filter the list of servers by image params = {'image': self.image_ref} resp, body = self.client.list_servers(params) servers = body['servers'] self.assertIn(self.s1['id'], map(lambda x: x['id'], servers)) self.assertNotIn(self.s2['id'], map(lambda x: x['id'], servers)) self.assertIn(self.s3['id'], map(lambda x: x['id'], servers)) @attr(type='gate') def test_list_servers_filter_by_flavor(self): # Filter the list of servers by flavor params = {'flavor': self.flavor_ref_alt} resp, body = self.client.list_servers(params) servers = body['servers'] self.assertNotIn(self.s1['id'], map(lambda x: x['id'], servers)) self.assertNotIn(self.s2['id'], map(lambda x: x['id'], servers)) self.assertIn(self.s3['id'], map(lambda x: x['id'], servers)) @attr(type='gate') def test_list_servers_filter_by_server_name(self): # Filter the list of servers by server name params = {'name': self.s1_name} resp, body = self.client.list_servers(params) servers = body['servers'] self.assertIn(self.s1_name, map(lambda x: x['name'], servers)) self.assertNotIn(self.s2_name, map(lambda x: x['name'], servers)) self.assertNotIn(self.s3_name, map(lambda x: x['name'], servers)) @attr(type='gate') def test_list_servers_filter_by_server_status(self): # Filter the list of servers by server status params = {'status': 'active'} resp, body = self.client.list_servers(params) servers = body['servers'] self.assertIn(self.s1['id'], map(lambda x: x['id'], servers)) self.assertIn(self.s2['id'], map(lambda x: x['id'], servers)) self.assertIn(self.s3['id'], map(lambda x: x['id'], servers)) @attr(type='gate') def test_list_servers_filter_by_limit(self): # Verify only the expected number of servers are returned params = {'limit': 1} resp, servers = self.client.list_servers(params) # when _interface='xml', one element for servers_links in servers self.assertEqual(1, len([x for x in servers['servers'] if 'id' in x])) @utils.skip_unless_attr('multiple_images', 'Only one image found') @attr(type='gate') def test_list_servers_detailed_filter_by_image(self): # Filter the detailed list of servers by image params = {'image': self.image_ref} resp, body = self.client.list_servers_with_detail(params) servers = body['servers'] self.assertIn(self.s1['id'], map(lambda x: x['id'], servers)) self.assertNotIn(self.s2['id'], map(lambda x: x['id'], servers)) self.assertIn(self.s3['id'], map(lambda x: x['id'], servers)) @attr(type='gate') def test_list_servers_detailed_filter_by_flavor(self): # Filter the detailed list of servers by flavor params = {'flavor': self.flavor_ref_alt} resp, body = self.client.list_servers_with_detail(params) servers = body['servers'] self.assertNotIn(self.s1['id'], map(lambda x: x['id'], servers)) self.assertNotIn(self.s2['id'], map(lambda x: x['id'], servers)) self.assertIn(self.s3['id'], map(lambda x: x['id'], servers)) @attr(type='gate') def test_list_servers_detailed_filter_by_server_name(self): # Filter the detailed list of servers by server name params = {'name': self.s1_name} resp, body = self.client.list_servers_with_detail(params) servers = body['servers'] self.assertIn(self.s1_name, map(lambda x: x['name'], servers)) self.assertNotIn(self.s2_name, map(lambda x: x['name'], servers)) self.assertNotIn(self.s3_name, map(lambda x: x['name'], servers)) @attr(type='gate') def test_list_servers_detailed_filter_by_server_status(self): # Filter the detailed list of servers by server status params = {'status': 'active'} resp, body = self.client.list_servers_with_detail(params) servers = body['servers'] self.assertIn(self.s1['id'], map(lambda x: x['id'], servers)) self.assertIn(self.s2['id'], map(lambda x: x['id'], servers)) self.assertIn(self.s3['id'], map(lambda x: x['id'], servers)) self.assertEqual(['ACTIVE'] * 3, [x['status'] for x in servers]) @attr(type='gate') def test_list_servers_filtered_by_name_wildcard(self): # List all servers that contains '-instance' in name params = {'name': '-instance'} resp, body = self.client.list_servers(params) servers = body['servers'] self.assertIn(self.s1_name, map(lambda x: x['name'], servers)) self.assertIn(self.s2_name, map(lambda x: x['name'], servers)) self.assertIn(self.s3_name, map(lambda x: x['name'], servers)) # Let's take random part of name and try to search it part_name = self.s1_name[6:-1] params = {'name': part_name} resp, body = self.client.list_servers(params) servers = body['servers'] self.assertIn(self.s1_name, map(lambda x: x['name'], servers)) self.assertNotIn(self.s2_name, map(lambda x: x['name'], servers)) self.assertNotIn(self.s3_name, map(lambda x: x['name'], servers)) @skip_because(bug="1170718") @attr(type='gate') def test_list_servers_filtered_by_ip(self): # Filter servers by ip # Here should be listed 1 server resp, self.s1 = self.client.get_server(self.s1['id']) ip = self.s1['addresses'][self.fixed_network_name][0]['addr'] params = {'ip': ip} resp, body = self.client.list_servers(params) servers = body['servers'] self.assertIn(self.s1_name, map(lambda x: x['name'], servers)) self.assertNotIn(self.s2_name, map(lambda x: x['name'], servers)) self.assertNotIn(self.s3_name, map(lambda x: x['name'], servers)) @skip_because(bug="1182883", condition=config.TempestConfig().service_available.neutron) @attr(type='gate') def test_list_servers_filtered_by_ip_regex(self): # Filter servers by regex ip # List all servers filtered by part of ip address. # Here should be listed all servers resp, self.s1 = self.client.get_server(self.s1['id']) ip = self.s1['addresses'][self.fixed_network_name][0]['addr'][0:-3] params = {'ip': ip} resp, body = self.client.list_servers(params) servers = body['servers'] self.assertIn(self.s1_name, map(lambda x: x['name'], servers)) self.assertIn(self.s2_name, map(lambda x: x['name'], servers)) self.assertIn(self.s3_name, map(lambda x: x['name'], servers)) @attr(type='gate') def test_list_servers_detailed_limit_results(self): # Verify only the expected number of detailed results are returned params = {'limit': 1} resp, servers = self.client.list_servers_with_detail(params) self.assertEqual(1, len(servers['servers']))