def baymodel_data(**kwargs):
"""Generates random baymodel data
Keypair and image id cannot be random for the baymodel to be valid due to
validations for the presence of keypair and image id prior to baymodel
creation.
:param keypair_id: keypair name
:param image_id: image id or name
:returns: BayModelEntity with generated data
"""
data = {
"name": data_utils.rand_name('bay'),
"coe": "swarm-mode",
"tls_disabled": False,
"network_driver": None,
"volume_driver": None,
"labels": {},
"public": False,
"dns_nameserver": "8.8.8.8",
"flavor_id": data_utils.rand_name('bay'),
"master_flavor_id": data_utils.rand_name('bay'),
"external_network_id": config.Config.nic_id,
"keypair_id": data_utils.rand_name('bay'),
"image_id": data_utils.rand_name('bay')
}
data.update(kwargs)
model = baymodel_model.BayModelEntity.from_dict(data)
return model
def test_create_list_update_show_delete_security_group(self):
group_create_body, _ = self._create_security_group()
# List security groups and verify if created group is there in response
list_body = self.security_groups_client.list_security_groups()
secgroup_list = list()
for secgroup in list_body['security_groups']:
secgroup_list.append(secgroup['id'])
self.assertIn(group_create_body['security_group']['id'], secgroup_list)
# Update the security group
new_name = data_utils.rand_name('security-')
new_description = data_utils.rand_name('security-description')
update_body = self.security_groups_client.update_security_group(
group_create_body['security_group']['id'],
name=new_name,
description=new_description)
# Verify if security group is updated
self.assertEqual(update_body['security_group']['name'], new_name)
self.assertEqual(update_body['security_group']['description'],
new_description)
# Show details of the updated security group
show_body = self.security_groups_client.show_security_group(
group_create_body['security_group']['id'])
self.assertEqual(show_body['security_group']['name'], new_name)
self.assertEqual(show_body['security_group']['description'],
new_description)
def test_copy_object_in_same_container(self):
# create source object
src_object_name = data_utils.rand_name(name='SrcObject')
src_data = data_utils.random_bytes(size=len(src_object_name) * 2)
resp, _ = self.object_client.create_object(self.container_name,
src_object_name,
src_data)
# create destination object
dst_object_name = data_utils.rand_name(name='DstObject')
dst_data = data_utils.random_bytes(size=len(dst_object_name) * 3)
resp, _ = self.object_client.create_object(self.container_name,
dst_object_name,
dst_data)
# copy source object to destination
headers = {}
headers['X-Copy-From'] = "%s/%s" % (str(self.container_name),
str(src_object_name))
resp, body = self.object_client.create_object(self.container_name,
dst_object_name,
data=None,
headers=headers)
self.assertHeaders(resp, 'Object', 'PUT')
# check data
resp, body = self.object_client.get_object(self.container_name,
dst_object_name)
self.assertEqual(body, src_data)
def test_create_update_and_delete_domain_config_groups_and_opts(self):
domain, _ = self._create_domain_and_config(self.custom_config)
# Check that updating configuration groups work.
new_driver = data_utils.rand_name('driver')
new_limit = data_utils.rand_int_id(0, 100)
new_group_config = {'identity': {'driver': new_driver,
'list_limit': new_limit}}
updated_config = self.client.update_domain_group_config(
domain['id'], 'identity', **new_group_config)['config']
self.assertEqual(new_driver, updated_config['identity']['driver'])
self.assertEqual(new_limit, updated_config['identity']['list_limit'])
# Check that updating individual configuration group options work.
new_driver = data_utils.rand_name('driver')
updated_config = self.client.update_domain_group_option_config(
domain['id'], 'identity', 'driver', driver=new_driver)['config']
self.assertEqual(new_driver, updated_config['identity']['driver'])
# Check that deleting individual configuration group options work.
self.client.delete_domain_group_option_config(
domain['id'], 'identity', 'driver')
self.assertRaises(lib_exc.NotFound,
self.client.show_domain_group_option_config,
domain['id'], 'identity', 'driver')
# Check that deleting configuration groups work.
self.client.delete_domain_group_config(domain['id'], 'identity')
self.assertRaises(lib_exc.NotFound,
self.client.show_domain_group_config,
domain['id'], 'identity')
def cluster_template_data(**kwargs):
"""Generates random cluster_template data
Keypair and image id cannot be random for the cluster_template to be valid
due to validations for the presence of keypair and image id prior to
cluster_template creation.
:param keypair_id: keypair name
:param image_id: image id or name
:returns: ClusterTemplateEntity with generated data
"""
data = {
"name": data_utils.rand_name('cluster'),
"coe": "swarm",
"tls_disabled": False,
"network_driver": None,
"volume_driver": None,
"docker_volume_size": 3,
"labels": {},
"public": False,
"dns_nameserver": "8.8.8.8",
"flavor_id": data_utils.rand_name('cluster'),
"master_flavor_id": data_utils.rand_name('cluster'),
"external_network_id": config.Config.nic_id,
"keypair_id": data_utils.rand_name('cluster'),
"image_id": data_utils.rand_name('cluster')
}
data.update(kwargs)
model = cluster_template_model.ClusterTemplateEntity.from_dict(data)
return model
def resource_setup(cls):
super(EndPointsTestJSON, cls).resource_setup()
cls.service_ids = list()
s_name = data_utils.rand_name('service')
s_type = data_utils.rand_name('type')
s_description = data_utils.rand_name('description')
service_data = cls.services_client.create_service(
name=s_name, type=s_type,
description=s_description)['OS-KSADM:service']
cls.service_id = service_data['id']
cls.service_ids.append(cls.service_id)
# Create endpoints so as to use for LIST and GET test cases
cls.setup_endpoints = list()
for _ in range(2):
region = data_utils.rand_name('region')
url = data_utils.rand_url()
endpoint = cls.endpoints_client.create_endpoint(
service_id=cls.service_id,
region=region,
publicurl=url,
adminurl=url,
internalurl=url)['endpoint']
# list_endpoints() will return 'enabled' field
endpoint['enabled'] = True
cls.setup_endpoints.append(endpoint)
def _get_updated_quotas(self):
# Verify that GET shows the updated quota set of project
project_name = data_utils.rand_name('cpu_quota_project')
project_desc = project_name + '-desc'
project = identity.identity_utils(self.os_admin).create_project(
name=project_name, description=project_desc)
project_id = project['id']
self.addCleanup(identity.identity_utils(self.os_admin).delete_project,
project_id)
self.adm_client.update_quota_set(project_id, ram='5120')
# Call show_quota_set with detail=true to cover the
# get_quota_set_details response schema for microversion tests
quota_set = self.adm_client.show_quota_set(
project_id, detail=True)['quota_set']
self.assertEqual(5120, quota_set['ram']['limit'])
# Verify that GET shows the updated quota set of user
user_name = data_utils.rand_name('cpu_quota_user')
password = data_utils.rand_password()
email = user_name + '@testmail.tm'
user = identity.identity_utils(self.os_admin).create_user(
username=user_name, password=password, project=project,
email=email)
user_id = user['id']
self.addCleanup(identity.identity_utils(self.os_admin).delete_user,
user_id)
self.adm_client.update_quota_set(project_id,
user_id=user_id,
ram='2048')
quota_set = self.adm_client.show_quota_set(
project_id, user_id=user_id)['quota_set']
self.assertEqual(2048, quota_set['ram'])
def test_to_verify_communication_between_two_vms_in_diff_network(self):
net_id = self.network['id']
name = data_utils.rand_name('server-smoke')
group_create_body = self._create_custom_security_group()
serverid = self._create_server_with_sec_group(
name, net_id, group_create_body['security_group']['id'])
self.assertTrue(self.verify_portgroup(self.network['id'], serverid))
deviceport = self.ports_client.list_ports(device_id=serverid)
body = self._associate_floating_ips(
port_id=deviceport['ports'][0]['id'])
fip1 = body['floatingip']['floating_ip_address']
network2 = self.create_network()
sub_cidr = netaddr.IPNetwork(CONF.network.project_network_cidr).next()
subnet2 = self.create_subnet(network2, cidr=sub_cidr)
router2 = self.create_router(data_utils.rand_name('router2-'),
external_network_id=self.ext_net_id,
admin_state_up="true")
self.create_router_interface(router2['id'], subnet2['id'])
serverid2 = self._create_server_with_sec_group(
name, network2['id'], group_create_body['security_group']['id'])
deviceport2 = self.ports_client.list_ports(device_id=serverid2)
body = self._associate_floating_ips(
port_id=deviceport2['ports'][0]['id'])
fip2 = body['floatingip']['floating_ip_address']
self.assertTrue(self.verify_portgroup(self.network['id'], serverid))
self.assertTrue(self.verify_portgroup(network2['id'], serverid2))
self.assertTrue(self._check_remote_connectivity(fip1, fip2))
def test_creation_of_VM_attach_to_user_created_port(self):
group_create_body = self._create_custom_security_group()
network = self.create_network()
subnet = self.create_subnet(network)
router = self.create_router(data_utils.rand_name('router-'),
external_network_id=self.ext_net_id,
admin_state_up="true")
self.create_router_interface(router['id'], subnet['id'])
post_body = {
"name": data_utils.rand_name('port-'),
"security_groups": [group_create_body['security_group']['id']],
"network_id": network['id'],
"admin_state_up": True}
port = self.ports_client.create_port(**post_body)
self.addCleanup(self.ports_client.delete_port, port['port']['id'])
name = data_utils.rand_name('server-smoke')
group_create_body, _ = self._create_security_group()
serverid = self._create_server_user_created_port(
name, port['port']['id'])
self.assertTrue(self.verify_portgroup(network['id'], serverid))
deviceport = self.ports_client.list_ports(device_id=serverid)
body = self._associate_floating_ips(
port_id=deviceport['ports'][0]['id'])
floatingiptoreach = body['floatingip']['floating_ip_address']
self._check_public_network_connectivity(floatingiptoreach)
def test_create_update_get_delete_region(self):
# Create region
r_description = data_utils.rand_name('description')
region = self.client.create_region(
description=r_description,
parent_region_id=self.setup_regions[0]['id'])['region']
# This test will delete the region as part of the validation
# procedure, so it needs a different cleanup method that
# would be useful in case the tests fails at any point before
# reaching the deletion part.
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.client.delete_region, region['id'])
self.assertEqual(r_description, region['description'])
self.assertEqual(self.setup_regions[0]['id'],
region['parent_region_id'])
# Update region with new description and parent ID
r_alt_description = data_utils.rand_name('description')
region = self.client.update_region(
region['id'],
description=r_alt_description,
parent_region_id=self.setup_regions[1]['id'])['region']
self.assertEqual(r_alt_description, region['description'])
self.assertEqual(self.setup_regions[1]['id'],
region['parent_region_id'])
# Get the details of region
region = self.client.show_region(region['id'])['region']
self.assertEqual(r_alt_description, region['description'])
self.assertEqual(self.setup_regions[1]['id'],
region['parent_region_id'])
# Delete the region
self.client.delete_region(region['id'])
body = self.client.list_regions()['regions']
regions_list = [r['id'] for r in body]
self.assertNotIn(region['id'], regions_list)
def _create_share_and_share_network(self):
name = data_utils.rand_name('autotest_share_name')
description = data_utils.rand_name('autotest_share_description')
common_share_network = self.client.get_share_network(
self.client.share_network)
neutron_net_id = (
common_share_network['neutron_net_id']
if 'none' not in common_share_network['neutron_net_id'].lower()
else None)
neutron_subnet_id = (
common_share_network['neutron_subnet_id']
if 'none' not in common_share_network['neutron_subnet_id'].lower()
else None)
share_network = self.client.create_share_network(
neutron_net_id=neutron_net_id,
neutron_subnet_id=neutron_subnet_id,
)
self.share = self.create_share(
share_protocol=self.protocol,
size=1,
name=name,
description=description,
share_network=share_network['id'],
client=self.client,
wait_for_creation=True
)
self.share = self.client.get_share(self.share['id'])
return self.share, share_network
def create_share(self, share_protocol=None, size=None,
name=None, snapshot_id=None, description=None,
metadata=None, share_network_id=None,
share_type_id=None, is_public=False):
metadata = metadata or {}
if name is None:
name = data_utils.rand_name("tempest-created-share")
if description is None:
description = data_utils.rand_name("tempest-created-share-desc")
if size is None:
size = self.share_size
if share_protocol is None:
share_protocol = self.share_protocol
if share_protocol is None:
raise share_exceptions.ShareProtocolNotSpecified()
post_body = {
"share": {
"share_proto": share_protocol,
"description": description,
"snapshot_id": snapshot_id,
"name": name,
"size": size,
"metadata": metadata,
"is_public": is_public,
}
}
if share_network_id:
post_body["share"]["share_network_id"] = share_network_id
if share_type_id:
post_body["share"]["share_type"] = share_type_id
body = json.dumps(post_body)
resp, body = self.post("shares", body)
self.expected_success(200, resp.status)
return self._parse_resp(body)
def resource_setup(cls):
super(ConsistencyGroupsNegativeTest, cls).resource_setup()
# Create share_type
name = data_utils.rand_name("tempest-manila")
extra_specs = cls.add_required_extra_specs_to_dict()
share_type = cls.create_share_type(name, extra_specs=extra_specs)
cls.share_type = share_type['share_type']
# Create a consistency group
cls.consistency_group = cls.create_consistency_group(
share_type_ids=[cls.share_type['id']])
# Create share inside consistency group
cls.share_name = data_utils.rand_name("tempest-share-name")
cls.share_desc = data_utils.rand_name("tempest-share-description")
cls.share_size = 1
cls.share = cls.create_share(
name=cls.share_name,
description=cls.share_desc,
size=cls.share_size,
consistency_group_id=cls.consistency_group['id'],
share_type_id=cls.share_type['id'],
)
# Create a cgsnapshot of the consistency group
cls.cgsnap_name = data_utils.rand_name("tempest-cgsnap-name")
cls.cgsnap_desc = data_utils.rand_name("tempest-cgsnap-description")
cls.cgsnapshot = cls.create_cgsnapshot_wait_for_active(
cls.consistency_group["id"],
name=cls.cgsnap_name,
description=cls.cgsnap_desc)
def test_service_set(self):
service_name = self._create_dummy_service()
# set service
new_service_name = data_utils.rand_name("NewTestService")
new_service_description = data_utils.rand_name("description")
new_service_type = data_utils.rand_name("NewTestType")
raw_output = self.openstack(
"service set "
"--type %(type)s "
"--name %(name)s "
"--description %(description)s "
"--disable "
"%(service)s"
% {
"type": new_service_type,
"name": new_service_name,
"description": new_service_description,
"service": service_name,
}
)
self.assertEqual(0, len(raw_output))
# get service details
raw_output = self.openstack("service show %s" % new_service_name)
# assert service details
service = self.parse_show_as_object(raw_output)
self.assertEqual(new_service_type, service["type"])
self.assertEqual(new_service_name, service["name"])
self.assertEqual(new_service_description, service["description"])
def test_create_update_get_delete_record(self):
# Create Domain
name = data_utils.rand_name('domain') + '.com.'
email = data_utils.rand_name('dns') + '@testmail.com'
_, domain = self.os.domains_client.create_domain(name, email)
self.addCleanup(self.os.domains_client.delete_domain, domain['id'])
# Create Record
r_name = 'www.' + name
r_data = "192.0.2.4"
_, record = self.client.create_record(domain['id'],
name=r_name, data=r_data,
type='A')
self.addCleanup(self._delete_record, domain['id'], record['id'])
self.assertIsNotNone(record['id'])
self.assertEqual(domain['id'], record['domain_id'])
self.assertEqual(r_name, record['name'])
self.assertEqual(r_data, record['data'])
self.assertEqual('A', record['type'])
# Update Record with data and ttl
r_data1 = "192.0.2.5"
r_ttl = 3600
_, update_record = self.client.update_record(domain['id'],
record['id'],
name=r_name, type='A',
data=r_data1, ttl=r_ttl)
self.assertEqual(r_data1, update_record['data'])
self.assertEqual(r_ttl, update_record['ttl'])
# GET record
_, get_record = self.client.get_record(domain['id'], record['id'])
self.assertEqual(update_record['data'], get_record['data'])
self.assertEqual(update_record['name'], get_record['name'])
self.assertEqual(update_record['type'], get_record['type'])
self.assertEqual(update_record['ttl'], get_record['ttl'])
self.assertEqual(update_record['domain_id'], get_record['domain_id'])
def test_check_simple_image_attributes(self):
name = data_utils.rand_name('image')
desc = data_utils.rand_name('desc for image')
image_id, image_clean = self._create_image(name, desc)
data = self.client.describe_image_attribute(
ImageId=image_id, Attribute='kernel')
self.assertIn('KernelId', data)
data = self.client.describe_image_attribute(
ImageId=image_id, Attribute='ramdisk')
self.assertIn('RamdiskId', data)
# description
data = self.client.describe_image_attribute(
ImageId=image_id, Attribute='description')
self.assertIn('Description', data)
self.assertIn('Value', data['Description'])
self.assertEqual(desc, data['Description']['Value'])
def _modify_description(**kwargs):
self.client.modify_image_attribute(ImageId=image_id, **kwargs)
data = self.client.describe_image_attribute(
ImageId=image_id, Attribute='description')
self.assertEqual(new_desc, data['Description']['Value'])
new_desc = data_utils.rand_name('new desc')
_modify_description(Attribute='description', Value=new_desc)
_modify_description(Description={'Value': new_desc})
data = self.client.deregister_image(ImageId=image_id)
self.cancelResourceCleanUp(image_clean)
def test_create_update_delete_ike_policy(self):
# Creates a IKE policy
name = data_utils.rand_name('ike-policy')
body = (self.client.create_ikepolicy(
name=name,
ike_version="v1",
encryption_algorithm="aes-128",
auth_algorithm="sha1"))
ikepolicy = body['ikepolicy']
self.assertIsNotNone(ikepolicy['id'])
self.addCleanup(self._delete_ike_policy, ikepolicy['id'])
# Update IKE Policy
new_ike = {'name': data_utils.rand_name("New-IKE"),
'description': "Updated ike policy",
'encryption_algorithm': "aes-256",
'ike_version': "v2",
'pfs': "group14",
'lifetime': {'units': "seconds", 'value': 2000}}
self.client.update_ikepolicy(ikepolicy['id'], **new_ike)
# Confirm that update was successful by verifying using 'show'
body = self.client.show_ikepolicy(ikepolicy['id'])
ike_policy = body['ikepolicy']
for key, value in six.iteritems(new_ike):
self.assertIn(key, ike_policy)
self.assertEqual(value, ike_policy[key])
# Verification of ike policy delete
self.client.delete_ikepolicy(ikepolicy['id'])
body = self.client.list_ikepolicies()
ikepolicies = [ikp['id'] for ikp in body['ikepolicies']]
self.assertNotIn(ike_policy['id'], ikepolicies)
def test_create_update_delete_tag(self):
# Create a namespace
namespace = self.create_namespace()
self._create_namespace_tags(namespace)
# Create a tag
tag_name = data_utils.rand_name('tag_name')
self.namespace_tags_client.create_namespace_tag(
namespace=namespace['namespace'], tag_name=tag_name)
body = self.namespace_tags_client.show_namespace_tag(
namespace['namespace'], tag_name)
self.assertEqual(tag_name, body['name'])
# Update tag definition
update_tag_definition = data_utils.rand_name('update-tag')
body = self.namespace_tags_client.update_namespace_tag(
namespace['namespace'], tag_name=tag_name,
name=update_tag_definition)
self.assertEqual(update_tag_definition, body['name'])
# Delete tag definition
self.namespace_tags_client.delete_namespace_tag(
namespace['namespace'], update_tag_definition)
# List namespace tags and validate deletion
namespace_tags = [
namespace_tag['name'] for namespace_tag in
self.namespace_tags_client.list_namespace_tags(
namespace['namespace'])['tags']]
self.assertNotIn(update_tag_definition, namespace_tags)
def test_group_type_create_list_show(self):
# Create/list/show group type.
name = data_utils.rand_name(self.__class__.__name__ + '-group-type')
description = data_utils.rand_name("group-type-description")
group_specs = {"consistent_group_snapshot_enabled": "<is> False"}
params = {'name': name,
'description': description,
'group_specs': group_specs,
'is_public': True}
body = self.create_group_type(**params)
self.assertIn('name', body)
err_msg = ("The created group_type %(var)s is not equal to the "
"requested %(var)s")
self.assertEqual(name, body['name'], err_msg % {"var": "name"})
self.assertEqual(description, body['description'],
err_msg % {"var": "description"})
group_list = (
self.admin_group_types_client.list_group_types()['group_types'])
self.assertIsInstance(group_list, list)
self.assertNotEmpty(group_list)
fetched_group_type = self.admin_group_types_client.show_group_type(
body['id'])['group_type']
for key in params.keys():
self.assertEqual(params[key], fetched_group_type[key],
'%s of the fetched group_type is different '
'from the created group_type' % key)
def test_get_share_with_share_type(self):
# Data
share_name = data_utils.rand_name("share")
shr_type_name = data_utils.rand_name("share-type")
extra_specs = self.add_required_extra_specs_to_dict({
"storage_protocol": CONF.share.capability_storage_protocol,
})
# Create share type
st_create = self.create_share_type(
shr_type_name, extra_specs=extra_specs)
# Create share with share type
share = self.create_share(
name=share_name, share_type_id=st_create["share_type"]["id"])
self.assertEqual(share["name"], share_name)
self.shares_client.wait_for_share_status(share["id"], "available")
# Verify share info
get = self.shares_v2_client.get_share(share["id"], version="2.5")
self.assertEqual(share_name, get["name"])
self.assertEqual(share["id"], get["id"])
self.assertEqual(shr_type_name, get["share_type"])
get = self.shares_v2_client.get_share(share["id"], version="2.6")
self.assertEqual(st_create["share_type"]["id"], get["share_type"])
self.assertEqual(shr_type_name, get["share_type_name"])
def setUpClass(cls):
# prepare v3 env
os.environ['OS_IDENTITY_API_VERSION'] = '3'
auth_url = os.environ.get('OS_AUTH_URL')
auth_url = auth_url.replace('v2.0', 'v3')
os.environ['OS_AUTH_URL'] = auth_url
# create dummy domain
cls.domain_name = data_utils.rand_name('TestDomain')
cls.domain_description = data_utils.rand_name('description')
cls.openstack(
'domain create '
'--description %(description)s '
'--enable '
'%(name)s' % {'description': cls.domain_description,
'name': cls.domain_name})
# create dummy project
cls.project_name = data_utils.rand_name('TestProject')
cls.project_description = data_utils.rand_name('description')
cls.openstack(
'project create '
'--domain %(domain)s '
'--description %(description)s '
'--enable '
'%(name)s' % {'domain': cls.domain_name,
'description': cls.project_description,
'name': cls.project_name})
def _check_create_cluster_template(self):
ng_template_name = data_utils.rand_name('sahara-ng-template')
ng_template = self.create_node_group_template(ng_template_name,
**self.worker_template)
full_cluster_template = self.cluster_template.copy()
full_cluster_template['node_groups'] = [
{
'name': 'master-node',
'flavor_id': TEMPEST_CONF.compute.flavor_ref,
'node_processes': ['namenode'],
'count': 1
},
{
'name': 'worker-node',
'node_group_template_id': ng_template.id,
'count': 3
}
]
template_name = data_utils.rand_name('sahara-cluster-template')
# create cluster template
resp_body = self.create_cluster_template(template_name,
**full_cluster_template)
# check that template created successfully
self.assertEqual(template_name, resp_body.name)
self.assertDictContainsSubset(self.cluster_template,
resp_body.__dict__)
return resp_body.id, template_name
def _create_dummy_user(self, add_clean_up=True):
username = data_utils.rand_name('TestUser')
password = data_utils.rand_name('password')
email = data_utils.rand_name() + '@example.com'
description = data_utils.rand_name('description')
raw_output = self.openstack(
'user create '
'--domain %(domain)s '
'--project %(project)s '
'--project-domain %(project_domain)s '
'--password %(password)s '
'--email %(email)s '
'--description %(description)s '
'--enable '
'%(name)s' % {'domain': self.domain_name,
'project': self.project_name,
'project_domain': self.domain_name,
'email': email,
'password': password,
'description': description,
'name': username})
if add_clean_up:
self.addCleanup(
self.openstack,
'user delete %s' % self.parse_show_as_object(raw_output)['id'])
items = self.parse_show(raw_output)
self.assert_show_fields(items, self.USER_FIELDS)
return username
def test_application_credential_create_with_options(self):
name = data_utils.rand_name('name')
secret = data_utils.rand_name('secret')
description = data_utils.rand_name('description')
tomorrow = (datetime.datetime.utcnow() +
datetime.timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S%z')
role1, role2 = self._create_role_assignments()
raw_output = self.openstack('application credential create %(name)s'
' --secret %(secret)s'
' --description %(description)s'
' --expiration %(tomorrow)s'
' --role %(role1)s'
' --role %(role2)s'
' --unrestricted'
% {'name': name,
'secret': secret,
'description': description,
'tomorrow': tomorrow,
'role1': role1,
'role2': role2})
self.addCleanup(
self.openstack,
'application credential delete %(name)s' % {'name': name})
items = self.parse_show(raw_output)
self.assert_show_fields(items, self.APPLICATION_CREDENTIAL_FIELDS)
def create_trustor_and_roles(self):
# create a project that trusts will be granted on
trustor_project_name = data_utils.rand_name(name='project')
project = self.projects_client.create_project(
trustor_project_name,
domain_id=CONF.identity.default_domain_id)['project']
self.trustor_project_id = project['id']
self.assertIsNotNone(self.trustor_project_id)
# Create a trustor User
trustor_username = data_utils.rand_name('user')
u_desc = trustor_username + 'description'
u_email = trustor_username + '@testmail.xx'
trustor_password = data_utils.rand_password()
user = self.users_client.create_user(
name=trustor_username,
description=u_desc,
password=trustor_password,
email=u_email,
project_id=self.trustor_project_id,
domain_id=CONF.identity.default_domain_id)['user']
self.trustor_user_id = user['id']
# And two roles, one we'll delegate and one we won't
self.delegated_role = data_utils.rand_name('DelegatedRole')
self.not_delegated_role = data_utils.rand_name('NotDelegatedRole')
role = self.roles_client.create_role(name=self.delegated_role)['role']
self.delegated_role_id = role['id']
role = self.roles_client.create_role(
name=self.not_delegated_role)['role']
self.not_delegated_role_id = role['id']
# Assign roles to trustor
self.roles_client.create_user_role_on_project(
self.trustor_project_id,
self.trustor_user_id,
self.delegated_role_id)
self.roles_client.create_user_role_on_project(
self.trustor_project_id,
self.trustor_user_id,
self.not_delegated_role_id)
# Get trustee user ID, use the demo user
trustee_username = self.non_admin_client.user
self.trustee_user_id = self.get_user_by_name(trustee_username)['id']
self.assertIsNotNone(self.trustee_user_id)
# Initialize a new client with the trustor credentials
creds = common_creds.get_credentials(
identity_version='v3',
username=trustor_username,
password=trustor_password,
user_domain_id=CONF.identity.default_domain_id,
tenant_name=trustor_project_name,
project_domain_id=CONF.identity.default_domain_id,
domain_id=CONF.identity.default_domain_id)
os = clients.Manager(credentials=creds)
self.trustor_client = os.trusts_client
def test_tag_security_group(self):
cidr = '10.1.0.0/16'
data = self.client.create_vpc(CidrBlock=cidr)
vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(
self.client.delete_vpc, VpcId=vpc_id)
name = data_utils.rand_name('sgName')
desc = data_utils.rand_name('sgDesc')
data = self.client.create_security_group(VpcId=vpc_id,
GroupName=name,
Description=desc)
group_id = data['GroupId']
res_clean = self.addResourceCleanUp(self.client.delete_security_group,
GroupId=group_id)
time.sleep(2)
def describe_func(*args, **kwargs):
data = self.client.describe_security_groups(*args, **kwargs)
self.assertEqual(1, len(data['SecurityGroups']))
self.assertEqual(group_id,
data['SecurityGroups'][0]['GroupId'])
self._test_tag_resource(group_id, 'security-group', describe_func)
self.client.delete_security_group(GroupId=group_id)
self.cancelResourceCleanUp(res_clean)
self.client.delete_vpc(VpcId=vpc_id)
self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id)
def test_project_create(self):
project_name = data_utils.rand_name('TestProject')
description = data_utils.rand_name('description')
raw_output = self.openstack(
'project create '
'--domain %(domain)s '
'--description %(description)s '
'--enable '
'--property k1=v1 '
'--property k2=v2 '
'%(name)s' % {'domain': self.domain_name,
'description': description,
'name': project_name})
self.addCleanup(
self.openstack,
'project delete '
'--domain %(domain)s '
'%(name)s' % {'domain': self.domain_name,
'name': project_name}
)
items = self.parse_show(raw_output)
show_fields = list(self.PROJECT_FIELDS)
show_fields.extend(['k1', 'k2'])
self.assert_show_fields(items, show_fields)
project = self.parse_show_as_object(raw_output)
self.assertEqual('v1', project['k1'])
self.assertEqual('v2', project['k2'])
def test_add_multiple_router_interfaces(self):
network_name = data_utils.rand_name(self.__class__.__name__)
network01 = self.networks_client.create_network(
name=network_name)['network']
self.addCleanup(self.networks_client.delete_network,
network01['id'])
network_name = data_utils.rand_name(self.__class__.__name__)
network02 = self.networks_client.create_network(
name=network_name)['network']
self.addCleanup(self.networks_client.delete_network,
network02['id'])
subnet01 = self.create_subnet(network01)
self.addCleanup(self.subnets_client.delete_subnet, subnet01['id'])
sub02_cidr = self.cidr.next()
subnet02 = self.create_subnet(network02, cidr=sub02_cidr)
self.addCleanup(self.subnets_client.delete_subnet, subnet02['id'])
router = self.create_router()
self.addCleanup(self.delete_router, router)
interface01 = self._add_router_interface_with_subnet_id(router['id'],
subnet01['id'])
self._verify_router_interface(router['id'], subnet01['id'],
interface01['port_id'])
interface02 = self._add_router_interface_with_subnet_id(router['id'],
subnet02['id'])
self._verify_router_interface(router['id'], subnet02['id'],
interface02['port_id'])
def test_update_consistency_group_v2_4(self):
# Get consistency_group
consistency_group = self.shares_v2_client.get_consistency_group(
self.consistency_group['id'], version='2.4')
self.assertEqual(self.cg_name, consistency_group["name"])
self.assertEqual(self.cg_desc, consistency_group["description"])
# Update consistency_group
new_name = data_utils.rand_name("tempest-new-name")
new_desc = data_utils.rand_name("tempest-new-description")
updated = self.shares_v2_client.update_consistency_group(
consistency_group["id"],
name=new_name,
description=new_desc,
version='2.4'
)
self.assertEqual(new_name, updated["name"])
self.assertEqual(new_desc, updated["description"])
# Get consistency_group
consistency_group = self.shares_v2_client.get_consistency_group(
self.consistency_group['id'], version='2.4')
self.assertEqual(new_name, consistency_group["name"])
self.assertEqual(new_desc, consistency_group["description"])
def resource_setup(cls):
super(InheritsV3TestJSON, cls).resource_setup()
u_name = data_utils.rand_name('user-')
u_desc = '%s description' % u_name
u_email = '*****@*****.**' % u_name
u_password = data_utils.rand_password()
cls.domain = cls.create_domain()
cls.project = cls.projects_client.create_project(
data_utils.rand_name('project-'),
description=data_utils.rand_name('project-desc-'),
domain_id=cls.domain['id'])['project']
cls.addClassResourceCleanup(cls.projects_client.delete_project,
cls.project['id'])
cls.group = cls.groups_client.create_group(
name=data_utils.rand_name('group-'), project_id=cls.project['id'],
domain_id=cls.domain['id'])['group']
cls.addClassResourceCleanup(cls.groups_client.delete_group,
cls.group['id'])
if not CONF.identity_feature_enabled.immutable_user_source:
cls.user = cls.users_client.create_user(
name=u_name,
description=u_desc,
password=u_password,
email=u_email,
project_id=cls.project['id'],
domain_id=cls.domain['id']
)['user']
cls.addClassResourceCleanup(cls.users_client.delete_user,
cls.user['id'])
def test_update_non_existent_subnetpool(self):
non_exist_id = data_utils.rand_name('subnetpool')
self.assertRaises(lib_exc.NotFound, self.client.update_subnetpool,
non_exist_id, name='foo-name')
def test_delete_non_existent_subnetpool(self):
non_exist_id = data_utils.rand_name('subnetpool')
self.assertRaises(lib_exc.NotFound, self.client.delete_subnetpool,
non_exist_id)
def test_tenant_create_subnetpool_associate_shared_address_scope(self):
address_scope = self.create_address_scope(
name=data_utils.rand_name('smoke-address-scope'), is_admin=True,
shared=True, ip_version=4)
self.assertRaises(lib_exc.BadRequest, self._create_subnetpool,
address_scope_id=address_scope['id'])
def test_create_subnetpool_associate_address_scope_of_other_owner(self):
address_scope = self.create_address_scope(
name=data_utils.rand_name('smoke-address-scope'), is_admin=True,
ip_version=4)
self.assertRaises(lib_exc.NotFound, self._create_subnetpool,
address_scope_id=address_scope['id'])
def create_ssh_security_group(clients,
add_rule=False,
ethertype='IPv4',
use_neutron=True):
"""Create a security group for ping/ssh testing
Create a security group to be attached to a VM using the nova or neutron
clients. If rules are added, the group can be attached to a VM to enable
connectivity validation over ICMP and further testing over SSH.
:param clients: Instance of `tempest.lib.services.clients.ServiceClients`
or of a subclass of it. Resources are provisioned using clients from
`clients`.
:param add_rule: Whether security group rules are provisioned or not.
Defaults to `False`.
:param ethertype: 'IPv4' or 'IPv6'. Honoured only in case neutron is used.
:param use_neutron: When True resources are provisioned via neutron, when
False resources are provisioned via nova.
:returns: A dictionary with the security group as returned by the API.
Examples::
from tempest.common import validation_resources as vr
from tempest.lib import auth
from tempest.lib.services import clients
creds = auth.get_credentials('http://mycloud/identity/v3',
username='******', project_name='me',
password='******', domain_name='Default')
osclients = clients.ServiceClients(creds, 'http://mycloud/identity/v3')
# Security group for IPv4 tests
sg4 = vr.create_ssh_security_group(osclients, add_rule=True)
# Security group for IPv6 tests
sg6 = vr.create_ssh_security_group(osclients, ethertype='IPv6',
add_rule=True)
"""
network_service = _network_service(clients, use_neutron)
security_groups_client = network_service.SecurityGroupsClient()
security_group_rules_client = network_service.SecurityGroupRulesClient()
# Security Group clients for nova and neutron behave the same
sg_name = data_utils.rand_name('securitygroup-')
sg_description = data_utils.rand_name('description-')
security_group = security_groups_client.create_security_group(
name=sg_name, description=sg_description)['security_group']
# Security Group Rules clients require different parameters depending on
# the network service in use
if add_rule:
try:
if use_neutron:
security_group_rules_client.create_security_group_rule(
security_group_id=security_group['id'],
protocol='tcp',
ethertype=ethertype,
port_range_min=22,
port_range_max=22,
direction='ingress')
security_group_rules_client.create_security_group_rule(
security_group_id=security_group['id'],
protocol='icmp',
ethertype=ethertype,
direction='ingress')
else:
security_group_rules_client.create_security_group_rule(
parent_group_id=security_group['id'],
ip_protocol='tcp',
from_port=22,
to_port=22)
security_group_rules_client.create_security_group_rule(
parent_group_id=security_group['id'],
ip_protocol='icmp',
from_port=-1,
to_port=-1)
except Exception as sgc_exc:
# If adding security group rules fails, we cleanup the SG before
# re-raising the failure up
with excutils.save_and_reraise_exception():
try:
msg = ('Error while provisioning security group rules in '
'security group %s. Trying to cleanup.')
# The exceptions logging is already handled, so using
# debug here just to provide more context
LOG.debug(msg, sgc_exc)
clear_validation_resources(clients,
keypair=None,
floating_ip=None,
security_group=security_group,
use_neutron=use_neutron)
except Exception as cleanup_exc:
msg = ('Error during cleanup of a security group. '
'The cleanup was triggered by an exception during '
'the provisioning of security group rules.\n'
'Provisioning exception: %s\n'
'First cleanup exception: %s')
LOG.exception(msg, sgc_exc, cleanup_exc)
LOG.debug(
"SSH Validation resource security group with tcp and icmp "
"rules %s created", sg_name)
return security_group
def create_share_network(self):
share_network = self._create_share_network(
neutron_net_id=self.network['id'],
neutron_subnet_id=self.subnet['id'],
name=data_utils.rand_name("sn-name"))
return share_network
def test_update_non_existent_router_returns_404(self):
router = data_utils.rand_name('non_exist_router')
self.assertRaises(lib_exc.NotFound, self.routers_client.update_router,
router, name="new_name")
def test_try_delete_share_type_by_nonexistent_id(self):
self.assertRaises(lib_exc.NotFound,
self.shares_client.delete_share_type,
data_utils.rand_name("fake"))
def test_create_share_with_nonexistent_share_type(self):
self.assertRaises(lib_exc.NotFound,
self.create_share,
share_type_id=data_utils.rand_name("fake"))
def _create_share_type(self):
name = data_utils.rand_name("unique_st_name")
extra_specs = self.add_required_extra_specs_to_dict({"key": "value"})
return self.create_share_type(name, extra_specs=extra_specs)
def _create_volume_from_image(self):
"""Create a cinder volume from the default image."""
image_id = CONF.compute.image_ref
vol_name = data_utils.rand_name(self.__class__.__name__ +
'-volume-origin')
return self.create_volume(name=vol_name, image_id=image_id)
def test_resize_server_revert_deleted_flavor(self):
"""Test reverting resized server with original flavor deleted
Tests that we can revert the resize on an instance whose original
flavor has been deleted.
"""
# First we have to create a flavor that we can delete so make a copy
# of the normal flavor from which we'd create a server.
flavor = self.admin_flavors_client.show_flavor(
self.flavor_ref)['flavor']
flavor = self.admin_flavors_client.create_flavor(
name=data_utils.rand_name('test_resize_flavor_'),
ram=flavor['ram'],
disk=flavor['disk'],
vcpus=flavor['vcpus'])['flavor']
self.addCleanup(self._flavor_clean_up, flavor['id'])
# Set extra specs same as self.flavor_ref for the created flavor,
# because the environment may need some special extra specs to
# create server which should have been contained in
# self.flavor_ref.
extra_spec_keys = self.admin_flavors_client.list_flavor_extra_specs(
self.flavor_ref)['extra_specs']
if extra_spec_keys:
self.admin_flavors_client.set_flavor_extra_spec(
flavor['id'], **extra_spec_keys)
# Now boot a server with the copied flavor.
server = self.create_test_server(wait_until='ACTIVE',
flavor=flavor['id'])
server = self.servers_client.show_server(server['id'])['server']
# If 'id' not in server['flavor'], we can only compare the flavor
# details, so here we should save the to-be-deleted flavor's details,
# for the flavor comparison after the server resizing.
if not server['flavor'].get('id'):
pre_flavor = {}
body = self.flavors_client.show_flavor(flavor['id'])['flavor']
for key in ['name', 'ram', 'vcpus', 'disk']:
pre_flavor[key] = body[key]
# Delete the flavor we used to boot the instance.
self._flavor_clean_up(flavor['id'])
# Now resize the server and wait for it to go into verify state.
self.servers_client.resize_server(server['id'], self.flavor_ref_alt)
waiters.wait_for_server_status(self.servers_client, server['id'],
'VERIFY_RESIZE')
# Now revert the resize, it should be OK even though the original
# flavor used to boot the server was deleted.
self.servers_client.revert_resize_server(server['id'])
waiters.wait_for_server_status(self.servers_client, server['id'],
'ACTIVE')
server = self.servers_client.show_server(server['id'])['server']
if server['flavor'].get('id'):
msg = ('server flavor is not same as flavor!')
self.assertEqual(flavor['id'], server['flavor']['id'], msg)
else:
self.assertEqual(
pre_flavor['name'], server['flavor']['original_name'],
"original_name in server flavor is not same as "
"flavor name!")
for key in ['ram', 'vcpus', 'disk']:
msg = ('attribute %s in server flavor is not same as '
'flavor!' % key)
self.assertEqual(pre_flavor[key], server['flavor'][key], msg)
def test_full_migration(self, test_type):
# We are testing with DHSS=True only because it allows us to specify
# new_share_network.
share = self.create_share(
share_protocol='nfs',
size=1,
name=data_utils.rand_name('autotest_share_name'),
client=self.get_user_client(),
share_type=self.old_type['ID'],
share_network=self.old_share_net['id'],
wait_for_creation=True)
share = self.admin_client.get_share(share['id'])
pools = self.admin_client.pool_list(detail=True)
dest_pool = utils.choose_matching_backend(
share, pools, self.new_type)
self.assertIsNotNone(dest_pool)
source_pool = share['host']
new_type = self.new_type
if test_type == 'error':
statuses = constants.TASK_STATE_MIGRATION_ERROR
new_type = self.error_type
else:
statuses = (constants.TASK_STATE_MIGRATION_DRIVER_PHASE1_DONE,
constants.TASK_STATE_DATA_COPYING_COMPLETED)
self.admin_client.migration_start(
share['id'], dest_pool, writable=True, nondisruptive=False,
preserve_metadata=True, preserve_snapshots=True,
force_host_assisted_migration=False,
new_share_network=self.new_share_net['id'],
new_share_type=new_type['ID'])
share = self.admin_client.wait_for_migration_task_state(
share['id'], dest_pool, statuses)
progress = self.admin_client.migration_get_progress(share['id'])
self.assertEqual('100', progress['total_progress'])
self.assertEqual(source_pool, share['host'])
self.assertEqual(self.old_type['ID'], share['share_type'])
self.assertEqual(self.old_share_net['id'], share['share_network_id'])
if test_type == 'error':
self.assertEqual(statuses, progress['task_state'])
else:
if test_type == 'success':
self.admin_client.migration_complete(share['id'])
statuses = constants.TASK_STATE_MIGRATION_SUCCESS
elif test_type == 'cancel':
self.admin_client.migration_cancel(share['id'])
statuses = constants.TASK_STATE_MIGRATION_CANCELLED
share = self.admin_client.wait_for_migration_task_state(
share['id'], dest_pool, statuses)
progress = self.admin_client.migration_get_progress(share['id'])
self.assertEqual(statuses, progress['task_state'])
if test_type == 'success':
self.assertEqual(dest_pool, share['host'])
self.assertEqual(new_type['ID'], share['share_type'])
self.assertEqual(self.new_share_net['id'],
share['share_network_id'])
else:
self.assertEqual(source_pool, share['host'])
self.assertEqual(self.old_type['ID'], share['share_type'])
self.assertEqual(self.old_share_net['id'],
share['share_network_id'])
def setUp(self):
super(ObjectACLsNegativeTest, self).setUp()
self.container_name = data_utils.rand_name(name='TestContainer')
self.container_client.create_container(self.container_name)
def test_update_all_tags(self):
new_tag_name = data_utils.rand_name(self.__class__.__name__ + '-tag')
with self.rbac_utils.override_role(self):
self.servers_client.update_all_tags(self.server['id'],
[new_tag_name])
def create_keypair(cls, client=None):
client = client or cls.manager.keypairs_client
name = data_utils.rand_name('keypair-test')
body = client.create_keypair(name=name)
cls.keypairs.append(body['keypair'])
return body['keypair']
def _update_project(self, project_uuid):
put_body = {'display_name': data_utils.rand_name('project')}
self.project_client.update_project(project_uuid, **put_body)
def resource_setup(cls):
super(UsersTestJSON, cls).resource_setup()
cls.alt_user = data_utils.rand_name('test_user')
cls.alt_email = cls.alt_user + '@testmail.tm'
def resource_setup(cls):
super(TestSubscriptions, cls).resource_setup()
cls.queue_name = data_utils.rand_name('Queues-Test')
# Create Queue
cls.client.create_queue(cls.queue_name)
def _add_tag_to_server(self):
tag_name = data_utils.rand_name(self.__class__.__name__ + '-tag')
self.servers_client.update_tag(self.server['id'], tag_name)
self.addCleanup(self.servers_client.delete_all_tags, self.server['id'])
return tag_name
def create_ssh_security_group(clients,
add_rule=False,
ethertype='IPv4',
use_neutron=True):
"""Create a security group for ping/ssh testing
Create a security group to be attached to a VM using the nova or neutron
clients. If rules are added, the group can be attached to a VM to enable
connectivity validation over ICMP and further testing over SSH.
:param clients: Instance of `tempest.lib.services.clients.ServiceClients`
or of a subclass of it. Resources are provisioned using clients from
`clients`.
:param add_rule: Whether security group rules are provisioned or not.
Defaults to `False`.
:param ethertype: 'IPv4' or 'IPv6'. Honoured only in case neutron is used.
:param use_neutron: When True resources are provisioned via neutron, when
False resources are provisioned via nova.
:returns: A dictionary with the security group as returned by the API.
Examples::
from tempest.common import validation_resources as vr
from tempest.lib import auth
from tempest.lib.services import clients
creds = auth.get_credentials('http://mycloud/identity/v3',
username='******', project_name='me',
password='******', domain_name='Default')
osclients = clients.ServiceClients(creds, 'http://mycloud/identity/v3')
# Security group for IPv4 tests
sg4 = vr.create_ssh_security_group(osclients, add_rule=True)
# Security group for IPv6 tests
sg6 = vr.create_ssh_security_group(osclients, ethertype='IPv6',
add_rule=True)
"""
network_service = _network_service(clients, use_neutron)
security_groups_client = network_service.SecurityGroupsClient()
security_group_rules_client = network_service.SecurityGroupRulesClient()
# Security Group clients for nova and neutron behave the same
sg_name = data_utils.rand_name('securitygroup-')
sg_description = data_utils.rand_name('description-')
security_group = security_groups_client.create_security_group(
name=sg_name, description=sg_description)['security_group']
# Security Group Rules clients require different parameters depending on
# the network service in use
if add_rule:
if use_neutron:
security_group_rules_client.create_security_group_rule(
security_group_id=security_group['id'],
protocol='tcp',
ethertype=ethertype,
port_range_min=22,
port_range_max=22,
direction='ingress')
security_group_rules_client.create_security_group_rule(
security_group_id=security_group['id'],
protocol='icmp',
ethertype=ethertype,
direction='ingress')
else:
security_group_rules_client.create_security_group_rule(
parent_group_id=security_group['id'],
ip_protocol='tcp',
from_port=22,
to_port=22)
security_group_rules_client.create_security_group_rule(
parent_group_id=security_group['id'],
ip_protocol='icmp',
from_port=-1,
to_port=-1)
LOG.debug(
"SSH Validation resource security group with tcp and icmp "
"rules %s created", sg_name)
return security_group
def _create_subnetpool(self, is_admin=False, **kwargs):
name = data_utils.rand_name('subnetpool-')
subnetpool_data = copy.deepcopy(self._subnetpool_data)
for key in subnetpool_data.keys():
kwargs[key] = subnetpool_data[key]
return self.create_subnetpool(name=name, is_admin=is_admin, **kwargs)
def create_server(self, name=None, image_id=None, flavor=None,
validatable=False, wait_until='ACTIVE',
clients=None, **kwargs):
"""Wrapper utility that returns a test server.
This wrapper utility calls the common create test server and
returns a test server. The purpose of this wrapper is to minimize
the impact on the code of the tests already using this
function.
"""
# NOTE(jlanoux): As a first step, ssh checks in the scenario
# tests need to be run regardless of the run_validation and
# validatable parameters and thus until the ssh validation job
# becomes voting in CI. The test resources management and IP
# association are taken care of in the scenario tests.
# Therefore, the validatable parameter is set to false in all
# those tests. In this way create_server just return a standard
# server and the scenario tests always perform ssh checks.
# Needed for the cross_tenant_traffic test:
if clients is None:
clients = self.manager
if name is None:
name = data_utils.rand_name(self.__class__.__name__ + "-server")
vnic_type = CONF.network.port_vnic_type
# If vnic_type is configured create port for
# every network
if vnic_type:
ports = []
create_port_body = {'binding:vnic_type': vnic_type,
'namestart': 'port-smoke'}
if kwargs:
# Convert security group names to security group ids
# to pass to create_port
if 'security_groups' in kwargs:
security_groups = \
clients.security_groups_client.list_security_groups(
).get('security_groups')
sec_dict = dict([(s['name'], s['id'])
for s in security_groups])
sec_groups_names = [s['name'] for s in kwargs.pop(
'security_groups')]
security_groups_ids = [sec_dict[s]
for s in sec_groups_names]
if security_groups_ids:
create_port_body[
'security_groups'] = security_groups_ids
networks = kwargs.pop('networks', [])
else:
networks = []
# If there are no networks passed to us we look up
# for the project's private networks and create a port.
# The same behaviour as we would expect when passing
# the call to the clients with no networks
if not networks:
networks = clients.networks_client.list_networks(
**{'router:external': False, 'fields': 'id'})['networks']
# It's net['uuid'] if networks come from kwargs
# and net['id'] if they come from
# clients.networks_client.list_networks
for net in networks:
net_id = net.get('uuid', net.get('id'))
if 'port' not in net:
port = self._create_port(network_id=net_id,
client=clients.ports_client,
**create_port_body)
ports.append({'port': port['id']})
else:
ports.append({'port': net['port']})
if ports:
kwargs['networks'] = ports
self.ports = ports
tenant_network = self.get_tenant_network()
body, servers = compute.create_test_server(
clients,
tenant_network=tenant_network,
wait_until=wait_until,
name=name, flavor=flavor,
image_id=image_id, **kwargs)
self.addCleanup(waiters.wait_for_server_termination,
clients.servers_client, body['id'])
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
clients.servers_client.delete_server, body['id'])
server = clients.servers_client.show_server(body['id'])['server']
return server
def _create_network_resources(self, tenant_id):
"""The function creates network resources in the given tenant.
The function checks if network_resources class member is empty,
In case it is, it will create a network, a subnet and a router for
the tenant according to the given tenant id parameter.
Otherwise it will create a network resource according
to the values from network_resources dict.
:param tenant_id: The tenant id to create resources for.
:type tenant_id: str
:raises: InvalidConfiguration, Exception
:returns: network resources(network,subnet,router)
:rtype: tuple
"""
network = None
subnet = None
router = None
# Make sure settings
if self.network_resources:
if self.network_resources['router']:
if (not self.network_resources['subnet'] or
not self.network_resources['network']):
raise lib_exc.InvalidConfiguration(
'A router requires a subnet and network')
elif self.network_resources['subnet']:
if not self.network_resources['network']:
raise lib_exc.InvalidConfiguration(
'A subnet requires a network')
elif self.network_resources['dhcp']:
raise lib_exc.InvalidConfiguration('DHCP requires a subnet')
rand_name_root = data_utils.rand_name(
self.name, prefix=self.resource_prefix)
if not self.network_resources or self.network_resources['network']:
network_name = rand_name_root + "-network"
network = self._create_network(network_name, tenant_id)
try:
if not self.network_resources or self.network_resources['subnet']:
subnet_name = rand_name_root + "-subnet"
subnet = self._create_subnet(subnet_name, tenant_id,
network['id'])
if not self.network_resources or self.network_resources['router']:
router_name = rand_name_root + "-router"
router = self._create_router(router_name, tenant_id)
self._add_router_interface(router['id'], subnet['id'])
except Exception:
try:
if router:
self._clear_isolated_router(router['id'], router['name'])
if subnet:
self._clear_isolated_subnet(subnet['id'], subnet['name'])
if network:
self._clear_isolated_network(network['id'],
network['name'])
except Exception as cleanup_exception:
msg = "There was an exception trying to setup network " \
"resources for tenant %s, and this error happened " \
"trying to clean them up: %s"
LOG.warning(msg % (tenant_id, cleanup_exception))
raise
return network, subnet, router
def resource_setup(cls):
super(DvrRoutersNegativeTest, cls).resource_setup()
cls.router = cls.create_router(data_utils.rand_name('router'))
cls.network = cls.create_network()
cls.subnet = cls.create_subnet(cls.network)
def create_topology_subnet(
self, subnet_name, network, routers_client=None,
subnets_client=None, router_id=None, ip_version=4, cidr=None,
mask_bits=None, **kwargs):
subnet_name_ = constants.APPLIANCE_NAME_STARTS_WITH + subnet_name
if not subnets_client:
subnets_client = self.subnets_client
if not routers_client:
routers_client = self.routers_client
def cidr_in_use(cidr, tenant_id):
"""Check cidr existence
:returns: True if subnet with cidr already exist in tenant
False else
"""
cidr_in_use = \
self.os_admin.subnets_client.list_subnets(
tenant_id=tenant_id, cidr=cidr)['subnets']
return len(cidr_in_use) != 0
if ip_version == 6:
tenant_cidr = (cidr or netaddr.IPNetwork(
CONF.network.project_network_v6_cidr))
mask_bits = mask_bits or CONF.network.project_network_v6_mask_bits
else:
tenant_cidr = cidr or netaddr.IPNetwork(
CONF.network.project_network_cidr)
mask_bits = mask_bits or CONF.network.project_network_mask_bits
str_cidr = str(tenant_cidr)
if not cidr:
# Repeatedly attempt subnet creation with sequential cidr
# blocks until an unallocated block is found.
for subnet_cidr in tenant_cidr.subnet(mask_bits):
str_cidr = str(subnet_cidr)
if not cidr_in_use(str_cidr, tenant_id=network['tenant_id']):
break
else:
if cidr_in_use(str_cidr, tenant_id=network['tenant_id']):
LOG.error("Specified subnet %r is in use" % str_cidr)
raise
subnet = dict(name=data_utils.rand_name(subnet_name_),
network_id=network['id'], tenant_id=network['tenant_id'],
cidr=str_cidr, ip_version=ip_version, **kwargs)
try:
result = None
result = subnets_client.create_subnet(**subnet)
except lib_exc.Conflict as e:
is_overlapping_cidr = 'overlaps with another subnet' in str(e)
if not is_overlapping_cidr:
raise
self.assertIsNotNone(result, 'Unable to allocate tenant network')
subnet = result['subnet']
self.assertEqual(subnet['cidr'], str_cidr)
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
subnets_client.delete_subnet, subnet['id'])
self.topology_subnets[subnet_name] = subnet
if router_id:
if not routers_client:
routers_client = self.routers_client
routers_client.add_router_interface(
router_id, subnet_id=subnet["id"])
self.addCleanup(
test_utils.call_and_ignore_notfound_exc,
routers_client.remove_router_interface, router_id,
subnet_id=subnet["id"])
return subnet
def test_router_create_tenant_distributed_returns_forbidden(self):
with testtools.ExpectedException(lib_exc.Forbidden):
self.create_router(data_utils.rand_name('router'),
distributed=True)
def create_validation_resources(clients,
keypair=False,
floating_ip=False,
security_group=False,
security_group_rules=False,
ethertype='IPv4',
use_neutron=True,
floating_network_id=None,
floating_network_name=None):
"""Provision resources for VM ping/ssh testing
Create resources required to be able to ping / ssh a virtual machine:
keypair, security group, security group rules and a floating IP.
Which of those resources are required may depend on the cloud setup and on
the specific test and it can be controlled via the corresponding
arguments.
Provisioned resources are returned in a dictionary.
:param clients: Instance of `tempest.lib.services.clients.ServiceClients`
or of a subclass of it. Resources are provisioned using clients from
`clients`.
:param keypair: Whether to provision a keypair. Defaults to False.
:param floating_ip: Whether to provision a floating IP. Defaults to False.
:param security_group: Whether to provision a security group. Defaults to
False.
:param security_group_rules: Whether to provision security group rules.
Defaults to False.
:param ethertype: 'IPv4' or 'IPv6'. Honoured only in case neutron is used.
:param use_neutron: When True resources are provisioned via neutron, when
False resources are provisioned via nova.
:param floating_network_id: The id of the network used to provision a
floating IP. Only used if a floating IP is requested and with neutron.
:param floating_network_name: The name of the floating IP pool used to
provision the floating IP. Only used if a floating IP is requested and
with nova-net.
:returns: A dictionary with the resources in the format they are returned
by the API. Valid keys are 'keypair', 'floating_ip' and
'security_group'.
Examples::
from tempest.common import validation_resources as vr
from tempest.lib import auth
from tempest.lib.services import clients
creds = auth.get_credentials('http://mycloud/identity/v3',
username='******', project_name='me',
password='******', domain_name='Default')
osclients = clients.ServiceClients(creds, 'http://mycloud/identity/v3')
# Request keypair and floating IP
resources = dict(keypair=True, security_group=False,
security_group_rules=False, floating_ip=True)
resources = vr.create_validation_resources(
osclients, use_neutron=True,
floating_network_id='4240E68E-23DA-4C82-AC34-9FEFAA24521C',
**resources)
# The floating IP to be attached to the VM
floating_ip = resources['floating_ip']['ip']
"""
# Create and Return the validation resources required to validate a VM
validation_data = {}
try:
if keypair:
keypair_name = data_utils.rand_name('keypair')
validation_data.update(
clients.compute.KeyPairsClient().create_keypair(
name=keypair_name))
LOG.debug("Validation resource key %s created", keypair_name)
if security_group:
validation_data['security_group'] = create_ssh_security_group(
clients,
add_rule=security_group_rules,
use_neutron=use_neutron,
ethertype=ethertype)
if floating_ip:
floating_ip_client = _network_service(
clients, use_neutron).FloatingIPsClient()
if use_neutron:
floatingip = floating_ip_client.create_floatingip(
floating_network_id=floating_network_id)
# validation_resources['floating_ip'] has historically looked
# like a compute API POST /os-floating-ips response, so we need
# to mangle it a bit for a Neutron response with different
# fields.
validation_data['floating_ip'] = floatingip['floatingip']
validation_data['floating_ip']['ip'] = (
floatingip['floatingip']['floating_ip_address'])
else:
# NOTE(mriedem): The os-floating-ips compute API was deprecated
# in the 2.36 microversion. Any tests for CRUD operations on
# floating IPs using the compute API should be capped at 2.35.
validation_data.update(
floating_ip_client.create_floating_ip(
pool=floating_network_name))
LOG.debug("Validation resource floating IP %s created",
validation_data['floating_ip'])
except Exception as prov_exc:
# If something goes wrong, cleanup as much as possible before we
# re-raise the exception
with excutils.save_and_reraise_exception():
if validation_data:
# Cleanup may fail as well
try:
msg = ('Error while provisioning validation resources %s. '
'Trying to cleanup what we provisioned so far: %s')
# The exceptions logging is already handled, so using
# debug here just to provide more context
LOG.debug(msg, prov_exc, str(validation_data))
clear_validation_resources(
clients,
keypair=validation_data.get('keypair', None),
floating_ip=validation_data.get('floating_ip', None),
security_group=validation_data.get(
'security_group', None),
use_neutron=use_neutron)
except Exception as cleanup_exc:
msg = ('Error during cleanup of validation resources. '
'The cleanup was triggered by an exception during '
'the provisioning step.\n'
'Provisioning exception: %s\n'
'First cleanup exception: %s')
LOG.exception(msg, prov_exc, cleanup_exc)
return validation_data
def test_remove_share_type_by_nonexistent_id(self):
self.assertRaises(lib_exc.NotFound,
self.shares_client.remove_access_from_share_type,
data_utils.rand_name("fake"),
self.shares_client.tenant_id)
def create_validation_resources(clients,
keypair=False,
floating_ip=False,
security_group=False,
security_group_rules=False,
ethertype='IPv4',
use_neutron=True,
floating_network_id=None,
floating_network_name=None):
"""Provision resources for VM ping/ssh testing
Create resources required to be able to ping / ssh a virtual machine:
keypair, security group, security group rules and a floating IP.
Which of those resources are required may depend on the cloud setup and on
the specific test and it can be controlled via the corresponding
arguments.
Provisioned resources are returned in a dictionary.
:param clients: Instance of `tempest.lib.services.clients.ServiceClients`
or of a subclass of it. Resources are provisioned using clients from
`clients`.
:param keypair: Whether to provision a keypair. Defaults to False.
:param floating_ip: Whether to provision a floating IP. Defaults to False.
:param security_group: Whether to provision a security group. Defaults to
False.
:param security_group_rules: Whether to provision security group rules.
Defaults to False.
:param ethertype: 'IPv4' or 'IPv6'. Honoured only in case neutron is used.
:param use_neutron: When True resources are provisioned via neutron, when
False resources are provisioned via nova.
:param floating_network_id: The id of the network used to provision a
floating IP. Only used if a floating IP is requested and with neutron.
:param floating_network_name: The name of the floating IP pool used to
provision the floating IP. Only used if a floating IP is requested and
with nova-net.
:returns: A dictionary with the same keys as the input
`validation_resources` and the resources for values in the format
they are returned by the API.
Examples::
from tempest.common import validation_resources as vr
from tempest.lib import auth
from tempest.lib.services import clients
creds = auth.get_credentials('http://mycloud/identity/v3',
username='******', project_name='me',
password='******', domain_name='Default')
osclients = clients.ServiceClients(creds, 'http://mycloud/identity/v3')
# Request keypair and floating IP
resources = dict(keypair=True, security_group=False,
security_group_rules=False, floating_ip=True)
resources = vr.create_validation_resources(
osclients, use_neutron=True,
floating_network_id='4240E68E-23DA-4C82-AC34-9FEFAA24521C',
**resources)
# The floating IP to be attached to the VM
floating_ip = resources['floating_ip']['ip']
"""
# Create and Return the validation resources required to validate a VM
validation_data = {}
if keypair:
keypair_name = data_utils.rand_name('keypair')
validation_data.update(
clients.compute.KeyPairsClient().create_keypair(name=keypair_name))
LOG.debug("Validation resource key %s created", keypair_name)
if security_group:
validation_data['security_group'] = create_ssh_security_group(
clients,
add_rule=security_group_rules,
use_neutron=use_neutron,
ethertype=ethertype)
if floating_ip:
floating_ip_client = _network_service(clients,
use_neutron).FloatingIPsClient()
if use_neutron:
floatingip = floating_ip_client.create_floatingip(
floating_network_id=floating_network_id)
# validation_resources['floating_ip'] has historically looked
# like a compute API POST /os-floating-ips response, so we need
# to mangle it a bit for a Neutron response with different
# fields.
validation_data['floating_ip'] = floatingip['floatingip']
validation_data['floating_ip']['ip'] = (
floatingip['floatingip']['floating_ip_address'])
else:
# NOTE(mriedem): The os-floating-ips compute API was deprecated
# in the 2.36 microversion. Any tests for CRUD operations on
# floating IPs using the compute API should be capped at 2.35.
validation_data.update(
floating_ip_client.create_floating_ip(
pool=floating_network_name))
return validation_data
