x/ranger-tempest-plugin
Code Issues Proposed changes

Refactor to remove resource leaks

Browse Source 
Resource leaks occur when resources
error out when creating in openstack.
This also includes a general refactor.

Change-Id: I2c3c3fad0a484cf3b5edf172d00b8465ba7d70f7
This commit is contained in:
jh629g 2019-12-13 22:46:34 -06:00
parent 22f72955cc
commit 362eabd829
7 changed files with 614 additions and 642 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ranger_tempest_plugin/config.py
View File

@ -60,7 +60,7 @@ ORM_GROUP_OPTIONS = [
cfg.StrOpt("alt_region_available", cfg.StrOpt("alt_region_available",
default=False, default=False,
help="Alt region for ranger tempest testing"), help="Alt region for ranger tempest testing"),
cfg.StrOpt("region_alt", cfg.StrOpt("alt_region",
default='', default='',
help="Provide alternate region for creating" help="Provide alternate region for creating"
"resources with multiple regions"), "resources with multiple regions"),

8
ranger_tempest_plugin/services/fms_client.py
View File

@ -97,21 +97,21 @@ class FmsClient(base_client.RangerClientBase):
flavor_id) flavor_id)
return self.get_request(uri, schema.get_extra_specs) return self.get_request(uri, schema.get_extra_specs)
def add_flvr_tenants(self, flavor_id, tenant_body): def add_flavor_tenants(self, flavor_id, tenant_body):
uri = '%s/%s/orm/flavors/%s/tenants/' % (self.fms_url, uri = '%s/%s/orm/flavors/%s/tenants/' % (self.fms_url,
self.version, self.version,
flavor_id) flavor_id)
post_body = json.dumps(tenant_body) post_body = json.dumps(tenant_body)
return self.post_request(uri, post_body, schema.add_tenant) return self.post_request(uri, post_body, schema.add_tenant)
def add_flvr_regions(self, flavor_id, region_body): def add_flavor_regions(self, flavor_id, region_body):
uri = '%s/%s/orm/flavors/%s/regions' % (self.fms_url, uri = '%s/%s/orm/flavors/%s/regions' % (self.fms_url,
self.version, self.version,
flavor_id) flavor_id)
post_body = json.dumps(region_body) post_body = json.dumps(region_body)
return self.post_request(uri, post_body, schema.add_region) return self.post_request(uri, post_body, schema.add_region)
def delete_flvr_region(self, flavor_id, region_id): def delete_flavor_region(self, flavor_id, region_id):
uri = '%s/%s/orm/flavors/%s/regions/%s' % (self.fms_url, uri = '%s/%s/orm/flavors/%s/regions/%s' % (self.fms_url,
self.version, self.version,
flavor_id, region_id) flavor_id, region_id)
@ -142,7 +142,7 @@ class FmsClient(base_client.RangerClientBase):
flavor_id, para) flavor_id, para)
return self.delete_request(uri, schema.delete_extra_specs) return self.delete_request(uri, schema.delete_extra_specs)
def delete_flvr_tenant(self, flavor_id, tenant): def delete_flavor_tenant(self, flavor_id, tenant):
uri = '%s/%s/orm/flavors/%s/tenants/%s' % (self.fms_url, uri = '%s/%s/orm/flavors/%s/tenants/%s' % (self.fms_url,
self.version, self.version,
flavor_id, tenant) flavor_id, tenant)

18
ranger_tempest_plugin/tests/api/cms_base.py
View File

@ -77,7 +77,7 @@ class CmsBaseOrmTest(base.BaseOrmTest):
@classmethod @classmethod
def _get_customer_params(cls, quota=None, enabled=True, region_users=True, def _get_customer_params(cls, quota=None, enabled=True, region_users=True,
default_users=True): default_users=True):
region, user, metadata, payload = {}, {}, {}, {} region, user, metadata, customer = {}, {}, {}, {}
cust_name = data_utils.rand_name('ormTempestCms') cust_name = data_utils.rand_name('ormTempestCms')
if not quota: if not quota:
quota = cls._get_quota() quota = cls._get_quota()
@ -90,14 +90,14 @@ class CmsBaseOrmTest(base.BaseOrmTest):
regions = [region] regions = [region]
metadata['my_server_name'] = cust_name metadata['my_server_name'] = cust_name
metadata['ocx_cust'] = str(random.randint(0, 999999999)) metadata['ocx_cust'] = str(random.randint(0, 999999999))
payload["description"] = cust_name customer["description"] = cust_name
payload["enabled"] = True if enabled else False customer["enabled"] = True if enabled else False
payload["name"] = cust_name customer["name"] = cust_name
payload['metadata'] = metadata customer['metadata'] = metadata
payload["regions"] = regions customer["regions"] = regions
payload["defaultQuotas"] = [quota] customer["defaultQuotas"] = [quota]
payload['users'] = [user] if default_users else [] customer['users'] = [user] if default_users else []
return payload return customer
@classmethod @classmethod
def _get_bare_customer_params(cls): def _get_bare_customer_params(cls):

2
ranger_tempest_plugin/tests/api/fms_base.py
View File

@ -15,6 +15,7 @@
import random import random
import time import time
import uuid
from oslo_log import log as logging from oslo_log import log as logging
from ranger_tempest_plugin.tests.api import base from ranger_tempest_plugin.tests.api import base
@ -49,6 +50,7 @@ class FmsBaseOrmTest(base.BaseOrmTest):
swap = random.randint(1, 40) * 1024 swap = random.randint(1, 40) * 1024
vcpus = random.randint(2, 40) vcpus = random.randint(2, 40)
disk = random.randint(2, 102) disk = random.randint(2, 102)
post_body['id'] = uuid.uuid4().hex
post_body["description"] = \ post_body["description"] = \
"orm-plugin-BaseORMTest-flavor" "orm-plugin-BaseORMTest-flavor"
post_body["series"] = random.choice(CONF.ranger.flavor_series) post_body["series"] = random.choice(CONF.ranger.flavor_series)

37
ranger_tempest_plugin/tests/api/test_customers.py
View File

