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)
