def _get_unused_flavor_id(self): flavor_id = data_utils.rand_int_id(start=1000) while True: try: self.flavors_client.show_flavor(flavor_id) except lib_exc.NotFound: break flavor_id = data_utils.rand_int_id(start=1000) return flavor_id
def _get_unused_flavor_id(self): flavor_id = data_utils.rand_int_id(start=1000) while True: try: self.flavors_client.get_flavor_details(flavor_id) except lib_exc.NotFound: break flavor_id = data_utils.rand_int_id(start=1000) return flavor_id
def test_flavor_access_add_remove(self): # Test to add and remove flavor access to a given tenant. flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) new_flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public='False') self.addCleanup(self.client.delete_flavor, new_flavor['id']) # Add flavor access to a tenant. resp_body = { "tenant_id": str(self.tenant_id), "flavor_id": str(new_flavor['id']), } add_body = \ self.client.add_flavor_access(new_flavor['id'], self.tenant_id) self.assertIn(resp_body, add_body) # The flavor is present in list. flavors = self.flavors_client.list_flavors_with_detail() self.assertIn(new_flavor['id'], map(lambda x: x['id'], flavors)) # Remove flavor access from a tenant. remove_body = \ self.client.remove_flavor_access(new_flavor['id'], self.tenant_id) self.assertNotIn(resp_body, remove_body) # The flavor is not present in list. flavors = self.flavors_client.list_flavors_with_detail() self.assertNotIn(new_flavor['id'], map(lambda x: x['id'], flavors))
def test_flavor_access_add_remove(self): # Test to add and remove flavor access to a given tenant. flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) new_flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public='False') self.addCleanup(self.client.delete_flavor, new_flavor['id']) # Add flavor access to a tenant. resp_body = { "tenant_id": str(self.tenant_id), "flavor_id": str(new_flavor['id']), } add_body = \ self.client.add_flavor_access(new_flavor['id'], self.tenant_id) self.assertIn(resp_body, add_body) # The flavor is present in list. flavors = self.flavors_client.list_flavors_with_detail() self.assertIn(new_flavor['id'], map(lambda x: x['id'], flavors)) # Remove flavor access from a tenant. remove_body = \ self.client.remove_flavor_access(new_flavor['id'], self.tenant_id) self.assertNotIn(resp_body, remove_body) # The flavor is not present in list. flavors = self.flavors_client.list_flavors_with_detail() self.assertNotIn(new_flavor['id'], map(lambda x: x['id'], flavors))
def test_list_non_public_flavor(self): # Create a flavor with os-flavor-access:is_public false. # The flavor should not be present in list_details as the # tenant is not automatically added access list. # This operation requires the user to have 'admin' role flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) # Create the flavor flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public="False") self.addCleanup(self.flavor_clean_up, flavor['id']) # Verify flavor is retrieved flag = False flavors = self.client.list_flavors(detail=True) for flavor in flavors: if flavor['name'] == flavor_name: flag = True self.assertFalse(flag) # Verify flavor is not retrieved with other user flag = False flavors = self.user_client.list_flavors(detail=True) for flavor in flavors: if flavor['name'] == flavor_name: flag = True self.assertFalse(flag)
def test_list_non_public_flavor(self): # Create a flavor with os-flavor-access:is_public false. # The flavor should not be present in list_details as the # tenant is not automatically added access list. # This operation requires the user to have 'admin' role flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) # Create the flavor flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public="False") self.addCleanup(self.flavor_clean_up, flavor['id']) # Verify flavor is retrieved flag = False flavors = self.client.list_flavors_with_detail() for flavor in flavors: if flavor['name'] == flavor_name: flag = True self.assertFalse(flag) # Verify flavor is not retrieved with other user flag = False flavors = self.user_client.list_flavors_with_detail() for flavor in flavors: if flavor['name'] == flavor_name: flag = True self.assertFalse(flag)
def test_volume_list_details_by_name(self): volume = self.volume_list[data_utils.rand_int_id(0, 2)] params = {self.name: volume[self.name]} fetched_vol = self.client.list_volumes(detail=True, params=params) self.assertEqual(1, len(fetched_vol), str(fetched_vol)) self.assertEqual(fetched_vol[0][self.name], volume[self.name])
def test_volumes_list_by_availability_zone(self): volume = self.volume_list[data_utils.rand_int_id(0, 2)] zone = volume['availability_zone'] params = {'availability_zone': zone} fetched_list = self.client.list_volumes(params=params) self._list_by_param_value_and_assert(params) self.assertVolumesIn(fetched_list, self.volume_list, fields=self.VOLUME_FIELDS)
def test_volumes_list_details_by_availability_zone(self): volume = self.volume_list[data_utils.rand_int_id(0, 2)] zone = volume['availability_zone'] params = {'availability_zone': zone} fetched_list = self.client.list_volumes(detail=True, params=params) for volume in fetched_list: self.assertEqual(zone, volume['availability_zone']) self.assertVolumesIn(fetched_list, self.volume_list)
def test_volumes_list_details_by_availability_zone(self): volume = self.volume_list[data_utils.rand_int_id(0, 2)] zone = volume['availability_zone'] params = {'availability_zone': zone} fetched_list = self.client.list_volumes(detail=True, params=params) for volume in fetched_list: self.assertEqual(zone, volume['availability_zone']) self.assertVolumesIn(fetched_list, self.volume_list)
def test_volumes_list_by_availability_zone(self): volume = self.volume_list[data_utils.rand_int_id(0, 2)] zone = volume['availability_zone'] params = {'availability_zone': zone} fetched_list = self.client.list_volumes(params=params) self._list_by_param_value_and_assert(params) self.assertVolumesIn(fetched_list, self.volume_list, fields=self.VOLUME_FIELDS)
def test_get_nonexistent_floating_ip_details(self): # Negative test:Should not be able to GET the details # of non-existent floating IP # Creating a non-existent floatingIP id if CONF.service_available.neutron: non_exist_id = str(uuid.uuid4()) else: non_exist_id = data_utils.rand_int_id(start=999) self.assertRaises(lib_exc.NotFound, self.client.show_floating_ip, non_exist_id)
def test_list_container_contents_with_limit(self): # get container contents list using limit param container_name = self._create_container() object_name = self._create_object(container_name) params = {'limit': data_utils.rand_int_id(1, 10000)} resp, object_list = self.container_client.list_container_contents( container_name, params=params) self.assertHeaders(resp, 'Container', 'GET') self.assertEqual(object_name, object_list.strip('\n'))
def test_get_nonexistent_floating_ip_details(self): # Negative test:Should not be able to GET the details # of non-existent floating IP # Creating a non-existent floatingIP id if CONF.service_available.neutron: non_exist_id = str(uuid.uuid4()) else: non_exist_id = data_utils.rand_int_id(start=999) self.assertRaises(lib_exc.NotFound, self.client.show_floating_ip, non_exist_id)
def test_get_queue_stats(self): # Retrieve random queue queue_name = self.queues[data_utils.rand_int_id(0, len(self.queues) - 1)] # Get Queue Stats for a newly created Queue _, body = self.get_queue_stats(queue_name) msgs = body['messages'] for element in ('free', 'claimed', 'total'): self.assertEqual(0, msgs[element]) for element in ('oldest', 'newest'): self.assertNotIn(element, msgs)
def test_list_container_contents_with_limit(self): # get container contents list using limit param container_name = self._create_container() object_name = self._create_object(container_name) params = {'limit': data_utils.rand_int_id(1, 10000)} resp, object_list = self.container_client.list_container_contents( container_name, params=params) self.assertHeaders(resp, 'Container', 'GET') self.assertEqual(object_name, object_list.strip('\n'))
def test_is_public_string_variations(self): flavor_id_not_public = data_utils.rand_int_id(start=1000) flavor_name_not_public = data_utils.rand_name(self.flavor_name_prefix) flavor_id_public = data_utils.rand_int_id(start=1000) flavor_name_public = data_utils.rand_name(self.flavor_name_prefix) # Create a non public flavor flavor = self.client.create_flavor(flavor_name_not_public, self.ram, self.vcpus, self.disk, flavor_id_not_public, is_public="False") self.addCleanup(self.flavor_clean_up, flavor['id']) # Create a public flavor flavor = self.client.create_flavor(flavor_name_public, self.ram, self.vcpus, self.disk, flavor_id_public, is_public="True") self.addCleanup(self.flavor_clean_up, flavor['id']) def _flavor_lookup(flavors, flavor_name): for flavor in flavors: if flavor['name'] == flavor_name: return flavor return None def _test_string_variations(variations, flavor_name): for string in variations: params = {'is_public': string} flavors = self.client.list_flavors(detail=True, **params) flavor = _flavor_lookup(flavors, flavor_name) self.assertIsNotNone(flavor) _test_string_variations(['f', 'false', 'no', '0'], flavor_name_not_public) _test_string_variations(['t', 'true', 'yes', '1'], flavor_name_public)
def test_get_queue_stats(self): # Retrieve random queue queue_name = self.queues[data_utils.rand_int_id( 0, len(self.queues) - 1)] # Get Queue Stats for a newly created Queue _, body = self.get_queue_stats(queue_name) msgs = body['messages'] for element in ('free', 'claimed', 'total'): self.assertEqual(0, msgs[element]) for element in ('oldest', 'newest'): self.assertNotIn(element, msgs)
def test_is_public_string_variations(self): flavor_id_not_public = data_utils.rand_int_id(start=1000) flavor_name_not_public = data_utils.rand_name(self.flavor_name_prefix) flavor_id_public = data_utils.rand_int_id(start=1000) flavor_name_public = data_utils.rand_name(self.flavor_name_prefix) # Create a non public flavor flavor = self.client.create_flavor(flavor_name_not_public, self.ram, self.vcpus, self.disk, flavor_id_not_public, is_public="False") self.addCleanup(self.flavor_clean_up, flavor['id']) # Create a public flavor flavor = self.client.create_flavor(flavor_name_public, self.ram, self.vcpus, self.disk, flavor_id_public, is_public="True") self.addCleanup(self.flavor_clean_up, flavor['id']) def _flavor_lookup(flavors, flavor_name): for flavor in flavors: if flavor['name'] == flavor_name: return flavor return None def _test_string_variations(variations, flavor_name): for string in variations: params = {'is_public': string} flavors = self.client.list_flavors_with_detail(params) flavor = _flavor_lookup(flavors, flavor_name) self.assertIsNotNone(flavor) _test_string_variations(['f', 'false', 'no', '0'], flavor_name_not_public) _test_string_variations(['t', 'true', 'yes', '1'], flavor_name_public)
def populate_smoke_table(self, table_name, keycount, count_per_key): """ Put [keycont*count_per_key] autogenerated items to the table. In result, [keycount] unique hash key values and [count_per_key] items for each has key value are generated. For example, to generate some number of items for the only hash key, set keycount=1 and count_per_key=needed_number_of_items. """ new_items = [] for _ in range(keycount): forum = 'forum%s' % data_utils.rand_int_id() for i in range(count_per_key): item = self.put_smoke_item( table_name, forum=forum, subject='subject%s' % i, message=data_utils.rand_name(self.table_prefix), last_posted_by=data_utils.rand_uuid(), replies=str(data_utils.rand_int_id()) ) new_items.append(item) return new_items
def test_flavor_access_list_with_public_flavor(self): # Test to list flavor access with exceptions by querying public flavor flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) new_flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public='True') self.addCleanup(self.client.delete_flavor, new_flavor['id']) self.assertRaises(lib_exc.NotFound, self.client.list_flavor_access, new_flavor_id)
def test_flavor_access_list_with_public_flavor(self): # Test to list flavor access with exceptions by querying public flavor flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) new_flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public='True') self.addCleanup(self.client.delete_flavor, new_flavor['id']) self.assertRaises(lib_exc.NotFound, self.client.list_flavor_access, new_flavor_id)
def test_create_flavor_using_string_ram(self): flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) ram = "1024" flavor = self.client.create_flavor(flavor_name, ram, self.vcpus, self.disk, new_flavor_id) self.addCleanup(self.flavor_clean_up, flavor['id']) self.assertEqual(flavor['name'], flavor_name) self.assertEqual(flavor['vcpus'], self.vcpus) self.assertEqual(flavor['disk'], self.disk) self.assertEqual(flavor['ram'], int(ram)) self.assertEqual(int(flavor['id']), new_flavor_id)
def _generate_a_non_existent_security_group_id(self): security_group_id = [] body = self.client.list_security_groups() for i in range(len(body)): security_group_id.append(body[i]['id']) # Generate a non-existent security group id while True: non_exist_id = data_utils.rand_int_id(start=999) if self.neutron_available: non_exist_id = data_utils.rand_uuid() if non_exist_id not in security_group_id: break return non_exist_id
def test_create_security_group_rule_with_invalid_to_port(self): # Negative test: Creation of Security Group rule should FAIL # with invalid to_port # Creating a Security Group to add rule to it sg = self.create_security_group() # Adding rules to the created Security Group parent_group_id = sg['id'] ip_protocol = 'tcp' from_port = 22 to_port = data_utils.rand_int_id(start=65536) self.assertRaises(lib_exc.BadRequest, self.client.create_security_group_rule, parent_group_id, ip_protocol, from_port, to_port)
def test_flavor_access_list_with_private_flavor(self): # Test to make sure that list flavor access on a newly created # private flavor will return an empty access list flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) new_flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public='False') self.addCleanup(self.client.delete_flavor, new_flavor['id']) flavor_access = self.client.list_flavor_access(new_flavor_id) self.assertEqual(len(flavor_access), 0, str(flavor_access))
def create_flavor_without_extra_specs(): flavor_no_eph_disk_name = data_utils.rand_name("no_eph_flavor") flavor_no_eph_disk_id = data_utils.rand_int_id(start=1000) ram = 64 vcpus = 1 disk = 0 # Create a flavor without extra specs flavor = self.flavor_client.create_flavor(flavor_no_eph_disk_name, ram, vcpus, disk, flavor_no_eph_disk_id) self.addCleanup(flavor_clean_up, flavor["id"]) return flavor["id"]
def test_flavor_access_list_with_private_flavor(self): # Test to make sure that list flavor access on a newly created # private flavor will return an empty access list flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) new_flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public='False') self.addCleanup(self.client.delete_flavor, new_flavor['id']) flavor_access = self.client.list_flavor_access(new_flavor_id) self.assertEqual(len(flavor_access), 0, str(flavor_access))
def _generate_a_non_existent_security_group_id(self): security_group_id = [] body = self.client.list_security_groups() for i in range(len(body)): security_group_id.append(body[i]['id']) # Generate a non-existent security group id while True: non_exist_id = data_utils.rand_int_id(start=999) if self.neutron_available: non_exist_id = data_utils.rand_uuid() if non_exist_id not in security_group_id: break return non_exist_id
def test_create_security_group_rule_with_invalid_to_port(self): # Negative test: Creation of Security Group rule should FAIL # with invalid to_port # Creating a Security Group to add rule to it sg = self.create_security_group() # Adding rules to the created Security Group parent_group_id = sg['id'] ip_protocol = 'tcp' from_port = 22 to_port = data_utils.rand_int_id(start=65536) self.assertRaises(lib_exc.BadRequest, self.client.create_security_group_rule, parent_group_id, ip_protocol, from_port, to_port)
def test_flavor_non_admin_add(self): # Test to add flavor access as a user without admin privileges. flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) new_flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public='False') self.addCleanup(self.client.delete_flavor, new_flavor['id']) self.assertRaises(lib_exc.Forbidden, self.flavors_client.add_flavor_access, new_flavor['id'], self.tenant_id)
def test_flavor_non_admin_add(self): # Test to add flavor access as a user without admin privileges. flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) new_flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public='False') self.addCleanup(self.client.delete_flavor, new_flavor['id']) self.assertRaises(lib_exc.Forbidden, self.flavors_client.add_flavor_access, new_flavor['id'], self.tenant_id)
def resource_setup(cls): super(FlavorsExtraSpecsNegativeTestJSON, cls).resource_setup() flavor_name = data_utils.rand_name("test_flavor") ram = 512 vcpus = 1 disk = 10 ephemeral = 10 cls.new_flavor_id = data_utils.rand_int_id(start=1000) swap = 1024 rxtx = 1 # Create a flavor cls.flavor = cls.client.create_flavor( flavor_name, ram, vcpus, disk, cls.new_flavor_id, ephemeral=ephemeral, swap=swap, rxtx=rxtx )
def create_flavor_without_extra_specs(): flavor_no_eph_disk_name = data_utils.rand_name('no_eph_flavor') flavor_no_eph_disk_id = data_utils.rand_int_id(start=1000) ram = 64 vcpus = 1 disk = 0 # Create a flavor without extra specs flavor = (self.flavor_client.create_flavor(flavor_no_eph_disk_name, ram, vcpus, disk, flavor_no_eph_disk_id)) self.addCleanup(flavor_clean_up, flavor['id']) return flavor['id']
def test_create_flavor_using_string_ram(self): flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) ram = "1024" flavor = self.client.create_flavor(flavor_name, ram, self.vcpus, self.disk, new_flavor_id) self.addCleanup(self.flavor_clean_up, flavor['id']) self.assertEqual(flavor['name'], flavor_name) self.assertEqual(flavor['vcpus'], self.vcpus) self.assertEqual(flavor['disk'], self.disk) self.assertEqual(flavor['ram'], int(ram)) self.assertEqual(int(flavor['id']), new_flavor_id)
def test_remove_flavor_access_not_found(self): # Create a new flavor. flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) new_flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public='False') self.addCleanup(self.client.delete_flavor, new_flavor['id']) # An exception should be raised when flavor access is not found self.assertRaises(lib_exc.NotFound, self.client.remove_flavor_access, new_flavor['id'], str(uuid.uuid4()))
def test_remove_flavor_access_not_found(self): # Create a new flavor. flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) new_flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public='False') self.addCleanup(self.client.delete_flavor, new_flavor['id']) # An exception should be raised when flavor access is not found self.assertRaises(lib_exc.NotFound, self.client.remove_flavor_access, new_flavor['id'], str(uuid.uuid4()))
def _post_and_claim_messages(self, queue_name, repeat=1): # Post Messages message_body = self.generate_message_body(repeat=repeat) self.client.post_messages(queue_name=self.queue_name, rbody=message_body) # Post Claim claim_ttl = data_utils.rand_int_id(start=60, end=CONF.messaging.max_claim_ttl) claim_grace = data_utils.\ rand_int_id(start=60, end=CONF.messaging.max_claim_grace) claim_body = {"ttl": claim_ttl, "grace": claim_grace} resp, body = self.client.post_claims(queue_name=self.queue_name, rbody=claim_body) return resp, body
def _post_and_claim_messages(self, queue_name, repeat=1): # Post Messages message_body = self.generate_message_body(repeat=repeat) self.client.post_messages(queue_name=self.queue_name, rbody=message_body) # Post Claim claim_ttl = data_utils.rand_int_id(start=60, end=CONF.messaging.max_claim_ttl) claim_grace = data_utils.\ rand_int_id(start=60, end=CONF.messaging.max_claim_grace) claim_body = {"ttl": claim_ttl, "grace": claim_grace} resp, body = self.client.post_claims(queue_name=self.queue_name, rbody=claim_body) return resp, body
def create_flavor_with_extra_specs(): flavor_with_eph_disk_name = data_utils.rand_name('eph_flavor') flavor_with_eph_disk_id = data_utils.rand_int_id(start=1000) ram = 64 vcpus = 1 disk = 0 # Create a flavor with extra specs flavor = (self.flavor_client. create_flavor(flavor_with_eph_disk_name, ram, vcpus, disk, flavor_with_eph_disk_id, ephemeral=1)) self.addCleanup(flavor_clean_up, flavor['id']) return flavor['id']
def resource_setup(cls): super(FloatingIPsNegativeTestJSON, cls).resource_setup() # Server creation server = cls.create_test_server(wait_until='ACTIVE') cls.server_id = server['id'] # Generating a nonexistent floatingIP id cls.floating_ip_ids = [] body = cls.client.list_floating_ips() for i in range(len(body)): cls.floating_ip_ids.append(body[i]['id']) while True: cls.non_exist_id = data_utils.rand_int_id(start=999) if CONF.service_available.neutron: cls.non_exist_id = str(uuid.uuid4()) if cls.non_exist_id not in cls.floating_ip_ids: break
def test_create_server_with_non_public_flavor(self): # Create a flavor with os-flavor-access:is_public false flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) # Create the flavor flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public="False") self.addCleanup(self.flavor_clean_up, flavor['id']) # Verify flavor is not used by other user self.assertRaises(lib_exc.BadRequest, self.os.servers_client.create_server, 'test', self.image_ref, flavor['id'])
def resource_setup(cls): super(FloatingIPsNegativeTestJSON, cls).resource_setup() # Server creation server = cls.create_test_server(wait_until='ACTIVE') cls.server_id = server['id'] # Generating a nonexistent floatingIP id cls.floating_ip_ids = [] body = cls.client.list_floating_ips() for i in range(len(body)): cls.floating_ip_ids.append(body[i]['id']) while True: cls.non_exist_id = data_utils.rand_int_id(start=999) if CONF.service_available.neutron: cls.non_exist_id = str(uuid.uuid4()) if cls.non_exist_id not in cls.floating_ip_ids: break
def test_create_server_with_non_public_flavor(self): # Create a flavor with os-flavor-access:is_public false flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) # Create the flavor flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public="False") self.addCleanup(self.flavor_clean_up, flavor['id']) # Verify flavor is not used by other user self.assertRaises(lib_exc.BadRequest, self.os.servers_client.create_server, 'test', self.image_ref, flavor['id'])
def resource_setup(cls): super(FlavorsExtraSpecsNegativeTestJSON, cls).resource_setup() flavor_name = data_utils.rand_name('test_flavor') ram = 512 vcpus = 1 disk = 10 ephemeral = 10 cls.new_flavor_id = data_utils.rand_int_id(start=1000) swap = 1024 rxtx = 1 # Create a flavor cls.flavor = cls.client.create_flavor(flavor_name, ram, vcpus, disk, cls.new_flavor_id, ephemeral=ephemeral, swap=swap, rxtx=rxtx)
def create_flavor_with_extra_specs(self,name,count=1): flavor_with_pci_name = data_utils.rand_name('pci_flavor') flavor_with_pci_id = data_utils.rand_int_id(start=1000) ram = 2048 vcpus = 1 disk = 2 pci_name = name pci_name = "%s:%d"%(pci_name,count) specs = {"pci_passthrough:alias": pci_name} # Create a flavor with extra specs flavor = (self.flavor_client. create_flavor(name=flavor_with_pci_name, ram=ram, vcpus=vcpus, disk=disk, id=flavor_with_pci_id)) self.flavor_client.set_flavor_extra_spec(flavor['flavor']['id'], **specs) self.addCleanup(flavor_clean_up, self, flavor['flavor']['id']) return flavor['flavor']['id']
def _create_flavor(self, cpu_policy='shared', cpu_threads_policy=None): flavor_name = data_utils.rand_name(self.flavor_name_prefix) flavor_id = data_utils.rand_int_id(start=1000) flavor = self.flavors_client.create_flavor( name=flavor_name, ram=self.ram, vcpus=self.vcpus, disk=self.disk, id=flavor_id, swap=self.swap, rxtx_factor=self.rxtx_factor)['flavor'] self.addCleanup(self.flavor_clean_up, flavor['id']) specs = {'hw:cpu_policy': cpu_policy} if cpu_policy == 'dedicated': specs['hw:cpu_threads_policy'] = cpu_threads_policy self.flavors_client.set_flavor_extra_spec(flavor['id'], **specs) return flavor
def create_flavor_with_extra_specs(self, name, count=1): flavor_with_pci_name = data_utils.rand_name('pci_flavor') flavor_with_pci_id = data_utils.rand_int_id(start=1000) ram = 2048 vcpus = 1 disk = 2 pci_name = name pci_name = "%s:%d" % (pci_name, count) specs = {"pci_passthrough:alias": pci_name} # Create a flavor with extra specs flavor = (self.flavor_client.create_flavor(name=flavor_with_pci_name, ram=ram, vcpus=vcpus, disk=disk, id=flavor_with_pci_id)) self.flavor_client.set_flavor_extra_spec(flavor['flavor']['id'], **specs) self.addCleanup(flavor_clean_up, self, flavor['flavor']['id']) return flavor['flavor']['id']
def create_flavor_with_extra_specs(self, name='hugepages_flavor', count=1): flavor_with_hugepages_name = data_utils.rand_name(name) flavor_with_hugepages_id = data_utils.rand_int_id(start=1000) ram = 64 vcpus = 1 disk = 0 # set numa pagesize extra_specs = {"hw:mem_page_size": str(HUGEPAGE_SIZE)} # Create a flavor with extra specs resp = (self.flavors_client. create_flavor(name=flavor_with_hugepages_name, ram=ram, vcpus=vcpus, disk=disk, id=flavor_with_hugepages_id)) self.flavors_client.set_flavor_extra_spec(flavor_with_hugepages_id, **extra_specs) self.addCleanup(self.flavor_clean_up, flavor_with_hugepages_id) self.assertEqual(200, resp.response.status) return flavor_with_hugepages_id
def test_update_claim(self): # Post a Claim resp, body = self._post_and_claim_messages(queue_name=self.queue_name) claim_uri = resp['location'][resp['location'].find('/v2'):] claimed_message_uri = body['messages'][0]['href'] # Update Claim claim_ttl = data_utils.rand_int_id(start=60, end=CONF.messaging.max_claim_ttl) update_rbody = {"ttl": claim_ttl} self.client.update_claim(claim_uri, rbody=update_rbody) # Verify claim ttl >= updated ttl value _, body = self.client.query_claim(claim_uri) updated_claim_ttl = body["ttl"] self.assertTrue(updated_claim_ttl >= claim_ttl) # Delete Claimed message self.client.delete_messages(claimed_message_uri)
def test_list_public_flavor_with_other_user(self): # Create a Flavor with public access. # Try to List/Get flavor with another user flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) # Create the flavor flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public="True") self.addCleanup(self.flavor_clean_up, flavor['id']) flag = False self.new_client = self.flavors_client # Verify flavor is retrieved with new user flavors = self.new_client.list_flavors_with_detail() for flavor in flavors: if flavor['name'] == flavor_name: flag = True self.assertTrue(flag)
def test_update_claim(self): # Post a Claim resp, body = self._post_and_claim_messages(queue_name=self.queue_name) claim_uri = resp['location'] claimed_message_uri = body[0]['href'] # Update Claim claim_ttl = data_utils.rand_int_id(start=60, end=CONF.messaging.max_claim_ttl) update_rbody = {"ttl": claim_ttl} self.client.update_claim(claim_uri, rbody=update_rbody) # Verify claim ttl >= updated ttl value _, body = self.client.query_claim(claim_uri) updated_claim_ttl = body["ttl"] self.assertTrue(updated_claim_ttl >= claim_ttl) # Delete Claimed message self.client.delete_messages(claimed_message_uri)
def test_set_and_get_queue_metadata(self): # Retrieve random queue queue_name = self.queues[data_utils.rand_int_id(0, len(self.queues) - 1)] # Check the Queue has no metadata _, body = self.get_queue_metadata(queue_name) self.assertThat(body, matchers.HasLength(0)) # Create metadata key3 = [0, 1, 2, 3, 4] key2 = data_utils.rand_name('value') req_body1 = dict() req_body1[data_utils.rand_name('key3')] = key3 req_body1[data_utils.rand_name('key2')] = key2 req_body = dict() req_body[data_utils.rand_name('key1')] = req_body1 # Set Queue Metadata self.set_queue_metadata(queue_name, req_body) # Get Queue Metadata _, body = self.get_queue_metadata(queue_name) self.assertThat(body, matchers.Equals(req_body))
def test_add_flavor_access_duplicate(self): # Create a new flavor. flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) new_flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public='False') self.addCleanup(self.client.delete_flavor, new_flavor['id']) # Add flavor access to a tenant. self.client.add_flavor_access(new_flavor['id'], self.tenant_id) self.addCleanup(self.client.remove_flavor_access, new_flavor['id'], self.tenant_id) # An exception should be raised when adding flavor access to the same # tenant self.assertRaises(lib_exc.Conflict, self.client.add_flavor_access, new_flavor['id'], self.tenant_id)
def create_flavor_with_numa(self, numa_nodes=2, ram=2048, vcpus=4, disk=0, specs=dict()): flavor_with_numa = data_utils.rand_name('numa_flavor') flavor_with_numa_id = data_utils.rand_int_id(start=1000) extra_specs = specs extra_specs["hw:numa_nodes"] = str(numa_nodes) # Create a flavor with extra specs resp = (self.flavors_client.create_flavor(name=flavor_with_numa, ram=ram, vcpus=vcpus, disk=disk, id=flavor_with_numa_id)) self.flavors_client.set_flavor_extra_spec(flavor_with_numa_id, **extra_specs) self.addCleanup(self.flavor_clean_up, flavor_with_numa_id) self.assertEqual(200, resp.response.status) return flavor_with_numa_id
def create_flavor_with_extra_specs(self, name='hugepages_flavor', count=1): flavor_with_hugepages_name = data_utils.rand_name(name) flavor_with_hugepages_id = data_utils.rand_int_id(start=1000) ram = 64 vcpus = 1 disk = 0 # set numa pagesize extra_specs = {"hw:mem_page_size": str(HUGEPAGE_SIZE)} # Create a flavor with extra specs resp = (self.flavors_client.create_flavor( name=flavor_with_hugepages_name, ram=ram, vcpus=vcpus, disk=disk, id=flavor_with_hugepages_id)) self.flavors_client.set_flavor_extra_spec(flavor_with_hugepages_id, **extra_specs) self.addCleanup(self.flavor_clean_up, flavor_with_hugepages_id) self.assertEqual(200, resp.response.status) return flavor_with_hugepages_id
def test_list_public_flavor_with_other_user(self): # Create a Flavor with public access. # Try to List/Get flavor with another user flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) # Create the flavor flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, is_public="True") self.addCleanup(self.flavor_clean_up, flavor['id']) flag = False self.new_client = self.flavors_client # Verify flavor is retrieved with new user flavors = self.new_client.list_flavors(detail=True) for flavor in flavors: if flavor['name'] == flavor_name: flag = True self.assertTrue(flag)
def test_set_and_get_queue_metadata(self): # Retrieve random queue queue_name = self.queues[data_utils.rand_int_id( 0, len(self.queues) - 1)] # Check the Queue has no metadata _, body = self.get_queue_metadata(queue_name) self.assertThat(body, matchers.HasLength(0)) # Create metadata key3 = [0, 1, 2, 3, 4] key2 = data_utils.rand_name('value') req_body1 = dict() req_body1[data_utils.rand_name('key3')] = key3 req_body1[data_utils.rand_name('key2')] = key2 req_body = dict() req_body[data_utils.rand_name('key1')] = req_body1 # Set Queue Metadata self.set_queue_metadata(queue_name, req_body) # Get Queue Metadata _, body = self.get_queue_metadata(queue_name) self.assertThat(body, matchers.Equals(req_body))
def test_create_flavor_verify_entry_in_list_details(self): # Create a flavor and ensure it's details are listed # This operation requires the user to have 'admin' role flavor_name = data_utils.rand_name(self.flavor_name_prefix) new_flavor_id = data_utils.rand_int_id(start=1000) # Create the flavor flavor = self.client.create_flavor(flavor_name, self.ram, self.vcpus, self.disk, new_flavor_id, ephemeral=self.ephemeral, swap=self.swap, rxtx=self.rxtx) self.addCleanup(self.flavor_clean_up, flavor['id']) flag = False # Verify flavor is retrieved flavors = self.client.list_flavors(detail=True) for flavor in flavors: if flavor['name'] == flavor_name: flag = True self.assertTrue(flag)