@ -19,7 +19,6 @@ import uuid
from ranger_tempest_plugin.data_utils import data_utils from ranger_tempest_plugin.data_utils import data_utils
from ranger_tempest_plugin.tests.api import cms_base from ranger_tempest_plugin.tests.api import cms_base
from tempest import config from tempest import config
from tempest import test
from tempest.lib import decorators from tempest.lib import decorators
from tempest.lib import exceptions from tempest.lib import exceptions
@ -36,14 +35,15 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
cls._create_cust_validate_creation_on_dcp_and_lcp( cls._create_cust_validate_creation_on_dcp_and_lcp(
**cls.setup_customer) **cls.setup_customer)
cls.addClassResourceCleanup(
cls._del_cust_validate_deletion_on_dcp_and_lcp,
cls.setup_customer_id)
cls.bare_customer = cls._get_bare_customer_params() cls.bare_customer = cls._get_bare_customer_params()
cls.bare_customer_id = \ cls.bare_customer_id = \
cls._create_cust_validate_creation_on_dcp_and_lcp( cls._create_cust_validate_creation_on_dcp_and_lcp(
**cls.bare_customer) **cls.bare_customer)
cls.addClassResourceCleanup(
cls._del_cust_validate_deletion_on_dcp_and_lcp,
cls.setup_customer_id)
cls.addClassResourceCleanup( cls.addClassResourceCleanup(
cls._del_cust_validate_deletion_on_dcp_and_lcp, cls._del_cust_validate_deletion_on_dcp_and_lcp,
cls.bare_customer_id) cls.bare_customer_id)
@ -58,15 +58,15 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
def _create_region(self, status='functional'): def _create_region(self, status='functional'):
region_name = data_utils.rand_name() region_name = data_utils.rand_name()
self.addCleanup(
self.os_admin.rms_client.delete_region,
region_name)
_, region = self.os_admin.rms_client.create_region( _, region = self.os_admin.rms_client.create_region(
**{ **{
'region_id': region_name, 'region_id': region_name,
'status': status, 'status': status,
} }
) )
test.addClassResourceCleanup(
self.os_admin.rms_client.delete_region,
region_name)
return region return region
def _create_customer(self, post_body): def _create_customer(self, post_body):
@ -140,7 +140,7 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
post_body = self._get_customer_params(enabled=False) post_body = self._get_customer_params(enabled=False)
test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp( test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp(
**post_body) **post_body)
test.addClassResourceCleanup( self.addCleanup(
self._del_cust_validate_deletion_on_dcp_and_lcp, self._del_cust_validate_deletion_on_dcp_and_lcp,
test_customer_id) test_customer_id)
@ -160,9 +160,10 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
region_users=False) region_users=False)
test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp( test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp(
**post_body) **post_body)
test.addClassResourceCleanup( self.addCleanup(
self._del_cust_validate_deletion_on_dcp_and_lcp, self._del_cust_validate_deletion_on_dcp_and_lcp,
test_customer_id) test_customer_id)
_, body = self.client.get_customer(test_customer_id) _, body = self.client.get_customer(test_customer_id)
self.assertFalse(body['users']) self.assertFalse(body['users'])
self.assertFalse(body["regions"][0]['users']) self.assertFalse(body["regions"][0]['users'])
@ -186,7 +187,7 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
default_user_id = post_body["users"][0]["id"] default_user_id = post_body["users"][0]["id"]
test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp( test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp(
**post_body) **post_body)
test.addClassResourceCleanup( self.addCleanup(
self._del_cust_validate_deletion_on_dcp_and_lcp, self._del_cust_validate_deletion_on_dcp_and_lcp,
test_customer_id) test_customer_id)
_, body = self.client.get_customer(test_customer_id) _, body = self.client.get_customer(test_customer_id)
@ -212,7 +213,7 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
default_user_id = post_body["users"][0]["id"] default_user_id = post_body["users"][0]["id"]
test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp( test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp(
**post_body) **post_body)
test.addClassResourceCleanup( self.addCleanup(
self._del_cust_validate_deletion_on_dcp_and_lcp, self._del_cust_validate_deletion_on_dcp_and_lcp,
test_customer_id) test_customer_id)
_, body = self.client.get_customer(test_customer_id) _, body = self.client.get_customer(test_customer_id)
@ -242,7 +243,7 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
default_users=False) default_users=False)
test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp( test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp(
**post_body) **post_body)
test.addClassResourceCleanup( self.addCleanup(
self._del_cust_validate_deletion_on_dcp_and_lcp, self._del_cust_validate_deletion_on_dcp_and_lcp,
test_customer_id) test_customer_id)
_, body = self.client.get_customer(test_customer_id) _, body = self.client.get_customer(test_customer_id)
@ -268,7 +269,7 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
region_user_id = post_body["regions"][0]["users"][0]["id"] region_user_id = post_body["regions"][0]["users"][0]["id"]
test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp( test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp(
**post_body) **post_body)
test.addResourceCleanup( self.addCleanup(
self._del_cust_validate_deletion_on_dcp_and_lcp, self._del_cust_validate_deletion_on_dcp_and_lcp,
test_customer_id) test_customer_id)
_, body = self.client.get_customer(test_customer_id) _, body = self.client.get_customer(test_customer_id)
@ -288,7 +289,7 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
post_body = self._get_customer_params() post_body = self._get_customer_params()
test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp( test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp(
**post_body) **post_body)
test.addClassResourceCleanup( self.addCleanup(
self._del_cust_validate_deletion_on_dcp_and_lcp, self._del_cust_validate_deletion_on_dcp_and_lcp,
test_customer_id) test_customer_id)
@ -341,7 +342,7 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
region_name = post_body["regions"][0]["name"] region_name = post_body["regions"][0]["name"]
test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp( test_customer_id = self._create_cust_validate_creation_on_dcp_and_lcp(
**post_body) **post_body)
test.addClassResourceCleanup( self.addCleanup(
self._del_cust_validate_deletion_on_dcp_and_lcp, self._del_cust_validate_deletion_on_dcp_and_lcp,
test_customer_id) test_customer_id)
_, customer = self.client.get_customer(test_customer_id) _, customer = self.client.get_customer(test_customer_id)
@ -358,7 +359,7 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
test_cust_name = post_body['name'] test_cust_name = post_body['name']
_, body = self.client.create_customer(**post_body) _, body = self.client.create_customer(**post_body)
test_customer_id = body['customer']['id'] test_customer_id = body['customer']['id']
test.addClassResourceCleanup( self.addCleanup(
self._del_cust_validate_deletion_on_dcp_and_lcp, self._del_cust_validate_deletion_on_dcp_and_lcp,
test_customer_id) test_customer_id)
self._wait_for_status(test_customer_id, 'Success') self._wait_for_status(test_customer_id, 'Success')
@ -414,7 +415,7 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
resp, body = self.client.create_customer(**cust_body) resp, body = self.client.create_customer(**cust_body)
self.assertIn('id', body['customer']) self.assertIn('id', body['customer'])
test_customer_id = body['customer']['id'] test_customer_id = body['customer']['id']
test.addClassResourceCleanup( self.addCleanup(
self._delete_customer, self._delete_customer,
test_customer_id, test_customer_id,
region_name) region_name)
@ -434,7 +435,7 @@ class TestTempestCms(cms_base.CmsBaseOrmTest):
resp, body = self.client.create_customer(**cust_body) resp, body = self.client.create_customer(**cust_body)
self.assertIn('id', body['customer']) self.assertIn('id', body['customer'])
test_customer_id = body['customer']['id'] test_customer_id = body['customer']['id']
test.addClassResourceCleanup( self.addCleanup(
self._delete_customer, self._delete_customer,
test_customer_id, test_customer_id,
region_name) region_name)

209
ranger_tempest_plugin/tests/api/test_flavors.py
View File

@ -14,7 +14,6 @@
# under the License. # under the License.
import json import json
import uuid
from ranger_tempest_plugin import data_utils as orm_data_utils from ranger_tempest_plugin import data_utils as orm_data_utils
from ranger_tempest_plugin.tests.api import fms_base from ranger_tempest_plugin.tests.api import fms_base
@ -84,21 +83,18 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
return group_id return group_id
def _data_setup(self, post_body): def _data_setup(self, post_body):
flavor = self._create_flv_and_validate_creation_on_dcp_and_lcp(
**post_body)
self.addCleanup( self.addCleanup(
self._del_flv_and_validate_deletion_on_dcp_and_lcp, self._del_flv_and_validate_deletion_on_dcp_and_lcp,
flavor["id"]) post_body['id'])
flavor = self._create_flv_and_validate_creation_on_dcp_and_lcp(
**post_body)
return flavor return flavor
def _exec_tags_function(self, flavor_id, req_json, action, para): def _exec_tags_function(self, flavor_id, req_json, action, para):
if action == 'add': if action == 'add':
_, body = self.client.add_tags(flavor_id, req_json) _, body = self.client.add_tags(flavor_id, req_json)
elif action == 'update': elif action == 'update':
_, body = self.client.update_tags(flavor_id, req_json) _, body = self.client.update_tags(flavor_id, req_json)
elif action == 'delete': elif action == 'delete':
_, body = self.client.delete_tags(flavor_id, para) _, body = self.client.delete_tags(flavor_id, para)
@ -107,10 +103,8 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
def _exec_ex_spec_function(self, flavor_id, es_body, action, para): def _exec_ex_spec_function(self, flavor_id, es_body, action, para):
if action == 'add': if action == 'add':
_, body = self.client.add_extra_specs(flavor_id, es_body) _, body = self.client.add_extra_specs(flavor_id, es_body)
elif action == 'update': elif action == 'update':
_, body = self.client.update_extra_specs(flavor_id, es_body) _, body = self.client.update_extra_specs(flavor_id, es_body)
elif action == 'delete': elif action == 'delete':
_, body = self.client.delete_extra_specs(flavor_id, para) _, body = self.client.delete_extra_specs(flavor_id, para)
@ -136,39 +130,37 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
def _assert_create_flavor(self, public=False): def _assert_create_flavor(self, public=False):
post_body = self._get_flavor_params(public=public) post_body = self._get_flavor_params(public=public)
visibility = "private" if not public else "public" visibility = "private" if not public else "public"
# call client create_flavor and wait till status equals 'Success'
_, body = self.client.create_flavor(**post_body)
test_flvr_id = body["flavor"]['id']
self._wait_for_flavor_status_on_dcp(test_flvr_id, 'Success')
# add flavor to tempest cleanup # call client create_flavor and wait till status equals 'Success'
self.addCleanup( body = self._data_setup(post_body)
self._del_flv_and_validate_deletion_on_dcp_and_lcp, test_flavor_id = body['id']
test_flvr_id) self._wait_for_flavor_status_on_dcp(test_flavor_id, 'Success')
# verify flavor record created successfully # verify flavor record created successfully
flavor = self._get_flavor_details(test_flvr_id) flavor = self._get_flavor_details(test_flavor_id)
self.assertEqual(flavor["visibility"], visibility) self.assertEqual(flavor["visibility"], visibility)
self.assertEqual(flavor["regions"][0]["name"], CONF.identity.region) self.assertEqual(flavor["regions"][0]["name"], CONF.identity.region)
self.assertEqual(flavor["status"], "Success") self.assertEqual(flavor["status"], "Success")
def _create_region(self, status='functional'): def _create_region(self, status='functional'):
region_name = data_utils.rand_name() region_name = data_utils.rand_name()
self.addCleanup(
self.os_admin.rms_client.delete_region,
region_name)
_, region = self.os_admin.rms_client.create_region( _, region = self.os_admin.rms_client.create_region(
**{ **{
'region_id': region_name, 'region_id': region_name,
'status': status, 'status': status,
} }
) )
self.addCleanup(
self.os_admin.rms_client.delete_region,
region_name)
return region return region
def _delete_flavor(self, flvr_id): def _delete_flavor(self, flavor_id):
# delete the data and do get_flavor to ensure 404-NotFound response # delete the data and do get_flavor to ensure 404-NotFound response
self._del_flv_and_validate_deletion_on_dcp_and_lcp(flvr_id) self._del_flv_and_validate_deletion_on_dcp_and_lcp(flavor_id)
self.assertRaises(exceptions.NotFound, self.client.get_flavor, flvr_id) self.assertRaises(exceptions.NotFound,
self.client.get_flavor,
flavor_id)
@decorators.idempotent_id('2a4481cd-acce-4a5d-af7c-940222a6238b') @decorators.idempotent_id('2a4481cd-acce-4a5d-af7c-940222a6238b')
def test_get_flavor(self): def test_get_flavor(self):
@ -209,7 +201,7 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
alias_filter, contains_filter, startswith_filter, alias_filter, contains_filter, startswith_filter,
series_filter, tenant_filter]: series_filter, tenant_filter]:
_, body = self.client.list_flavors(list_filter) _, body = self.client.list_flavors(list_filter)
flavor_ids = [flvr["id"] for flvr in body["flavors"]] flavor_ids = [flavor["id"] for flavor in body["flavors"]]
self.assertIn(self.flavor_id, flavor_ids) self.assertIn(self.flavor_id, flavor_ids)
@decorators.idempotent_id('7b9d1f91-a8a4-458d-aaad-a98b5bf033b4') @decorators.idempotent_id('7b9d1f91-a8a4-458d-aaad-a98b5bf033b4')
@ -221,7 +213,7 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
self._assert_create_flavor(public=True) self._assert_create_flavor(public=True)
@decorators.idempotent_id('4cad10ce-67d2-4633-b347-2c16783a31b9') @decorators.idempotent_id('4cad10ce-67d2-4633-b347-2c16783a31b9')
def test_add_flvr_tags(self): def test_add_flavor_tags(self):
# test add_tags command with two sets of key:values # test add_tags command with two sets of key:values
add_tag_body = {"tags": {"aa": "bb", "cc": "dd"}} add_tag_body = {"tags": {"aa": "bb", "cc": "dd"}}
self._exec_tags_function(self.flavor_id, add_tag_body, 'add', None) self._exec_tags_function(self.flavor_id, add_tag_body, 'add', None)
@ -233,20 +225,17 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
self.assertDictEqual(add_tag_body.get("tags"), subset) self.assertDictEqual(add_tag_body.get("tags"), subset)
@decorators.idempotent_id('db8e5c0f-0041-45d4-9939-e079296123d8') @decorators.idempotent_id('db8e5c0f-0041-45d4-9939-e079296123d8')
def test_replace_flvr_tags(self): def test_replace_flavor_tags(self):
# test replace_tags command # test replace_tags command
replace_tag_body = {"tags": {"ee": "ff", "gg": "hh"}} replace_tag_body = {"tags": {"ee": "ff", "gg": "hh"}}
self._exec_tags_function(self.flavor_id, replace_tag_body, self._exec_tags_function(self.flavor_id, replace_tag_body,
'update', None) 'update', None)
self.addCleanup(
self._restore_default_tags,
self.flavor_id)
_, tag_body = self.client.get_tags(self.flavor_id) _, tag_body = self.client.get_tags(self.flavor_id)
self.assertDictEqual(replace_tag_body.get("tags"), self.assertDictEqual(replace_tag_body.get("tags"),
tag_body.get("tags")) tag_body.get("tags"))
@decorators.idempotent_id('e0a0eca6-e120-45ab-a1a4-f5b95fdf97f1') @decorators.idempotent_id('e0a0eca6-e120-45ab-a1a4-f5b95fdf97f1')
def test_delete_flvr_tag(self): def test_delete_flavor_tag(self):
# test delete_tag command - delete a tag from tags body # test delete_tag command - delete a tag from tags body
delete_tag_key = "a" delete_tag_key = "a"
self._exec_tags_function(self.flavor_id, None, 'delete', self._exec_tags_function(self.flavor_id, None, 'delete',
@ -257,7 +246,7 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
self.assertIsNone(tag_present) self.assertIsNone(tag_present)
@decorators.idempotent_id('9c511020-53ed-4139-8c53-451cb0ea8c75') @decorators.idempotent_id('9c511020-53ed-4139-8c53-451cb0ea8c75')
def test_delete_all_flvr_tags(self): def test_delete_all_flavor_tags(self):
# ensure there is at least a tag # ensure there is at least a tag
_, tag_body = self.client.get_tags(self.flavor_id) _, tag_body = self.client.get_tags(self.flavor_id)
self.assertTrue(True if tag_body.get("tags") else False) self.assertTrue(True if tag_body.get("tags") else False)
@ -265,40 +254,37 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
# test delete_all_tags command - run get_tag again and confirm # test delete_all_tags command - run get_tag again and confirm
# that the tag dict is now empty # that the tag dict is now empty
self._exec_tags_function(self.flavor_id, None, 'delete', None) self._exec_tags_function(self.flavor_id, None, 'delete', None)
self.addCleanup(
self._restore_default_tags,
self.flavor_id)
_, tag_body = self.client.get_tags(self.flavor_id) _, tag_body = self.client.get_tags(self.flavor_id)
# assert that tag_body contains nothing # assert that tag_body contains nothing
self.assertFalse(tag_body["tags"]) self.assertFalse(tag_body["tags"])
@decorators.idempotent_id('ec74d68f-b42a-41a8-9685-ff5eca25ea0c') @decorators.idempotent_id('ec74d68f-b42a-41a8-9685-ff5eca25ea0c')
def test_add_delete_flvr_region(self): def test_add_delete_flavor_region(self):
# setup data to add region # setup data to add region
post_body = self._get_flavor_params(set_region=False) post_body = self._get_flavor_params(set_region=False)
flavor = self._data_setup(post_body) flavor = self._data_setup(post_body)
test_flvr_id = flavor['id'] test_flavor_id = flavor['id']
post_region_body = '{"regions": [{"name": "%s"}]}' % (self.region_id) post_region_body = '{"regions": [{"name": "%s"}]}' % (self.region_id)
post_region_body = json.loads(post_region_body) post_region_body = json.loads(post_region_body)
_, body = self.client.add_flvr_regions(test_flvr_id, _, body = self.client.add_flavor_regions(test_flavor_id,
post_region_body) post_region_body)
self._wait_for_flavor_status_on_dcp(test_flvr_id, 'Success') self._wait_for_flavor_status_on_dcp(test_flavor_id, 'Success')
_, body = self.client.get_flavor(test_flvr_id) _, body = self.client.get_flavor(test_flavor_id)
self.assertEqual(body["flavor"]["regions"][0]["name"], self.assertEqual(body["flavor"]["regions"][0]["name"],
post_region_body["regions"][0]["name"]) post_region_body["regions"][0]["name"])
# remove added region and then check to confirm flavor status # remove added region and then check to confirm flavor status
_, body = self.client.delete_flvr_region(test_flvr_id, _, body = self.client.delete_flavor_region(test_flavor_id,
self.region_id) self.region_id)
# flavor status must show 'no regions' when it has no region assigned # flavor status must show 'no regions' when it has no region assigned
self._wait_for_flavor_status_on_dcp(test_flvr_id, 'no regions') self._wait_for_flavor_status_on_dcp(test_flavor_id, 'no regions')
# flavor region is now empty after the lone region was removed # flavor region is now empty after the lone region was removed
_, body = self.client.get_flavor(test_flvr_id) _, body = self.client.get_flavor(test_flavor_id)
self.assertTrue(len(body["flavor"]["regions"]) == 0) self.assertTrue(len(body["flavor"]["regions"]) == 0)
@decorators.idempotent_id('71404409-5d95-472c-8dac-b49a1c0c4b37') @decorators.idempotent_id('71404409-5d95-472c-8dac-b49a1c0c4b37')
def test_add_flvr_extra_specs(self): def test_add_flavor_extra_specs(self):
# get extra specs before the add # get extra specs before the add
_, es_body = self.client.get_extra_specs(self.flavor_id) _, es_body = self.client.get_extra_specs(self.flavor_id)
es_expected = es_body.get("os_extra_specs") es_expected = es_body.get("os_extra_specs")
@ -313,7 +299,7 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
self.assertDictEqual(es_expected, extra_specs.get("os_extra_specs")) self.assertDictEqual(es_expected, extra_specs.get("os_extra_specs"))
@decorators.idempotent_id('043948fd-125b-4d96-bf40-42464066a7e1') @decorators.idempotent_id('043948fd-125b-4d96-bf40-42464066a7e1')
def test_update_flvr_extra_specs(self): def test_update_flavor_extra_specs(self):
# add custom extra spec using update_extra_spec # add custom extra spec using update_extra_spec
replace_es_body = {"os_extra_specs": {"z": "zebra", "x": "xray"}} replace_es_body = {"os_extra_specs": {"z": "zebra", "x": "xray"}}
self._exec_ex_spec_function( self._exec_ex_spec_function(
@ -321,19 +307,17 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
replace_es_body, replace_es_body,
'update', 'update',
None) None)
self.addCleanup(
self._restore_custom_es,
self.flavor_id)
# assert extra specs update results match expected # assert extra specs update results match expected
_, flvr_ex_specs = self.client.get_extra_specs(self.flavor_id) _, flavor_ex_specs = self.client.get_extra_specs(self.flavor_id)
es_expected = replace_es_body.get("os_extra_specs") es_expected = replace_es_body.get("os_extra_specs")
es_expected.update(self.dflt_ex_specs) es_expected.update(self.dflt_ex_specs)
self.assertDictEqual(es_expected, flvr_ex_specs.get("os_extra_specs")) self.assertDictEqual(es_expected,
flavor_ex_specs.get("os_extra_specs"))
@decorators.idempotent_id('df83e2cd-d202-4b2f-8459-391a73067ec5') @decorators.idempotent_id('df83e2cd-d202-4b2f-8459-391a73067ec5')
def test_delete_flvr_extra_spec(self): def test_delete_flavor_extra_spec(self):
# get extra specs before the delete # get extra specs before the delete
_, es_body = self.client.get_extra_specs(self.flavor_id) _, es_body = self.client.get_extra_specs(self.flavor_id)
@ -344,53 +328,51 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
# assert extra specs update results match expected # assert extra specs update results match expected
es_body["os_extra_specs"].pop(delete_es_key_h) es_body["os_extra_specs"].pop(delete_es_key_h)
_, flvr_ex_specs = self.client.get_extra_specs(self.flavor_id) _, flavor_ex_specs = self.client.get_extra_specs(self.flavor_id)
self.assertDictEqual(es_body["os_extra_specs"], self.assertDictEqual(es_body["os_extra_specs"],
flvr_ex_specs.get("os_extra_specs")) flavor_ex_specs.get("os_extra_specs"))
@decorators.idempotent_id('e3fc7ce3-c8fe-4805-8ad3-7be2c94fe7ad') @decorators.idempotent_id('e3fc7ce3-c8fe-4805-8ad3-7be2c94fe7ad')
def test_delete_all_flvr_extra_specs(self): def test_delete_all_flavor_extra_specs(self):
# run delete ALL extra specs - note that this will only # run delete ALL extra specs - note that this will only
# delete custom extra specs, NOT the default extra specs # delete custom extra specs, NOT the default extra specs
self._exec_ex_spec_function(self.flavor_id, None, 'delete', None) self._exec_ex_spec_function(self.flavor_id, None, 'delete', None)
self.addCleanup( _, flavor_ex_specs = self.client.get_extra_specs(self.flavor_id)
self._restore_custom_es,
self.flavor_id)
_, flvr_ex_specs = self.client.get_extra_specs(self.flavor_id)
# assert that flavor extra specs now contains only # assert that flavor extra specs now contains only
# the default extra specs # the default extra specs
self.assertDictEqual(self.dflt_ex_specs, self.assertDictEqual(self.dflt_ex_specs,
flvr_ex_specs.get("os_extra_specs")) flavor_ex_specs.get("os_extra_specs"))
@decorators.idempotent_id('187195b5-adfb-4c73-a2f5-42117021f5f2') @decorators.idempotent_id('187195b5-adfb-4c73-a2f5-42117021f5f2')
def test_add_delete_flvr_tenant(self): def test_add_delete_flavor_tenant(self):
# setup data for test case # setup data for test case
post_body = self._get_flavor_params() post_body = self._get_flavor_params()
flavor = self._data_setup(post_body) flavor = self._data_setup(post_body)
test_flvr_id = flavor['id'] test_flavor_id = flavor['id']
# check that flavor contains one tenant before testing add_flvr_tenant # check that flavor contains one tenant before testing adding tenant
flavor = self._get_flavor_details(test_flvr_id) flavor = self._get_flavor_details(test_flavor_id)
self.assertEqual(len(flavor["tenants"]), 1) self.assertEqual(len(flavor["tenants"]), 1)
self.assertEqual(flavor["tenants"][0], self.tenant_id) self.assertEqual(flavor["tenants"][0], self.tenant_id)
# test add_flvr_tenant by adding one more tenant # test add_flavor_tenant by adding one more tenant
post_tenant_body = '{"tenants": ["%s"]}' % (self.alt_tenant_id) post_tenant_body = '{"tenants": ["%s"]}' % (self.alt_tenant_id)
post_tenant_body = json.loads(post_tenant_body) post_tenant_body = json.loads(post_tenant_body)
_, body = self.client.add_flvr_tenants(test_flvr_id, post_tenant_body) _, body = self.client.add_flavor_tenants(test_flavor_id,
self._wait_for_flavor_status_on_dcp(test_flvr_id, 'Success') post_tenant_body)
self._wait_for_flavor_status_on_dcp(test_flavor_id, 'Success')
# get flavor on same flavor id and confirm we have two tenants now # get flavor on same flavor id and confirm we have two tenants now
flavor = self._get_flavor_details(test_flvr_id) flavor = self._get_flavor_details(test_flavor_id)
self.assertEqual(len(flavor["tenants"]), 2) self.assertEqual(len(flavor["tenants"]), 2)
self.assertIn(self.alt_tenant_id, flavor["tenants"]) self.assertIn(self.alt_tenant_id, flavor["tenants"])
# delete one tenant, then wait until status = 'Success' # delete one tenant, then wait until status = 'Success'
_, body = self.client.delete_flvr_tenant(test_flvr_id, _, body = self.client.delete_flavor_tenant(test_flavor_id,
self.alt_tenant_id) self.alt_tenant_id)
self._wait_for_flavor_status_on_dcp(test_flvr_id, 'Success') self._wait_for_flavor_status_on_dcp(test_flavor_id, 'Success')
# get flavor to confirm flavor["tenants"] now shows one tenant only # get flavor to confirm flavor["tenants"] now shows one tenant only
flavor = self._get_flavor_details(test_flvr_id) flavor = self._get_flavor_details(test_flavor_id)
self.assertEqual(len(flavor["tenants"]), 1) self.assertEqual(len(flavor["tenants"]), 1)
self.assertEqual(flavor["tenants"][0], self.tenant_id) self.assertEqual(flavor["tenants"][0], self.tenant_id)
@ -398,16 +380,16 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
def test_delete_flavor(self): def test_delete_flavor(self):
# setup data for test case # setup data for test case
post_body = self._get_flavor_params() post_body = self._get_flavor_params()
flavor = self._create_flv_and_validate_creation_on_dcp_and_lcp(
**post_body)
test_flvr_id = flavor['id']
# delete the data and do get_flavor to ensure 404-NotFound response
self.addCleanup( self.addCleanup(
self._del_flv_and_validate_deletion_on_dcp_and_lcp, self._del_flv_and_validate_deletion_on_dcp_and_lcp,
test_flvr_id) post_body['id'])
flavor = self._create_flv_and_validate_creation_on_dcp_and_lcp(
**post_body)
test_flavor_id = flavor['id']
# delete the data and do get_flavor to ensure 404-NotFound response
self.assertRaises(exceptions.NotFound, self.client.get_flavor, self.assertRaises(exceptions.NotFound, self.client.get_flavor,
test_flvr_id) test_flavor_id)
@decorators.idempotent_id('2a1240d8-ae30-4c37-b99f-af961a5e16cb') @decorators.idempotent_id('2a1240d8-ae30-4c37-b99f-af961a5e16cb')
def test_create_flavor_with_swap_and_ephemeral(self): def test_create_flavor_with_swap_and_ephemeral(self):
@ -419,9 +401,9 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
post_body['ephemeral'] = ephemeral post_body['ephemeral'] = ephemeral
post_body['swap'] = swap post_body['swap'] = swap
flavor = self._data_setup(post_body) flavor = self._data_setup(post_body)
test_flvr_id = flavor['id'] test_flavor_id = flavor['id']
# verify flavor record created successfully # verify flavor record created successfully
flavor_details = self._get_flavor_details(test_flvr_id) flavor_details = self._get_flavor_details(test_flavor_id)
self.assertEqual(flavor_details['status'], 'Success') self.assertEqual(flavor_details['status'], 'Success')
self.assertEqual(flavor_details['swap'], swap) self.assertEqual(flavor_details['swap'], swap)
self.assertEqual(flavor_details['ephemeral'], ephemeral) self.assertEqual(flavor_details['ephemeral'], ephemeral)
@ -458,35 +440,28 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
disk = '0' disk = '0'
post_body['disk'] = disk post_body['disk'] = disk
flavor = self._data_setup(post_body) flavor = self._data_setup(post_body)
test_flvr_id = flavor['id'] test_flavor_id = flavor['id']
flavor_details = self._get_flavor_details(test_flvr_id) flavor_details = self._get_flavor_details(test_flavor_id)
self.assertEqual(flavor_details["status"], "Success") self.assertEqual(flavor_details["status"], "Success")
self.assertEqual(flavor_details["disk"], disk) self.assertEqual(flavor_details["disk"], disk)
@decorators.idempotent_id('997ca03c-4176-4632-a0c9-7e943b03306c') @decorators.idempotent_id('997ca03c-4176-4632-a0c9-7e943b03306c')
def test_create_flavor_with_region_group(self): def test_create_flavor_with_region_group(self):
# create region group # create region group
_, body = self.rms_client.create_region_group( group_id = self._create_region_group()
**orm_data_utils.rand_region_group([CONF.identity.region])
)
group_id = body['group']['id']
self.addCleanup(
self.rms_client.delete_region_group,
group_id)
post_body = self._get_flavor_params() post_body = self._get_flavor_params()
region_group = {'name': group_id, 'type': 'group'} region_group = {'name': group_id, 'type': 'group'}
post_body['regions'] = [region_group] post_body['regions'] = [region_group]
flavor = self._data_setup(post_body) flavor = self._data_setup(post_body)
test_flvr_id = flavor['id'] test_flavor_id = flavor['id']
flavor_details = self._get_flavor_details(test_flvr_id) flavor_details = self._get_flavor_details(test_flavor_id)
self.assertEqual(flavor_details['status'], 'Success') self.assertEqual(flavor_details['status'], 'Success')
self.assertEqual(flavor['regions'][0]['name'], CONF.identity.region) self.assertEqual(flavor['regions'][0]['name'], CONF.identity.region)
@decorators.idempotent_id('ea2a618e-bd53-460b-bde5-01ea20b417c9') @decorators.idempotent_id('ea2a618e-bd53-460b-bde5-01ea20b417c9')
def test_create_flavor_with_two_regions(self): def test_create_flavor_with_two_regions(self):
region_alt = CONF.ranger.region_alt region_alt = CONF.ranger.alt_region
if not region_alt: if not region_alt:
raise exceptions.InvalidConfiguration( raise exceptions.InvalidConfiguration(
'Provide region_alt in ranger block in configuration file') 'Provide region_alt in ranger block in configuration file')
@ -495,15 +470,15 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
{'name': region_alt} {'name': region_alt}
) )
flavor = self._data_setup(post_body) flavor = self._data_setup(post_body)
test_flvr_id = flavor['id'] test_flavor_id = flavor['id']
flavor_details = self._get_flavor_details(test_flvr_id) flavor_details = self._get_flavor_details(test_flavor_id)
self.assertEqual(flavor_details['status'], 'Success') self.assertEqual(flavor_details['status'], 'Success')
self.assertEqual(flavor['regions'][0]['name'], CONF.identity.region) self.assertEqual(flavor['regions'][0]['name'], CONF.identity.region)
self.assertEqual(flavor['regions'][1]['name'], region_alt) self.assertEqual(flavor['regions'][1]['name'], region_alt)
@decorators.idempotent_id('06c81b29-85b6-4edf-ab89-3877c49e23bc') @decorators.idempotent_id('06c81b29-85b6-4edf-ab89-3877c49e23bc')
def test_create_flavor_with_single_and_group_region(self): def test_create_flavor_with_single_and_group_region(self):
region_alt = CONF.ranger.region_alt region_alt = CONF.ranger.alt_region
if not region_alt: if not region_alt:
raise exceptions.InvalidConfiguration( raise exceptions.InvalidConfiguration(
'Provide region_alt in ranger block in configuration file') 'Provide region_alt in ranger block in configuration file')
@ -520,8 +495,7 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
} }
] ]
flavor = self._data_setup(post_body) flavor = self._data_setup(post_body)
test_flvr_id = flavor['id'] flavor_details = self._get_flavor_details(flavor['id'])
flavor_details = self._get_flavor_details(test_flvr_id)
self.assertEqual(flavor_details['status'], 'Success') self.assertEqual(flavor_details['status'], 'Success')
self.assertEqual(flavor['regions'][0]['name'], CONF.identity.region) self.assertEqual(flavor['regions'][0]['name'], CONF.identity.region)
self.assertEqual(flavor['regions'][1]['name'], region_alt) self.assertEqual(flavor['regions'][1]['name'], region_alt)
@ -529,12 +503,10 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
@decorators.idempotent_id('997ca03c-4176-4632-a0c9-7e943b03306d') @decorators.idempotent_id('997ca03c-4176-4632-a0c9-7e943b03306d')
def test_create_flavor_with_uuid(self): def test_create_flavor_with_uuid(self):
post_body = self._get_flavor_params() post_body = self._get_flavor_params()
uuid_ = uuid.uuid4().hex
post_body['id'] = uuid_
flavor = self._data_setup(post_body) flavor = self._data_setup(post_body)
flavor_details = self._get_flavor_details(uuid_) flavor_details = self._get_flavor_details(post_body['id'])
self.assertEqual(flavor_details['status'], 'Success') self.assertEqual(flavor_details['status'], 'Success')
self.assertEqual(flavor['id'], uuid_) self.assertEqual(flavor['id'], post_body['id'])
@decorators.idempotent_id('37f1909f-3ba2-403c-ba0c-0a11b869d6a1') @decorators.idempotent_id('37f1909f-3ba2-403c-ba0c-0a11b869d6a1')
def test_flavor_while_region_down(self): def test_flavor_while_region_down(self):
@ -545,7 +517,7 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
post_body = self._get_flavor_params() post_body = self._get_flavor_params()
post_body['regions'][0]['name'] = region['name'] post_body['regions'][0]['name'] = region['name']
self.assertRaises(exceptions.BadRequest, self.assertRaises(exceptions.BadRequest,
self.client.create_flavor, **post_body) self._data_setup, post_body)
@decorators.idempotent_id('1c6a24d3-345e-46d4-aaa0-127b7fc8a42d') @decorators.idempotent_id('1c6a24d3-345e-46d4-aaa0-127b7fc8a42d')
def test_flavor_while_region_building(self): def test_flavor_while_region_building(self):
@ -554,16 +526,16 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
post_body = self._get_flavor_params() post_body = self._get_flavor_params()
post_body['regions'][0]['name'] = region['name'] post_body['regions'][0]['name'] = region['name']
_, body = self.client.create_flavor(**post_body)
self.assertIn('id', body['flavor'])
test_flvr_id = body['flavor']['id']
self.addCleanup( self.addCleanup(
self._delete_flavor, self._delete_flavor,
test_flvr_id) post_body['id'])
body = self._data_setup(post_body)
flavor = self._get_flavor_details(test_flvr_id) self.assertIn('id', body)
self.assertEqual(flavor['id'], test_flvr_id) test_flavor_id = body['id']
flavor = self._get_flavor_details(test_flavor_id)
self.assertEqual(flavor['id'], test_flavor_id)
self.assertEqual(flavor['status'], 'Error') self.assertEqual(flavor['status'], 'Error')
@decorators.idempotent_id('e17dab64-c900-4a19-a7a2-96a0bf4af0f8') @decorators.idempotent_id('e17dab64-c900-4a19-a7a2-96a0bf4af0f8')
@ -573,13 +545,10 @@ class TestTempestFms(fms_base.FmsBaseOrmTest):
post_body = self._get_flavor_params() post_body = self._get_flavor_params()
post_body['regions'][0]['name'] = region['name'] post_body['regions'][0]['name'] = region['name']
_, body = self.client.create_flavor(**post_body) body = self._data_setup(post_body)
self.assertIn('id', body['flavor']) self.assertIn('id', body)
test_flvr_id = body['flavor']['id'] test_flavor_id = body['id']
self.addCleanup(
self._delete_flavor,
test_flvr_id)
flavor = self._get_flavor_details(test_flvr_id) flavor = self._get_flavor_details(test_flavor_id)
self.assertEqual(flavor['id'], test_flvr_id) self.assertEqual(flavor['id'], test_flavor_id)
self.assertEqual(flavor['status'], 'Error') self.assertEqual(flavor['status'], 'Error')

980
ranger_tempest_plugin/tests/api/test_images.py Executable file → Normal file
View File

@ -1,490 +1,490 @@
# Copyright 2016 AT&T Corp # Copyright 2016 AT&T Corp
# All Rights Reserved # All Rights Reserved
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may # Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain # not use this file except in compliance with the License. You may obtain
# a copy of the License at # a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid from ranger_tempest_plugin.data_utils import data_utils
from ranger_tempest_plugin.tests.api import ims_base
from ranger_tempest_plugin.data_utils import data_utils from tempest import config
from ranger_tempest_plugin.tests.api import ims_base
from tempest import config from tempest.lib import decorators
from tempest.lib import exceptions
from tempest.lib import decorators
from tempest.lib import exceptions CONF = config.CONF
CONF = config.CONF
class TestTempestIms(ims_base.ImsBaseOrmTest):
class TestTempestIms(ims_base.ImsBaseOrmTest): @classmethod
def setup_credentials(cls):
@classmethod cls.set_network_resources()
def setup_credentials(cls): super(TestTempestIms, cls).setup_credentials()
cls.set_network_resources()
super(TestTempestIms, cls).setup_credentials() @classmethod
def setup_clients(cls):
@classmethod super(TestTempestIms, cls).setup_clients()
def setup_clients(cls):
super(TestTempestIms, cls).setup_clients() @classmethod
def resource_setup(cls):
@classmethod # setup public image for tempest testing
def resource_setup(cls): cls.image_params_public = \
# setup public image for tempest testing cls._get_image_params(set_private=False)
cls.image_params_public = \ cls.image_params_private = \
cls._get_image_params(set_private=False) cls._get_image_params(set_enabled=False)
cls.image_params_private = \
cls._get_image_params(set_enabled=False) cls.addClassResourceCleanup(
cls._del_img_validate_deletion_on_dcp_and_lcp,
cls.addClassResourceCleanup( cls.image_params_public['id'])
cls._del_img_validate_deletion_on_dcp_and_lcp, cls.addClassResourceCleanup(
cls.image_params_public['id']) cls._del_img_validate_deletion_on_dcp_and_lcp,
cls.addClassResourceCleanup( cls.image_params_private['id'])
cls._del_img_validate_deletion_on_dcp_and_lcp,
cls.image_params_private['id']) # setup public image for tempest testing
cls.public_image = \
# setup public image for tempest testing cls._create_img_and_validate_creation_on_dcp_and_lcp(
cls.public_image = \ **cls.image_params_public)
cls._create_img_and_validate_creation_on_dcp_and_lcp(
**cls.image_params_public) # setup private image for tempest testing
cls.private_image = \
# setup private image for tempest testing cls._create_img_and_validate_creation_on_dcp_and_lcp(
cls.private_image = \ **cls.image_params_private)
cls._create_img_and_validate_creation_on_dcp_and_lcp(
**cls.image_params_private) super(TestTempestIms, cls).resource_setup()
super(TestTempestIms, cls).resource_setup() def _data_setup(self, post_body):
self.addCleanup(
def _data_setup(self, post_body): self._del_img_validate_deletion_on_dcp_and_lcp,
self.addCleanup( post_body['id'])
self._del_img_validate_deletion_on_dcp_and_lcp, image = self._create_img_and_validate_creation_on_dcp_and_lcp(
post_body["id"]) **post_body)
image = self._create_img_and_validate_creation_on_dcp_and_lcp( # only check for Success image status if "regions" is not empty
**post_body) if image["regions"]:
# only check for Success image status if "regions" is not empty self._wait_for_image_status_on_dcp(image['id'], 'Success')
if image["regions"]:
self._wait_for_image_status_on_dcp(image["id"], 'Success') return image
return image def _delete_image(self, id_):
"""Try to delete from from dcp only"""
def _delete_image(self, id_): # delete the data and do get_image to ensure 404-NotFound response
"""Try to delete from from dcp only""" self._del_img_validate_deletion_on_dcp_and_lcp(id_)
# delete the data and do get_image to ensure 404-NotFound response self.assertRaises(exceptions.NotFound, self.client.get_image, id_)
self._del_img_validate_deletion_on_dcp_and_lcp(id_)
self.assertRaises(exceptions.NotFound, self.client.get_image, id_) def _create_region(self, status='functional'):
region_name = data_utils.rand_name()
def _create_region(self, status='functional'): self.addCleanup(
region_name = data_utils.rand_name() self.os_admin.rms_client.delete_region,
self.addCleanup( region_name)
self.os_admin.rms_client.delete_region,
region_name) _, region = self.os_admin.rms_client.create_region(
**{
_, region = self.os_admin.rms_client.create_region( 'region_id': region_name,
**{ 'status': status,
'region_id': region_name, }
'status': status, )
}
) return region
return region @decorators.idempotent_id('2b1bb28b-4151-4e75-ae1b-d21089c3418c')
def test_get_image(self):
@decorators.idempotent_id('2b1bb28b-4151-4e75-ae1b-d21089c3418c') """Execute 'get_image' using the following options:
def test_get_image(self):
"""Execute 'get_image' using the following options: - get image by id (using cust_id parameter)
- get image by name (using cust_name parameter)
- get image by id (using cust_id parameter) """
- get image by name (using cust_name parameter)
""" # execute get_image using image ID and iamge_name
for identifier in [self.public_image['id'], self.public_image['name']]:
# execute get_image using image ID and iamge_name _, body = self.client.get_image(identifier)
for identifier in [self.public_image['id'], self.public_image['name']]: self.assertIn(self.public_image['id'], body['image']['id'])
_, body = self.client.get_image(identifier)
self.assertIn(self.public_image['id'], body['image']['id']) @decorators.idempotent_id('6072c438-1e45-4c0b-97a6-e5127bd33d90')
def test_list_images_with_filters(self):
@decorators.idempotent_id('6072c438-1e45-4c0b-97a6-e5127bd33d90') """This function executes 'list customer' with all available filters:
def test_list_images_with_filters(self):
"""This function executes 'list customer' with all available filters: - no filter (i.e. list all images)
- filter by region
- no filter (i.e. list all images) - filter by customer
- filter by region - filter by visibility (public/private)
- filter by customer """
- filter by visibility (public/private)
""" # define the list customer filters to be used for this test
no_filter = None
# define the list customer filters to be used for this test customer_filter = "?customer=%s" % self.tenant_id
no_filter = None region_filter = "?region=%s" % self.region_id
customer_filter = "?customer=%s" % self.tenant_id public_filter = "?visibility=public"
region_filter = "?region=%s" % self.region_id private_filter = "?visibility=private"
public_filter = "?visibility=public"
private_filter = "?visibility=private" # list public images
_, body = self.client.list_images(public_filter)
# list public images image_ids = [img['id'] for img in body['images']]
_, body = self.client.list_images(public_filter) self.assertIn(self.public_image['id'], image_ids)
image_ids = [img['id'] for img in body['images']]
self.assertIn(self.public_image['id'], image_ids) # list private images
_, body = self.client.list_images(private_filter)
# list private images image_ids = [img['id'] for img in body['images']]
_, body = self.client.list_images(private_filter) self.assertIn(self.private_image['id'], image_ids)
image_ids = [img['id'] for img in body['images']]
self.assertIn(self.private_image['id'], image_ids) # execute list_customers with the rest of the filters
for list_filter in [no_filter, region_filter,
# execute list_customers with the rest of the filters customer_filter]:
for list_filter in [no_filter, region_filter, _, body = self.client.list_images(list_filter)
customer_filter]: images = [image['id'] for image in body['images']]
_, body = self.client.list_images(list_filter) self.assertIn(self.private_image['id'], images)
images = [image['id'] for image in body['images']]
self.assertIn(self.private_image['id'], images) @decorators.idempotent_id('4435fef4-49a9-435b-8463-cf8a1e0b7cd8')
def test_disable_image(self):
@decorators.idempotent_id('4435fef4-49a9-435b-8463-cf8a1e0b7cd8') # disable self.public_image and check if request is successful
def test_disable_image(self): self.client.enabled_image(self.public_image['id'], False)
# disable self.public_image and check if request is successful self._wait_for_image_status_on_dcp(self.public_image['id'], 'Success')
self.client.enabled_image(self.public_image['id'], False) _, body = self.client.get_image(self.public_image['id'])
self._wait_for_image_status_on_dcp(self.public_image['id'], 'Success') image = body["image"]
_, body = self.client.get_image(self.public_image['id'])
image = body["image"] # assert that the image["enabled"] value is 'False'
self.assertTrue(not image['enabled'])
# assert that the image["enabled"] value is 'False'
self.assertTrue(not image['enabled']) @decorators.idempotent_id('f32a13e3-6f38-423b-a616-09c8d4e1c277')
def test_enable_image(self):
@decorators.idempotent_id('f32a13e3-6f38-423b-a616-09c8d4e1c277') # enable self.private_image and check if request is successful
def test_enable_image(self): self.client.enabled_image(self.private_image['id'], True)
# enable self.private_image and check if request is successful self._wait_for_image_status_on_dcp(self.private_image['id'], 'Success')
self.client.enabled_image(self.private_image['id'], True) _, body = self.client.get_image(self.private_image['id'])
self._wait_for_image_status_on_dcp(self.private_image['id'], 'Success') image = body["image"]
_, body = self.client.get_image(self.private_image['id'])
image = body["image"] # assert that the image["enabled"] value is 'True'
self.assertTrue(image['enabled'])
# assert that the image["enabled"] value is 'True'
self.assertTrue(image['enabled']) @decorators.idempotent_id('cb9e3022-00d7-4a21-bdb2-67d3cd15a4f8')
def test_add_delete_image_region(self):
@decorators.idempotent_id('cb9e3022-00d7-4a21-bdb2-67d3cd15a4f8') # skip region assignment in data setup
def test_add_delete_image_region(self): post_body = self._get_image_params(set_region=False)
# skip region assignment in data setup image = self._data_setup(post_body)
post_body = self._get_image_params(set_region=False)
image = self._data_setup(post_body) # add region to image then check to confirm image status = "Success"
test_image_id = image['id'] self.client.add_region_to_image(image['id'], self.region_id)
# image status must show 'Success' when assigned to a region
# add region to image then check to confirm image status = "Success" self._wait_for_image_status_on_dcp(image['id'], 'Success')
self.client.add_region_to_image(test_image_id, self.region_id)
# image status must show 'Success' when assigned to a region # check that region is successfully added
self._wait_for_image_status_on_dcp(test_image_id, 'Success') _, body = self.client.get_image(image['id'])
image = body["image"]
# check that region is successfully added self.assertEqual(image["regions"][0]["name"], self.region_id)
_, body = self.client.get_image(test_image_id)
image = body["image"] # delete the region then check to confirm image status = "no regions"
self.assertEqual(image["regions"][0]["name"], self.region_id) _, body = self.client.delete_region_from_image(image['id'],
self.region_id)
# delete the region then check to confirm image status = "no regions" self._wait_for_image_status_on_dcp(image['id'], 'no regions')
_, body = self.client.delete_region_from_image(test_image_id,
self.region_id) # image region array should be empty after the region was removed
self._wait_for_image_status_on_dcp(test_image_id, 'no regions') _, body = self.client.get_image(image['id'])
image = body["image"]
# image region array should be empty after the region was removed self.assertFalse(image["regions"])
_, body = self.client.get_image(test_image_id)
image = body["image"] @decorators.idempotent_id('0ee68189-66a8-4213-ad68-bc12991c174a')
self.assertFalse(image["regions"]) def test_add_delete_image_tenant(self):
# add alt tenant to self.private_image & check if status = "Success"
@decorators.idempotent_id('0ee68189-66a8-4213-ad68-bc12991c174a') self.client.add_customer_to_image(self.private_image['id'],
def test_add_delete_image_tenant(self): self.alt_tenant_id)
# add alt tenant to self.private_image & check if status = "Success" self._wait_for_image_status_on_dcp(self.private_image['id'],
self.client.add_customer_to_image(self.private_image['id'], 'Success')
self.alt_tenant_id)
self._wait_for_image_status_on_dcp(self.private_image['id'], # check that alt tenant successfully added to image tenants array
'Success') _, body = self.client.get_image(self.private_image['id'])
image = body["image"]
# check that alt tenant successfully added to image tenants array self.assertEqual(len(image["customers"]), 2)
_, body = self.client.get_image(self.private_image['id']) self.assertIn(self.alt_tenant_id, image['customers'])
image = body["image"]
self.assertEqual(len(image["customers"]), 2) # now delete alt_tenant_id and ensure operation is successful
self.assertIn(self.alt_tenant_id, image['customers']) _, body = self.client.delete_customer_from_image(
self.private_image['id'],
# now delete alt_tenant_id and ensure operation is successful self.alt_tenant_id)
_, body = self.client.delete_customer_from_image( self._wait_for_image_status_on_dcp(self.private_image['id'], 'Success')
self.private_image['id'],
self.alt_tenant_id) # image region array should no longer contain alt tenant
self._wait_for_image_status_on_dcp(self.private_image['id'], 'Success') _, body = self.client.get_image(self.private_image['id'])
image = body["image"]
# image region array should no longer contain alt tenant self.assertNotIn(self.alt_tenant_id, image['customers'])
_, body = self.client.get_image(self.private_image['id'])
image = body["image"] @decorators.idempotent_id('bac99348-6b13-4b30-958b-3c039b27eda3')
self.assertNotIn(self.alt_tenant_id, image['customers']) def test_update_image_tenant(self):
# replace current tenant in self.private_image with alt tenant
@decorators.idempotent_id('bac99348-6b13-4b30-958b-3c039b27eda3') self.client.update_customer(self.private_image['id'],
def test_update_image_tenant(self): self.alt_tenant_id)
# replace current tenant in self.private_image with alt tenant self._wait_for_image_status_on_dcp(self.private_image['id'], 'Success')
self.client.update_customer(self.private_image['id'],
self.alt_tenant_id) # check that image tenants array contains only alt tenant
self._wait_for_image_status_on_dcp(self.private_image['id'], 'Success') _, body = self.client.get_image(self.private_image['id'])
image = body["image"]
# check that image tenants array contains only alt tenant self.assertEqual(len(image["customers"]), 1)
_, body = self.client.get_image(self.private_image['id']) self.assertIn(self.alt_tenant_id, image['customers'])
image = body["image"]
self.assertEqual(len(image["customers"]), 1) @decorators.idempotent_id('0331e02a-ab52-4341-b676-a02462244277')
self.assertIn(self.alt_tenant_id, image['customers']) def test_create_image(self):
post_body = self._get_image_params()
@decorators.idempotent_id('0331e02a-ab52-4341-b676-a02462244277') self.addCleanup(
def test_create_image(self): self._del_img_validate_deletion_on_dcp_and_lcp,
post_body = self._get_image_params() post_body['id'])
self.addCleanup( # call client create_IMAGE and wait till status equals 'Success'
self._del_img_validate_deletion_on_dcp_and_lcp, _, body = self.client.create_image(**post_body)
post_body["id"]) image = body["image"]
# call client create_IMAGE and wait till status equals 'Success' self._wait_for_image_status_on_dcp(image['id'], 'Success')
_, body = self.client.create_image(**post_body)
image = body["image"] # verify image record created successfully
test_image_id = image["id"] _, body = self.client.get_image(image['id'])
self._wait_for_image_status_on_dcp(test_image_id, 'Success') image = body["image"]
self.assertEqual(image["regions"][0]["name"], CONF.identity.region)
# verify image record created successfully
_, body = self.client.get_image(test_image_id) @decorators.idempotent_id('01160918-e217-401d-a6a0-e7992ab76e41')
image = body["image"] def test_update_image(self):
self.assertEqual(image["regions"][0]["name"], CONF.identity.region) region = {}
@decorators.idempotent_id('01160918-e217-401d-a6a0-e7992ab76e41') # define data used to update image
def test_update_image(self): post_body = self._get_image_params(set_region=False)
region = {}
post_body = self._get_image_params(set_region=False) # create image that will be updated
image = self._data_setup(post_body) image = self._data_setup(post_body)
test_image_id = image['id']
# setup region, change properties for update data
# setup region and change 'enabled', 'customers' properties region["name"] = self.region_id
region["name"] = self.region_id region["type"] = "single"
region["type"] = "single" region["checksum"] = "7297321c2fa6424417a548c85edd6e98"
region["checksum"] = "7297321c2fa6424417a548c85edd6e98" region["virtual_size"] = "None"
region["virtual_size"] = "None" region["size"] = "38797312"
region["size"] = "38797312" post_body["regions"] = [region]
post_body["regions"] = [region] post_body["enabled"] = False
post_body["enabled"] = False post_body["customers"] = [self.alt_tenant_id]
post_body["customers"] = [self.alt_tenant_id] # empty tags list
# empty tags list post_body["tags"] = []
post_body["tags"] = []
_, body = self.client.update_image(image['id'], para=None,
_, body = self.client.update_image(test_image_id, para=None, **post_body)
**post_body) self._wait_for_image_status_on_dcp(image['id'], 'Success')
self._wait_for_image_status_on_dcp(test_image_id, 'Success') # verify image record updated successfully
# verify image record updated successfully _, body = self.client.get_image(image['id'])
_, body = self.client.get_image(test_image_id) image = body["image"]
image = body["image"] self.assertEqual(image["regions"][0]["name"], CONF.identity.region)
self.assertEqual(image["regions"][0]["name"], CONF.identity.region) self.assertIn(self.alt_tenant_id, image['customers'])
self.assertIn(self.alt_tenant_id, image['customers']) self.assertFalse(image['enabled'])
self.assertFalse(image['enabled']) self.assertFalse(image['tags'])
self.assertFalse(image['tags'])
@decorators.idempotent_id('23e2e7e2-5b19-4c66-b35c-7c686a986627')
@decorators.idempotent_id('23e2e7e2-5b19-4c66-b35c-7c686a986627') def test_delete_image(self):
def test_delete_image(self): # setup data for test case
# setup data for test case post_body = self._get_image_params()
post_body = self._get_image_params() image = self._create_img_and_validate_creation_on_dcp_and_lcp(
image = self._create_img_and_validate_creation_on_dcp_and_lcp( **post_body)
**post_body)
test_image_id = image['id'] # delete the data and do get_image to ensure 404-NotFound response
self._del_img_validate_deletion_on_dcp_and_lcp(image['id'])
# delete the data and do get_image to ensure 404-NotFound response self.assertRaises(exceptions.NotFound, self.client.get_image,
self._del_img_validate_deletion_on_dcp_and_lcp(test_image_id) image['id'])
self.assertRaises(exceptions.NotFound, self.client.get_image,
test_image_id) @decorators.idempotent_id('e642fa39-1b69-4d17-8bd1-aee90ea042a3')
def test_image_while_region_down(self):
@decorators.idempotent_id('e642fa39-1b69-4d17-8bd1-aee90ea042a3') # create region with status down
def test_image_while_region_down(self): region = self._create_region(status='down')
# create region with status down
region = self._create_region(status='down') # create image within that newly created region
post_body = self._get_image_params()
# create image within that newly created region post_body['regions'][0]['name'] = region['name']
post_body = self._get_image_params()
post_body['regions'][0]['name'] = region['name'] self.assertRaises(exceptions.BadRequest,
self.client.create_image, **post_body)
# TODO(JH629G): Determine if flavor resource deletion is necessary here
@decorators.idempotent_id('a1fee342-3000-41a6-97f9-b33fd2734e4d')
self.assertRaises(exceptions.BadRequest, def test_image_while_region_building(self):
self.client.create_image, **post_body) # create region with status building
region = self._create_region(status='building')
@decorators.idempotent_id('a1fee342-3000-41a6-97f9-b33fd2734e4d')
def test_image_while_region_building(self): # create image within that newly created region
# create region with status building post_body = self._get_image_params()
region = self._create_region(status='building') post_body['regions'][0]['name'] = region['name']
# create image within that newly created region # add image to tempest cleanup
post_body = self._get_image_params() self.addCleanup(
post_body['regions'][0]['name'] = region['name'] self._del_img_validate_deletion_on_dcp_and_lcp,
_, body = self.client.create_image(**post_body) post_body["id"])
self.assertIn('id', body['image'])
test_image_id = body['image']['id'] _, body = self.client.create_image(**post_body)
self.assertIn('id', body['image'])
# add image to tempest cleanup image = body['image']
self.addCleanup( _, body = self.client.get_image(image['id'])
self._del_img_validate_deletion_on_dcp_and_lcp, # since region is building it will send error
test_image_id) # notification to ORD
_, body = self.client.get_image(image['id'])
_, body = self.client.get_image(test_image_id) self.assertEqual(body['image']['id'], image['id'])
# since region is building it will give error self.assertEqual(body['image']['status'], 'error')
# Notification to ORD failed
_, body = self.client.get_image(test_image_id) @decorators.idempotent_id('b967ce58-5d24-4af2-8416-a336772c8087')
self.assertEqual(body['image']['id'], test_image_id) def test_image_while_region_maintenance(self):
self.assertEqual(body['image']['status'], 'error') # create region with status maintenance
region = self._create_region(status='maintenance')
@decorators.idempotent_id('b967ce58-5d24-4af2-8416-a336772c8087')
def test_image_while_region_maintenance(self): # get image params and add region to them
# create region with status maintenance post_body = self._get_image_params()
region = self._create_region(status='maintenance') post_body['regions'][0]['name'] = region['name']
# create image within that newly created region # add image to tempest cleanup
post_body = self._get_image_params() self.addCleanup(
post_body['regions'][0]['name'] = region['name'] self._del_img_validate_deletion_on_dcp_and_lcp,
_, body = self.client.create_image(**post_body) post_body['id'])
self.assertIn('id', body['image'])
test_image_id = body['image']['id'] _, body = self.client.create_image(**post_body)
self.assertIn('id', body['image'])
# add image to tempest cleanup image = body['image']
self.addCleanup(
self._del_img_validate_deletion_on_dcp_and_lcp, _, body = self.client.get_image(image['id'])
test_image_id) # since region is maintenance it will give error
_, body = self.client.get_image(test_image_id) # Notification to ORD failed
# since region is maintenance it will give error self.assertEqual(body['image']['id'], image['id'])
# Notification to ORD failed self.assertEqual(body['image']['status'], 'Error')
self.assertEqual(body['image']['id'], test_image_id)
self.assertEqual(body['image']['status'], 'Error') @decorators.idempotent_id('eae7ca20-5383-4579-9f73-0138b8b3ec85')
def test_list_public_images(self):
@decorators.idempotent_id('eae7ca20-5383-4579-9f73-0138b8b3ec85') """List images with visibility = 'public'"""
def test_list_public_images(self): # set_private = False to create image with visibility = 'public'
"""List images with visibility = 'public'""" post_body = self._get_image_params(set_private=False)
# set_private = False to create image with visibility = 'public' image = self._data_setup(post_body)
post_body = self._get_image_params(set_private=False) test_image_id = image['id']
image = self._data_setup(post_body) # confirm image visibility is set to "public" after image is created
test_image_id = image['id'] self.assertEqual(image["visibility"], "public")
# confirm image visibility is set to "public" after image is created filter_public_images = "?visibility=%s" % image["visibility"]
self.assertEqual(image["visibility"], "public")
filter_public_images = "?visibility=%s" % image["visibility"] # list all public images and check if test_image_id is in the list
_, body = self.client.list_images(filter_public_images)
# list all public images and check if test_image_id is in the list image_ids = [img['id'] for img in body['images']]
_, body = self.client.list_images(filter_public_images) self.assertIn(test_image_id, image_ids)
image_ids = [img['id'] for img in body['images']]
self.assertIn(test_image_id, image_ids) @decorators.idempotent_id('dc321d60-f3bd-477c-b7bf-1594626f0a12')
def test_list_private_images(self):
@decorators.idempotent_id('dc321d60-f3bd-477c-b7bf-1594626f0a12') """List images with visibility = 'private' """
def test_list_private_images(self): # image data created with visibility = private set by default
"""List images with visibility = 'private' """ post_body = self._get_image_params()
# image data created with visibility = private set by default image = self._data_setup(post_body)
post_body = self._get_image_params() # confirm image visibility is set to "private" after image is created
image = self._data_setup(post_body) self.assertEqual(image["visibility"], "private")
test_image_id = image['id'] filter_private_images = "?visibility=%s" % image["visibility"]
# confirm image visibility is set to "private" after image is created
self.assertEqual(image["visibility"], "private") # list all public images and check if image id is in the list
filter_private_images = "?visibility=%s" % image["visibility"] _, body = self.client.list_images(filter_private_images)
image_ids = [img['id'] for img in body['images']]
# list all public images and check if test_image_id is in the list self.assertIn(image['id'], image_ids)
_, body = self.client.list_images(filter_private_images)
image_ids = [img['id'] for img in body['images']] @decorators.idempotent_id('59887b26-8e73-4781-87a4-3b505ece0021')
self.assertIn(test_image_id, image_ids) def test_create_image_protected_true(self):
post_body = self._get_image_params()
@decorators.idempotent_id('59887b26-8e73-4781-87a4-3b505ece0021') # set Protected True
def test_create_image_protected_true(self): post_body['protected'] = True
post_body = self._get_image_params()
# set Protected True # add image to temepst cleanup
post_body['protected'] = True self.addCleanup(
# call client create_IMAGE and wait till status equals 'Success' self._del_img_validate_deletion_on_dcp_and_lcp,
_, body = self.client.create_image(**post_body) post_body['id'])
image = body["image"]
test_image_id = image["id"] # call client create_IMAGE and wait till status equals 'Success'
self._wait_for_image_status_on_dcp(test_image_id, 'Success') _, body = self.client.create_image(**post_body)
image = body["image"]
# add image to temepst cleanup self._wait_for_image_status_on_dcp(image['id'], 'Success')
self.addCleanup(
self._del_img_validate_deletion_on_dcp_and_lcp, # verify image record created successfully
test_image_id) _, body = self.client.get_image(image['id'])
# verify image record created successfully image = body["image"]
_, body = self.client.get_image(test_image_id) self.assertEqual(image["regions"][0]["name"], CONF.identity.region)
image = body["image"]
self.assertEqual(image["regions"][0]["name"], CONF.identity.region) @decorators.idempotent_id('56cd1de0-3908-41d5-af98-45ad95463817')
def test_create_image_with_tags_properties(self):
@decorators.idempotent_id('56cd1de0-3908-41d5-af98-45ad95463817') post_body = self._get_image_params()
def test_create_image_with_tags_properties(self): # set tags and properties
post_body = self._get_image_params() tags = ["brocade", "vyatta", "vCEImage", "mediumImage"]
# set tags and properties properties = {
tags = ["brocade", "vyatta", "vCEImage", "mediumImage"] "Application-Name": "Vyatta",
properties = { "Application-Type": "VCE",
"Application-Name": "Vyatta", "Application-Vendor": "Brocade",
"Application-Type": "VCE", "Application-Version": "3.5.R5.att-V6.0",
"Application-Vendor": "Brocade", "hw_vif_model": "VirtualVmxnet3",
"Application-Version": "3.5.R5.att-V6.0", "OS": "Debian",
"hw_vif_model": "VirtualVmxnet3", "OS-Version": "7",
"OS": "Debian", "Post-Processing-Networking": "None",
"OS-Version": "7", "Post-Processing-Tools": "None",
"Post-Processing-Networking": "None", "vmware-adaptertype": "ide",
"Post-Processing-Tools": "None", "vmware-disktype": "sparse"
"vmware-adaptertype": "ide", }
"vmware-disktype": "sparse" post_body["tags"] = tags
} post_body["properties"] = properties
post_body["tags"] = tags
post_body["properties"] = properties # add image to tempest cleanup
self.addCleanup(
# call client create_IMAGE and wait till status equals 'Success' self._del_img_validate_deletion_on_dcp_and_lcp,
_, body = self.client.create_image(**post_body) post_body['id'])
image = body["image"]
test_image_id = image["id"] # call client create_IMAGE and wait till status equals 'Success'
self._wait_for_image_status_on_dcp(test_image_id, 'Success') _, body = self.client.create_image(**post_body)
image = body["image"]
# add image to tempest cleanup self._wait_for_image_status_on_dcp(image['id'], 'Success')
self.addCleanup(
self._del_img_validate_deletion_on_dcp_and_lcp, # verify image record created successfully
test_image_id) _, body = self.client.get_image(image['id'])
# verify image record created successfully image = body["image"]
_, body = self.client.get_image(test_image_id) self.assertListEqual(image["regions"][0]["tags"], tags)
image = body["image"] self.assertDictEqual(image["regions"][0]["properties"], properties)
self.assertListEqual(image["regions"][0]["tags"], tags)
self.assertDictEqual(image["regions"][0]["properties"], properties) @decorators.idempotent_id('67aa7014-4dbb-4d66-bc7b-1a95a57494f8')
def test_create_image_with_uuid(self):
@decorators.idempotent_id('67aa7014-4dbb-4d66-bc7b-1a95a57494f8') post_body = self._get_image_params()
def test_create_image_with_uuid(self):
post_body = self._get_image_params() # add image to tempest cleanup
# set uuid self.addCleanup(
post_body['id'] = uuid.uuid4().hex self._del_img_validate_deletion_on_dcp_and_lcp,
post_body['id'])
# add image to tempest cleanup
self.addCleanup( # call client create_IMAGE and wait till status equals 'Success'
self._del_img_validate_deletion_on_dcp_and_lcp, _, body = self.client.create_image(**post_body)
post_body['id']) image = body["image"]
# call client create_IMAGE and wait till status equals 'Success' self._wait_for_image_status_on_dcp(image['id'], 'Success')
_, body = self.client.create_image(**post_body)
image = body["image"] # verify image record created successfully
_, body = self.client.get_image(image['id'])
self._wait_for_image_status_on_dcp(post_body['id'], 'Success') image = body["image"]
self.assertEqual(image["regions"][0]['id'], post_body['id'])
# verify image record created successfully
_, body = self.client.get_image(post_body['id']) @decorators.idempotent_id('ae1223b5-cb75-442b-82eb-488969acc978')
image = body["image"] def test_create_image_with_region_group(self):
self.assertEqual(image["regions"][0]["id"], post_body['id'])
# grab image details needed for image build
@decorators.idempotent_id('ae1223b5-cb75-442b-82eb-488969acc978') post_body = self._get_image_params()
def test_create_image_with_region_group(self): # define a region group
post_body = self._get_image_params() region_group = {"name": "NCLargetest", "type": "group"}
# region group # add region_group to regions in image
region_group = {"name": "NCLargetest", "type": "group"} post_body["regions"].append(region_group)
# update region_group to regions
post_body["regions"].append(region_group) # add image to tempest cleanup
# add image to tempest cleanup self.addCleanup(
self.addCleanup( self._del_img_validate_deletion_on_dcp_and_lcp,
self._del_img_validate_deletion_on_dcp_and_lcp, post_body['id'])
post_body["id"])
# call client create_IMAGE and wait till status equals 'Success'
# call client create_IMAGE and wait till status equals 'Success' _, body = self.client.create_image(**post_body)
_, body = self.client.create_image(**post_body)
image = body["image"] # set object to built image and wait until it is ready for use
test_image_id = image["id"] image = body["image"]
self._wait_for_image_status_on_dcp(test_image_id, 'Success') self._wait_for_image_status_on_dcp(image['id'], 'Success')
# verify image record created successfully # verify image record created successfully
_, body = self.client.get_image(test_image_id) _, body = self.client.get_image(image['id'])
image = body["image"] image = body["image"]
# Aggregate Status # Aggregate Status
self.assertEqual(image["status"], 'Success') self.assertEqual(image["status"], 'Success')
# Region Status # Region Status
self.assertEqual(image["regions"][1]["status"], 'Success') self.assertEqual(image["regions"][1]["status"], 'Success')
# region group # region group
self.assertDictEqual(image["regions"][1]["name"], "NCLargetest") self.assertDictEqual(image["regions"][1]["name"], "NCLargetest")